/*-------------------------------------------------------------------------
 * 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
 */ /*-------------------------------------------------------------------*/

#include "es31cArrayOfArraysTests.hpp"
#include "gluContextInfo.hpp"
#include "gluDefs.hpp"
#include "gluRenderContext.hpp"
#include "glwFunctions.hpp"
#include "tcuTestLog.hpp"

#include <algorithm>
#include <cassert>
#include <cstdio>
#include <string>
using std::string;

/* Selects if debug output is enabled */
#define IS_DEBUG 0
#define IS_DEBUG_DUMP_ALL_SHADERS 0

/* Selects if workaround in ExpressionsInvalid2 test is enabled */
#define WRKARD_EXPRESSIONSINVALID2 0

#if IS_DEBUG
#include "tcuTestLog.hpp"
#endif

namespace glcts
{
namespace ArraysOfArrays
{
namespace Interface
{
/* Sets limits on number of dimensions. Value 8 comes from ogirinal "ES" implementation.
 * Explanation was as follows:
 *
 *     "The current specifations allow up to 8 array dimensions."
 */
const size_t ES::MAX_ARRAY_DIMENSIONS = 8;
const size_t GL::MAX_ARRAY_DIMENSIONS = 8;

/* API specific shader parts */
const char *ES::shader_version_gpu5 =
    "#version 310 es\n#extension GL_EXT_gpu_shader5 : require\nprecision mediump float;\n\n";
const char *ES::shader_version = "#version 310 es\nprecision mediump float;\n\n";

const char *GL::shader_version_gpu5 = "#version 430 core\n\n";
const char *GL::shader_version      = "#version 430 core\n\n";
} /* namespace Interface */

/* Dummy fragment shader source code.
 * Used when testing the vertex shader. */
const std::string default_fragment_shader_source = "//default fragment shader\n"
                                                   "out vec4 color;\n"
                                                   "void main()\n"
                                                   "{\n"
                                                   "    color = vec4(1.0);\n"
                                                   "}\n";

/* Dummy vertex shader source code.
 * Used when testing the fragment shader. */
const std::string default_vertex_shader_source = "//default vertex shader\n"
                                                 "\n"
                                                 "void main()\n"
                                                 "{\n"
                                                 "    gl_Position = vec4(0.0,0.0,0.0,1.0);\n"
                                                 "}\n";

/* Dummy geometry shader source code.
 * Used when testing the other shaders. */
const std::string default_geometry_shader_source = "//default geometry\n"
                                                   "\n"
                                                   "void main()\n"
                                                   "{\n"
                                                   "    gl_Position  = vec4(-1, -1, 0, 1);\n"
                                                   "    EmitVertex();\n"
                                                   "    gl_Position  = vec4(-1, 1, 0, 1);\n"
                                                   "    EmitVertex();\n"
                                                   "    gl_Position  = vec4(1, -1, 0, 1);\n"
                                                   "    EmitVertex();\n"
                                                   "    gl_Position  = vec4(1, 1, 0, 1);\n"
                                                   "    EmitVertex();\n"
                                                   "}\n";

/* Dummy tesselation control shader source code.
 * Used when testing the other shaders. */
const std::string default_tc_shader_source = "//default tcs\n"
                                             "\n"
                                             "void main()\n"
                                             "{\n"
                                             "    gl_TessLevelOuter[0] = 1.0;\n"
                                             "    gl_TessLevelOuter[1] = 1.0;\n"
                                             "    gl_TessLevelOuter[2] = 1.0;\n"
                                             "    gl_TessLevelOuter[3] = 1.0;\n"
                                             "    gl_TessLevelInner[0] = 1.0;\n"
                                             "    gl_TessLevelInner[1] = 1.0;\n"
                                             "}\n";

/* Dummy tesselation evaluation shader source code.
 * Used when testing the other shaders. */
const std::string default_te_shader_source = "//default tes\n"
                                             "\n"
                                             "void main()\n"
                                             "{\n"
                                             "}\n";

/* Pass-through shaders source code. Used when testing other stage. */
const std::string pass_fragment_shader_source = "//pass fragment shader\n"
                                                "in float fs_result;\n"
                                                "out vec4 color;\n"
                                                "\n"
                                                "void main()\n"
                                                "{\n"
                                                "    color = vec4(fs_result);\n"
                                                "}\n";

const std::string pass_geometry_shader_source = "//pass geometry\n"
                                                "in  float gs_result[];\n"
                                                "out float fs_result;\n"
                                                "\n"
                                                "void main()\n"
                                                "{\n"
                                                "    gl_Position  = vec4(-1, -1, 0, 1);\n"
                                                "    fs_result = gs_result[0];\n"
                                                "    EmitVertex();\n"
                                                "    gl_Position  = vec4(-1, 1, 0, 1);\n"
                                                "    fs_result = gs_result[0];\n"
                                                "    EmitVertex();\n"
                                                "    gl_Position  = vec4(1, -1, 0, 1);\n"
                                                "    fs_result = gs_result[0];\n"
                                                "    EmitVertex();\n"
                                                "    gl_Position  = vec4(1, 1, 0, 1);\n"
                                                "    fs_result = gs_result[0];\n"
                                                "    EmitVertex();\n"
                                                "}\n";

const std::string pass_te_shader_source = "//pass tes\n"
                                          "in  float tcs_result[];\n"
                                          "out float fs_result;\n"
                                          "\n"
                                          "void main()\n"
                                          "{\n"
                                          "    fs_result = tcs_result[0];\n"
                                          "}\n";

/* Empty string */
static const std::string empty_string = "";

/* Beginning of a shader source code. */
const std::string shader_start = "void main()\n"
                                 "{\n";

/* End of a shader source code. */
const std::string shader_end = "}\n";

/* Emit full screen quad from GS */
const std::string emit_quad = "    gl_Position  = vec4(-1, -1, 0, 1);\n"
                              "    EmitVertex();\n"
                              "    gl_Position  = vec4(-1, 1, 0, 1);\n"
                              "    EmitVertex();\n"
                              "    gl_Position  = vec4(1, -1, 0, 1);\n"
                              "    EmitVertex();\n"
                              "    gl_Position  = vec4(1, 1, 0, 1);\n"
                              "    EmitVertex();\n";

/* Set tesselation levels */
const std::string set_tesseation = "    gl_TessLevelOuter[0] = 1.0;\n"
                                   "    gl_TessLevelOuter[1] = 1.0;\n"
                                   "    gl_TessLevelOuter[2] = 1.0;\n"
                                   "    gl_TessLevelOuter[3] = 1.0;\n"
                                   "    gl_TessLevelInner[0] = 1.0;\n"
                                   "    gl_TessLevelInner[1] = 1.0;\n";

/* Input and output data type modifiers. */
const std::string in_out_type_modifiers[] = {"in", "out", "uniform"};

/* Types and appropriate initialisers, used throughout these tests */
const var_descriptor var_descriptors[] = {
    {"bool", "", "true", "false", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"int", "", "1", "0", "0", "int", "", "iterator", "1", "N/A", "N/A"},
    {"uint", "", "1u", "0u", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"float", "", "1.0", "0.0", "0.0", "float", "", "iterator", "1.0", "N/A", "N/A"},
    {"vec2", "", "vec2(1.0)", "vec2(0.0)", "0.0", "float", "[0]", "vec2(iterator)", "vec2(1.0)", "N/A", "N/A"},
    {"vec3", "", "vec3(1.0)", "vec3(0.0)", "0.0", "float", "[0]", "vec3(iterator)", "vec3(1.0)", "N/A", "N/A"},
    {"vec4", "", "vec4(1.0)", "vec4(0.0)", "0.0", "float", "[0]", "vec4(iterator)", "vec4(1.0)", "N/A", "N/A"},
    {"bvec2", "", "bvec2(1)", "bvec2(0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"bvec3", "", "bvec3(1)", "bvec3(0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"bvec4", "", "bvec4(1)", "bvec4(0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"ivec2", "", "ivec2(1)", "ivec2(0)", "0", "int", "[0]", "ivec2(iterator)", "ivec2(1)", "N/A", "N/A"},
    {"ivec3", "", "ivec3(1)", "ivec3(0)", "0", "int", "[0]", "ivec3(iterator)", "ivec3(1)", "N/A", "N/A"},
    {"ivec4", "", "ivec4(1)", "ivec4(0)", "0", "int", "[0]", "ivec4(iterator)", "ivec4(1)", "N/A", "N/A"},
    {"uvec2", "", "uvec2(1u)", "uvec2(0u)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"uvec3", "", "uvec3(1u)", "uvec3(0u)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"uvec4", "", "uvec4(1u)", "uvec4(0u)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"mat2", "", "mat2(1.0)", "mat2(0.0)", "0.0", "float", "[0][0]", "mat2(iterator)", "mat2(1.0)", "N/A", "N/A"},
    {"mat3", "", "mat3(1.0)", "mat3(0.0)", "0.0", "float", "[0][0]", "mat3(iterator)", "mat3(1.0)", "N/A", "N/A"},
    {"mat4", "", "mat4(1.0)", "mat4(0.0)", "0.0", "float", "[0][0]", "mat4(iterator)", "mat4(1.0)", "N/A", "N/A"},
    {"mat2x2", "", "mat2x2(1.0)", "mat2x2(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"mat2x3", "", "mat2x3(1.0)", "mat2x3(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"mat2x4", "", "mat2x4(1.0)", "mat2x4(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"mat3x2", "", "mat3x2(1.0)", "mat3x2(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"mat3x3", "", "mat3x3(1.0)", "mat3x3(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"mat3x4", "", "mat3x4(1.0)", "mat3x4(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"mat4x2", "", "mat4x2(1.0)", "mat4x2(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"mat4x3", "", "mat4x3(1.0)", "mat4x3(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"mat4x4", "", "mat4x4(1.0)", "mat4x4(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"imageBuffer", "", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"iimageBuffer", "", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"uimageBuffer", "", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"samplerBuffer", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"isamplerBuffer", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"usamplerBuffer", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"sampler2D", "", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec2(0.0)", "vec4"},
    {"sampler3D", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "vec4"},
    {"samplerCube", "", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "vec4"},
    {
        "samplerCubeShadow",
        "lowp",
        "N/A",
        "N/A",
        "N/A",
        "N/A",
        "N/A",
        "N/A",
        "N/A",
        "vec4(0.0)",
        "float",
    },
    {"sampler2DShadow", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "float"},
    {"sampler2DArray", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "vec4"},
    {"sampler2DArrayShadow", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec4(0.0)", "float"},
    {"isampler2D", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec2(0.0)", "ivec4"},
    {"isampler3D", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "ivec4"},
    {"isamplerCube", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "ivec4"},
    {"isampler2DArray", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "ivec4"},
    {"usampler2D", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec2(0.0)", "uvec4"},
    {"usampler3D", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "uvec4"},
    {"usamplerCube", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "uvec4"},
    {"usampler2DArray", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "uvec4"},
};

const var_descriptor var_double_descriptors[] = {
    {"double", "", "1.0", "0.0", "0.0", "double", "", "iterator", "1.0", "N/A", "N/A"},
    {"dmat2", "", "dmat2(1.0)", "dmat2(0.0)", "0.0", "double", "[0][0]", "dmat2(iterator)", "dmat2(1.0)", "N/A", "N/A"},
    {"dmat3", "", "dmat3(1.0)", "dmat3(0.0)", "0.0", "double", "[0][0]", "dmat3(iterator)", "dmat3(1.0)", "N/A", "N/A"},
    {"dmat4", "", "dmat4(1.0)", "dmat4(0.0)", "0.0", "double", "[0][0]", "dmat4(iterator)", "dmat4(1.0)", "N/A", "N/A"},
    {"dmat2x2", "", "dmat2x2(1.0)", "dmat2x2(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"dmat2x3", "", "dmat2x3(1.0)", "dmat2x3(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"dmat2x4", "", "dmat2x4(1.0)", "dmat2x4(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"dmat3x2", "", "dmat3x2(1.0)", "dmat3x2(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"dmat3x3", "", "dmat3x3(1.0)", "dmat3x3(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"dmat3x4", "", "dmat3x4(1.0)", "dmat3x4(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"dmat4x2", "", "dmat4x2(1.0)", "dmat4x2(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"dmat4x3", "", "dmat4x3(1.0)", "dmat4x3(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
    {"dmat4x4", "", "dmat4x4(1.0)", "dmat4x4(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"},
};

_supported_variable_types_map supported_variable_types_map;

/** List of all supported variable types for es. */
const test_var_type var_types_es[] = {
    VAR_TYPE_BOOL,   VAR_TYPE_INT,    VAR_TYPE_UINT,   VAR_TYPE_FLOAT,  VAR_TYPE_VEC2,   VAR_TYPE_VEC3,
    VAR_TYPE_VEC4,   VAR_TYPE_BVEC2,  VAR_TYPE_BVEC3,  VAR_TYPE_BVEC4,  VAR_TYPE_IVEC2,  VAR_TYPE_IVEC3,
    VAR_TYPE_IVEC4,  VAR_TYPE_UVEC2,  VAR_TYPE_UVEC3,  VAR_TYPE_UVEC4,  VAR_TYPE_MAT2,   VAR_TYPE_MAT3,
    VAR_TYPE_MAT4,   VAR_TYPE_MAT2X2, VAR_TYPE_MAT2X3, VAR_TYPE_MAT2X4, VAR_TYPE_MAT3X2, VAR_TYPE_MAT3X3,
    VAR_TYPE_MAT3X4, VAR_TYPE_MAT4X2, VAR_TYPE_MAT4X3, VAR_TYPE_MAT4X4,
};

const test_var_type *Interface::ES::var_types = var_types_es;
const size_t Interface::ES::n_var_types       = sizeof(var_types_es) / sizeof(var_types_es[0]);

/** List of all supported variable types for gl. */
static const glcts::test_var_type var_types_gl[] = {
    VAR_TYPE_BOOL,    VAR_TYPE_INT,     VAR_TYPE_UINT,    VAR_TYPE_FLOAT,   VAR_TYPE_VEC2,    VAR_TYPE_VEC3,
    VAR_TYPE_VEC4,    VAR_TYPE_BVEC2,   VAR_TYPE_BVEC3,   VAR_TYPE_BVEC4,   VAR_TYPE_IVEC2,   VAR_TYPE_IVEC3,
    VAR_TYPE_IVEC4,   VAR_TYPE_UVEC2,   VAR_TYPE_UVEC3,   VAR_TYPE_UVEC4,   VAR_TYPE_MAT2,    VAR_TYPE_MAT3,
    VAR_TYPE_MAT4,    VAR_TYPE_MAT2X2,  VAR_TYPE_MAT2X3,  VAR_TYPE_MAT2X4,  VAR_TYPE_MAT3X2,  VAR_TYPE_MAT3X3,
    VAR_TYPE_MAT3X4,  VAR_TYPE_MAT4X2,  VAR_TYPE_MAT4X3,  VAR_TYPE_MAT4X4,  VAR_TYPE_DOUBLE,  VAR_TYPE_DMAT2,
    VAR_TYPE_DMAT3,   VAR_TYPE_DMAT4,   VAR_TYPE_DMAT2X2, VAR_TYPE_DMAT2X3, VAR_TYPE_DMAT2X4, VAR_TYPE_DMAT3X2,
    VAR_TYPE_DMAT3X3, VAR_TYPE_DMAT3X4, VAR_TYPE_DMAT4X2, VAR_TYPE_DMAT4X3, VAR_TYPE_DMAT4X4,
};

const test_var_type *Interface::GL::var_types = var_types_gl;
const size_t Interface::GL::n_var_types       = sizeof(var_types_gl) / sizeof(var_types_gl[0]);

/** List of all supported opaque types. */
const glcts::test_var_type opaque_var_types[] = {
    //Floating Point Sampler Types (opaque)
    VAR_TYPE_SAMPLER2D,
    VAR_TYPE_SAMPLER3D,
    VAR_TYPE_SAMPLERCUBE,
    VAR_TYPE_SAMPLERCUBESHADOW,
    VAR_TYPE_SAMPLER2DSHADOW,
    VAR_TYPE_SAMPLER2DARRAY,
    VAR_TYPE_SAMPLER2DARRAYSHADOW,
    //Signed Integer Sampler Types (opaque)
    VAR_TYPE_ISAMPLER2D,
    VAR_TYPE_ISAMPLER3D,
    VAR_TYPE_ISAMPLERCUBE,
    VAR_TYPE_ISAMPLER2DARRAY,
    //Unsigned Integer Sampler Types (opaque)
    VAR_TYPE_USAMPLER2D,
    VAR_TYPE_USAMPLER3D,
    VAR_TYPE_USAMPLERCUBE,
    VAR_TYPE_USAMPLER2DARRAY,
};

/** Sets up the type map that will be used to look up the type names, initialisation
 *  values, etc., associated with each of the types used within the array tests
 *
 **/
template <class API>
void initializeMap()
{
    int temp_index = 0;

    // Set up the map
    supported_variable_types_map[VAR_TYPE_BOOL]                 = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_INT]                  = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_UINT]                 = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_FLOAT]                = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_VEC2]                 = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_VEC3]                 = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_VEC4]                 = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_BVEC2]                = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_BVEC3]                = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_BVEC4]                = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_IVEC2]                = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_IVEC3]                = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_IVEC4]                = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_UVEC2]                = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_UVEC3]                = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_UVEC4]                = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_MAT2]                 = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_MAT3]                 = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_MAT4]                 = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_MAT2X2]               = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_MAT2X3]               = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_MAT2X4]               = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_MAT3X2]               = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_MAT3X3]               = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_MAT3X4]               = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_MAT4X2]               = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_MAT4X3]               = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_MAT4X4]               = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_IMAGEBUFFER]          = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_IIMAGEBUFFER]         = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_UIMAGEBUFFER]         = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_SAMPLERBUFFER]        = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_ISAMPLERBUFFER]       = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_USAMPLERBUFFER]       = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_SAMPLER2D]            = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_SAMPLER3D]            = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_SAMPLERCUBE]          = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_SAMPLERCUBESHADOW]    = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_SAMPLER2DSHADOW]      = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_SAMPLER2DARRAY]       = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_SAMPLER2DARRAYSHADOW] = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_ISAMPLER2D]           = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_ISAMPLER3D]           = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_ISAMPLERCUBE]         = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_ISAMPLER2DARRAY]      = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_USAMPLER2D]           = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_USAMPLER3D]           = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_USAMPLERCUBE]         = var_descriptors[temp_index++];
    supported_variable_types_map[VAR_TYPE_USAMPLER2DARRAY]      = var_descriptors[temp_index++];

    if (API::USE_DOUBLE)
    {
        temp_index = 0;

        supported_variable_types_map[VAR_TYPE_DOUBLE]  = var_double_descriptors[temp_index++];
        supported_variable_types_map[VAR_TYPE_DMAT2]   = var_double_descriptors[temp_index++];
        supported_variable_types_map[VAR_TYPE_DMAT3]   = var_double_descriptors[temp_index++];
        supported_variable_types_map[VAR_TYPE_DMAT4]   = var_double_descriptors[temp_index++];
        supported_variable_types_map[VAR_TYPE_DMAT2X2] = var_double_descriptors[temp_index++];
        supported_variable_types_map[VAR_TYPE_DMAT2X3] = var_double_descriptors[temp_index++];
        supported_variable_types_map[VAR_TYPE_DMAT2X4] = var_double_descriptors[temp_index++];
        supported_variable_types_map[VAR_TYPE_DMAT3X2] = var_double_descriptors[temp_index++];
        supported_variable_types_map[VAR_TYPE_DMAT3X3] = var_double_descriptors[temp_index++];
        supported_variable_types_map[VAR_TYPE_DMAT3X4] = var_double_descriptors[temp_index++];
        supported_variable_types_map[VAR_TYPE_DMAT4X2] = var_double_descriptors[temp_index++];
        supported_variable_types_map[VAR_TYPE_DMAT4X3] = var_double_descriptors[temp_index++];
        supported_variable_types_map[VAR_TYPE_DMAT4X4] = var_double_descriptors[temp_index++];
    }
}

/** Macro appends default ending of main function to source string
 *
 * @param SOURCE Tested shader source
 **/
#define DEFAULT_MAIN_ENDING(TYPE, SOURCE)                           \
    do                                                              \
    {                                                               \
        /* Apply stage specific stuff */                            \
        switch (TYPE)                                               \
        {                                                           \
        case TestCaseBase<API>::VERTEX_SHADER_TYPE:                 \
            SOURCE += "\n    gl_Position = vec4(0.0);\n";           \
            break;                                                  \
        case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:               \
            break;                                                  \
        case TestCaseBase<API>::COMPUTE_SHADER_TYPE:                \
            break;                                                  \
        case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:               \
            SOURCE += emit_quad;                                    \
            break;                                                  \
        case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:    \
            SOURCE += set_tesseation;                               \
            break;                                                  \
        case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: \
            break;                                                  \
        default:                                                    \
            TCU_FAIL("Unrecognized shader type.");                  \
            break;                                                  \
        }                                                           \
                                                                    \
        /* End main function */                                     \
        SOURCE += shader_end;                                       \
    } while (0)

/** Macro executes positive test selected on USE_ALL_SHADER_STAGES
 *
 * @param TYPE    Tested shader stage
 * @param SOURCE Tested shader source
 * @param DELETE Selects if program should be deleted afterwards
 **/
#define EXECUTE_POSITIVE_TEST(TYPE, SOURCE, DELETE, GPU5)                                                             \
    do                                                                                                                \
    {                                                                                                                 \
        const std::string *cs  = &empty_string;                                                                       \
        const std::string *vs  = &default_vertex_shader_source;                                                       \
        const std::string *tcs = &default_tc_shader_source;                                                           \
        const std::string *tes = &default_te_shader_source;                                                           \
        const std::string *fs  = &default_fragment_shader_source;                                                     \
                                                                                                                      \
        switch (TYPE)                                                                                                 \
        {                                                                                                             \
        case TestCaseBase<API>::COMPUTE_SHADER_TYPE:                                                                  \
            this->execute_positive_test(empty_string, empty_string, empty_string, empty_string, empty_string, SOURCE, \
                                        DELETE, GPU5);                                                                \
            break;                                                                                                    \
        case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:                                                                 \
            this->execute_positive_test(*vs, SOURCE, DELETE, GPU5);                                                   \
            break;                                                                                                    \
        case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:                                                                 \
            this->execute_positive_test(*vs, empty_string, empty_string, SOURCE, *fs, *cs, DELETE, GPU5);             \
            break;                                                                                                    \
        case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:                                                      \
            this->execute_positive_test(*vs, SOURCE, *tes, empty_string, *fs, *cs, DELETE, GPU5);                     \
            break;                                                                                                    \
        case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:                                                   \
            this->execute_positive_test(*vs, *tcs, SOURCE, empty_string, *fs, *cs, DELETE, GPU5);                     \
            break;                                                                                                    \
        case TestCaseBase<API>::VERTEX_SHADER_TYPE:                                                                   \
            this->execute_positive_test(SOURCE, *fs, DELETE, GPU5);                                                   \
            break;                                                                                                    \
        default:                                                                                                      \
            TCU_FAIL("Invalid enum");                                                                                 \
            break;                                                                                                    \
        };                                                                                                            \
    } while (0)

/** Macro executes either positive or negative test
 *
 * @param S        Selects negative test when 0, positive test otherwise
 * @param TYPE    Tested shader stage
 * @param SOURCE Tested shader source
 **/
#define EXECUTE_SHADER_TEST(S, TYPE, SOURCE)                  \
    do                                                        \
    {                                                         \
        if (S)                                                \
        {                                                     \
            EXECUTE_POSITIVE_TEST(TYPE, SOURCE, true, false); \
        }                                                     \
        else                                                  \
        {                                                     \
            this->execute_negative_test(TYPE, SOURCE);        \
        }                                                     \
    } while (0)

/** Test case constructor.
 *
 * @tparam API        Tested API descriptor
 *
 * @param context     EGL context ID.
 * @param name        Name of a test case.
 * @param description Test case description.
 **/
template <class API>
TestCaseBase<API>::TestCaseBase(Context &context, const char *name, const char *description)
    : tcu::TestCase(context.getTestContext(), name, description)
    , context_id(context)
    , program_object_id(0)
    , compute_shader_object_id(0)
    , fragment_shader_object_id(0)
    , geometry_shader_object_id(0)
    , tess_ctrl_shader_object_id(0)
    , tess_eval_shader_object_id(0)
    , vertex_shader_object_id(0)
{
    /* Left blank on purpose */
}

/** Clears up the shaders and program that were created during the tests
 *
 * @tparam API Tested API descriptor
 */
template <class API>
void TestCaseBase<API>::delete_objects(void)
{
    const glw::Functions &gl = context_id.getRenderContext().getFunctions();

    /* Release all ES objects that may have been created by iterate() */
    if (program_object_id != 0)
    {
        gl.deleteProgram(program_object_id);
        program_object_id = 0;
    }

    /* Use default program object to be sure the objects were released. */
    gl.useProgram(0);
}

/** Releases all OpenGL ES objects that were created for test case purposes.
 *
 * @tparam API Tested API descriptor
 */
template <class API>
void TestCaseBase<API>::deinit(void)
{
    this->delete_objects();
}

/** Runs the actual test for each shader type.
 *
 * @tparam API               Tested API descriptor
 *
 *  @return QP_TEST_RESULT_FAIL - test has failed;
 *          QP_TEST_RESULT_PASS - test has succeeded;
 **/
template <class API>
tcu::TestNode::IterateResult TestCaseBase<API>::iterate(void)
{
    test_shader_compilation(TestCaseBase<API>::VERTEX_SHADER_TYPE);
    test_shader_compilation(TestCaseBase<API>::FRAGMENT_SHADER_TYPE);

    if (API::USE_ALL_SHADER_STAGES)
    {
        test_shader_compilation(TestCaseBase<API>::COMPUTE_SHADER_TYPE);
        test_shader_compilation(TestCaseBase<API>::GEOMETRY_SHADER_TYPE);
        test_shader_compilation(TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE);
        test_shader_compilation(TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE);
    }

    return STOP;
}

/** Generates a shader object of the specified type,
 *  attaches the specified shader source,
 *  compiles it, and returns the compilation result.
 *
 * @tparam API               Tested API descriptor
 *
 * @param shader_source      The source for the shader object.
 * @param tested_shader_type The type of shader being compiled (vertex or fragment).
 *
 * @return Compilation result (GL_TRUE if the shader compilation succeeded, GL_FALSE otherwise).
 **/
template <class API>
glw::GLint TestCaseBase<API>::compile_shader_and_get_compilation_result(const std::string &tested_snippet,
                                                                        TestShaderType tested_shader_type,
                                                                        bool require_gpu_shader5)
{
    static const char *preamble_cs = "\n"
                                     "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
                                     "\n";

    static const char *preamble_gs = "\n"
                                     "layout(points)                           in;\n"
                                     "layout(triangle_strip, max_vertices = 4) out;\n"
                                     "\n";

    static const char *preamble_tcs = "\n"
                                      "layout(vertices = 1) out;\n"
                                      "\n";

    static const char *preamble_tes = "\n"
                                      "layout(isolines, point_mode) in;\n"
                                      "\n";

    glw::GLint compile_status   = GL_TRUE;
    const glw::Functions &gl    = context_id.getRenderContext().getFunctions();
    glw::GLint shader_object_id = 0;

    std::string shader_source;

    if (true == tested_snippet.empty())
    {
        return compile_status;
    }

    if (require_gpu_shader5)
    {
        // Add the version number here, rather than in each individual test
        shader_source = API::shader_version_gpu5;
    }
    else
    {
        // Add the version number here, rather than in each individual test
        shader_source = API::shader_version;
    }

    /* Apply stage specific stuff */
    switch (tested_shader_type)
    {
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        break;
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        break;
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        shader_source += preamble_cs;
        break;
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        shader_source += preamble_gs;
        break;
    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        shader_source += preamble_tcs;
        break;
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        shader_source += preamble_tes;
        break;
    default:
        TCU_FAIL("Unrecognized shader type.");
        break;
    }

    shader_source += tested_snippet;

    /* Prepare shader object */
    switch (tested_shader_type)
    {
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
    {
        shader_object_id = gl.createShader(GL_VERTEX_SHADER);
        assert(0 == vertex_shader_object_id);
        vertex_shader_object_id = shader_object_id;

        GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a vertex shader.");

        break;
    } /* case TestCaseBase<API>::VERTEX_SHADER_TYPE: */
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
    {
        shader_object_id = gl.createShader(GL_FRAGMENT_SHADER);
        assert(0 == fragment_shader_object_id);
        fragment_shader_object_id = shader_object_id;

        GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a fragment shader.");

        break;
    } /* case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: */
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    {
        shader_object_id = gl.createShader(GL_COMPUTE_SHADER);
        assert(0 == compute_shader_object_id);
        compute_shader_object_id = shader_object_id;

        GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a compute shader.");

        break;
    } /* case TestCaseBase<API>::COMPUTE_SHADER_TYPE: */
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    {
        shader_object_id = gl.createShader(GL_GEOMETRY_SHADER);
        assert(0 == geometry_shader_object_id);
        geometry_shader_object_id = shader_object_id;

        GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a geometry shader.");

        break;
    } /* case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: */
    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
    {
        shader_object_id = gl.createShader(GL_TESS_CONTROL_SHADER);
        assert(0 == tess_ctrl_shader_object_id);
        tess_ctrl_shader_object_id = shader_object_id;

        GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a tesselation control shader.");

        break;
    } /* case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: */
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
    {
        shader_object_id = gl.createShader(GL_TESS_EVALUATION_SHADER);
        assert(0 == tess_eval_shader_object_id);
        tess_eval_shader_object_id = shader_object_id;

        GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a tesselation evaluation shader.");

        break;
    } /* case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: */
    default:
    {
        TCU_FAIL("Unrecognized shader type.");

        break;
    } /* default: */
    } /* switch (tested_shader_type) */

    /* Assign source code to the objects */
    const char *code_ptr = shader_source.c_str();

#if IS_DEBUG_DUMP_ALL_SHADERS
    context_id.getTestContext().getLog() << tcu::TestLog::Message << "Compiling: " << tcu::TestLog::EndMessage;
    context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(code_ptr);
#endif /* IS_DEBUG_DUMP_ALL_SHADERS */

    gl.shaderSource(shader_object_id, 1 /* count */, &code_ptr, NULL);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() failed");

    /* Compile the shader */
    gl.compileShader(shader_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() failed");

    /* Get the compilation result. */
    gl.getShaderiv(shader_object_id, GL_COMPILE_STATUS, &compile_status);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() failed");

#if IS_DEBUG
    if (GL_TRUE != compile_status)
    {
        glw::GLint length = 0;
        std::string message;

        /* Error log length */
        gl.getShaderiv(shader_object_id, GL_INFO_LOG_LENGTH, &length);
        GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv");

        /* Prepare storage */
        message.resize(length, 0);

        /* Get error log */
        gl.getShaderInfoLog(shader_object_id, length, 0, &message[0]);
        GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderInfoLog");

        context_id.getTestContext().getLog()
            << tcu::TestLog::Message << "Error message: " << &message[0] << tcu::TestLog::EndMessage;

#if IS_DEBUG_DUMP_ALL_SHADERS
#else  /* IS_DEBUG_DUMP_ALL_SHADERS */
        context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(code_ptr);
#endif /* IS_DEBUG_DUMP_ALL_SHADERS */
    }
#endif /* IS_DEBUG */

    return compile_status;
}

/** Runs the negative test.
 *  The shader sources are considered as invalid,
 *  and the compilation of a shader object with the specified
 *  shader source is expected to fail.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader object (can be fragment or vertex).
 * @param shader_source      The source for the shader object to be used for this test.
 *
 *  @return QP_TEST_RESULT_FAIL - test has failed;
 *          QP_TEST_RESULT_PASS - test has succeeded;
 **/
template <class API>
tcu::TestNode::IterateResult TestCaseBase<API>::execute_negative_test(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &shader_source)
{
    glw::GLint compile_status = GL_FALSE;
    const char *error_message = 0;
    const glw::Functions &gl  = context_id.getRenderContext().getFunctions();
    bool test_result          = true;

    /* Try to generate and compile the shader object. */
    switch (tested_shader_type)
    {
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        error_message =
            "The fragment shader was expected to fail to compile, but the compilation process was successful.";
        break;

    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        error_message =
            "The vertex shader was expected to fail to compile, but the compilation process was successful.";

        break;

    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        error_message =
            "The compute shader was expected to fail to compile, but the compilation process was successful.";
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        error_message =
            "The geometry shader was expected to fail to compile, but the compilation process was successful.";
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        error_message = "The tesselation control shader was expected to fail to compile, but the compilation process "
                        "was successful.";
        break;

    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        error_message = "The tesselation evaluation shader was expected to fail to compile, but the compilation "
                        "process was successful.";
        break;

    default:
        TCU_FAIL("Unrecognized shader type.");
        test_result = false;

        break;
    } /* switch (shader_type) */

    compile_status = compile_shader_and_get_compilation_result(shader_source, tested_shader_type);

    if (compile_status == GL_TRUE)
    {
        TCU_FAIL(error_message);

        test_result = false;
    }

    /* Deallocate any resources used. */
    this->delete_objects();
    if (0 != compute_shader_object_id)
    {
        gl.deleteShader(compute_shader_object_id);
        compute_shader_object_id = 0;
    }
    if (0 != fragment_shader_object_id)
    {
        gl.deleteShader(fragment_shader_object_id);
        fragment_shader_object_id = 0;
    }
    if (0 != geometry_shader_object_id)
    {
        gl.deleteShader(geometry_shader_object_id);
        geometry_shader_object_id = 0;
    }
    if (0 != tess_ctrl_shader_object_id)
    {
        gl.deleteShader(tess_ctrl_shader_object_id);
        tess_ctrl_shader_object_id = 0;
    }
    if (0 != tess_eval_shader_object_id)
    {
        gl.deleteShader(tess_eval_shader_object_id);
        tess_eval_shader_object_id = 0;
    }
    if (0 != vertex_shader_object_id)
    {
        gl.deleteShader(vertex_shader_object_id);
        vertex_shader_object_id = 0;
    }

    /* Return test pass if true. */
    if (true == test_result)
    {
        m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    }

    return CONTINUE;
}

/** Runs the positive test.
 *  The shader sources are considered as valid,
 *  and the compilation and program linking are expected to succeed.
 *
 * @tparam API                     Tested API descriptor
 *
 * @param vertex_shader_source     The source for the vertex shader to be used for this test.
 * @param fragment_shader_source   The source for the fragment shader to be used for this test.
 * @param delete_generated_objects If true, the compiled shader objects will be deleted before returning.
 *
 *  @return QP_TEST_RESULT_FAIL - test has failed;
 *          QP_TEST_RESULT_PASS - test has succeeded;
 **/
template <class API>
tcu::TestNode::IterateResult TestCaseBase<API>::execute_positive_test(const std::string &vertex_shader_source,
                                                                      const std::string &fragment_shader_source,
                                                                      bool delete_generated_objects,
                                                                      bool require_gpu_shader5)
{
    glw::GLint compile_status = GL_TRUE;
    const glw::Functions &gl  = context_id.getRenderContext().getFunctions();
    glw::GLint link_status    = GL_TRUE;
    bool test_result          = true;

    /* Compile, and check the compilation result for the fragment shader object. */
    compile_status = compile_shader_and_get_compilation_result(
        fragment_shader_source, TestCaseBase<API>::FRAGMENT_SHADER_TYPE, require_gpu_shader5);

    if (compile_status == GL_FALSE)
    {
        TCU_FAIL("The fragment shader was expected to compile successfully, but failed to compile.");

        test_result = false;
    }

    /* Compile, and check the compilation result for the vertex shader object. */
    compile_status = compile_shader_and_get_compilation_result(
        vertex_shader_source, TestCaseBase<API>::VERTEX_SHADER_TYPE, require_gpu_shader5);

    if (compile_status == GL_FALSE)
    {
        TCU_FAIL("The vertex shader was expected to compile successfully, but failed to compile.");

        test_result = false;
    }

    if (true == test_result)
    {
        /* Create program object. */
        assert(0 == program_object_id);
        program_object_id = gl.createProgram();
        GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a program object.");

        /* Configure the program object */
        gl.attachShader(program_object_id, fragment_shader_object_id);
        gl.attachShader(program_object_id, vertex_shader_object_id);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() failed.");

        gl.deleteShader(fragment_shader_object_id);
        gl.deleteShader(vertex_shader_object_id);
        fragment_shader_object_id = 0;
        vertex_shader_object_id   = 0;

        /* Link the program object */
        gl.linkProgram(program_object_id);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() failed.");

        /* Make sure the linking operation succeeded. */
        gl.getProgramiv(program_object_id, GL_LINK_STATUS, &link_status);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() failed.");

        if (link_status != GL_TRUE)
        {
#if IS_DEBUG
            glw::GLint length = 0;
            std::string message;

            /* Get error log length */
            gl.getProgramiv(program_object_id, GL_INFO_LOG_LENGTH, &length);
            GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv");

            message.resize(length, 0);

            /* Get error log */
            gl.getProgramInfoLog(program_object_id, length, 0, &message[0]);
            GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramInfoLog");

            context_id.getTestContext().getLog()
                << tcu::TestLog::Message << "Error message: " << &message[0] << tcu::TestLog::EndMessage;

#if IS_DEBUG_DUMP_ALL_SHADERS
#else  /* IS_DEBUG_DUMP_ALL_SHADERS */
            context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(vertex_shader_source);
            context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(fragment_shader_source);
#endif /* IS_DEBUG_DUMP_ALL_SHADERS */
#endif /* IS_DEBUG */

            TCU_FAIL("Linking was expected to succeed, but the process was unsuccessful.");

            test_result = false;
        }
    }

    if (delete_generated_objects)
    {
        /* Deallocate any resources used. */
        this->delete_objects();
    }

    /* Return test pass if true. */
    if (true == test_result)
    {
        m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    }

    return CONTINUE;
}

/** Runs the positive test.
 *  The shader sources are considered as valid,
 *  and the compilation and program linking are expected to succeed.
 *
 * @tparam API                     Tested API descriptor
 *
 * @param vertex_shader_source     The source for the vertex shader to be used for this test.
 * @param tess_ctrl_shader_source  The source for the vertex shader to be used for this test.
 * @param tess_eval_shader_source  The source for the vertex shader to be used for this test.
 * @param geometry_shader_source   The source for the vertex shader to be used for this test.
 * @param fragment_shader_source   The source for the vertex shader to be used for this test.
 * @param compute_shader_source    The source for the fragment shader to be used for this test.
 * @param delete_generated_objects If true, the compiled shader objects will be deleted before returning.
 *
 *  @return QP_TEST_RESULT_FAIL - test has failed;
 *          QP_TEST_RESULT_PASS - test has succeeded;
 **/
template <class API>
tcu::TestNode::IterateResult TestCaseBase<API>::execute_positive_test(
    const std::string &vertex_shader_source, const std::string &tess_ctrl_shader_source,
    const std::string &tess_eval_shader_source, const std::string &geometry_shader_source,
    const std::string &fragment_shader_source, const std::string &compute_shader_source, bool delete_generated_objects,
    bool require_gpu_shader5)
{
    glw::GLint compile_status = GL_TRUE;
    const glw::Functions &gl  = context_id.getRenderContext().getFunctions();
    glw::GLint link_status    = GL_TRUE;
    bool test_compute         = !compute_shader_source.empty();
    bool test_result          = true;

    if (false == test_compute)
    {
        /* Compile, and check the compilation result for the fragment shader object. */
        compile_status = compile_shader_and_get_compilation_result(
            fragment_shader_source, TestCaseBase<API>::FRAGMENT_SHADER_TYPE, require_gpu_shader5);

        if (compile_status == GL_FALSE)
        {
            TCU_FAIL("The fragment shader was expected to compile successfully, but failed to compile.");

            test_result = false;
        }

        /* Compile, and check the compilation result for the geometry shader object. */
        compile_status = compile_shader_and_get_compilation_result(
            geometry_shader_source, TestCaseBase<API>::GEOMETRY_SHADER_TYPE, require_gpu_shader5);

        if (compile_status == GL_FALSE)
        {
            TCU_FAIL("The geometry shader was expected to compile successfully, but failed to compile.");

            test_result = false;
        }

        /* Compile, and check the compilation result for the te shader object. */
        compile_status = compile_shader_and_get_compilation_result(
            tess_eval_shader_source, TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE, require_gpu_shader5);

        if (compile_status == GL_FALSE)
        {
            TCU_FAIL("The tesselation evaluation shader was expected to compile successfully, but failed to compile.");

            test_result = false;
        }

        /* Compile, and check the compilation result for the tc shader object. */
        compile_status = compile_shader_and_get_compilation_result(
            tess_ctrl_shader_source, TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE, require_gpu_shader5);

        if (compile_status == GL_FALSE)
        {
            TCU_FAIL("The tesselation control shader was expected to compile successfully, but failed to compile.");

            test_result = false;
        }

        /* Compile, and check the compilation result for the vertex shader object. */
        compile_status = compile_shader_and_get_compilation_result(
            vertex_shader_source, TestCaseBase<API>::VERTEX_SHADER_TYPE, require_gpu_shader5);

        if (compile_status == GL_FALSE)
        {
            TCU_FAIL("The vertex shader was expected to compile successfully, but failed to compile.");

            test_result = false;
        }
    }
    else
    {
        /* Compile, and check the compilation result for the compute shader object. */
        compile_status = compile_shader_and_get_compilation_result(
            compute_shader_source, TestCaseBase<API>::COMPUTE_SHADER_TYPE, require_gpu_shader5);

        if (compile_status == GL_FALSE)
        {
            TCU_FAIL("The compute shader was expected to compile successfully, but failed to compile.");

            test_result = false;
        }
    }

    if (true == test_result)
    {
        /* Create program object. */
        program_object_id = gl.createProgram();
        GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a program object.");

        /* Configure the program object */
        if (false == test_compute)
        {
            gl.attachShader(program_object_id, fragment_shader_object_id);

            if (geometry_shader_object_id)
            {
                gl.attachShader(program_object_id, geometry_shader_object_id);
            }

            if (tess_ctrl_shader_object_id)
            {
                gl.attachShader(program_object_id, tess_ctrl_shader_object_id);
            }

            if (tess_eval_shader_object_id)
            {
                gl.attachShader(program_object_id, tess_eval_shader_object_id);
            }

            gl.attachShader(program_object_id, vertex_shader_object_id);
        }
        else
        {
            gl.attachShader(program_object_id, compute_shader_object_id);
        }
        GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() failed.");

        if (false == test_compute)
        {
            gl.deleteShader(fragment_shader_object_id);

            if (geometry_shader_object_id)
            {
                gl.deleteShader(geometry_shader_object_id);
            }

            if (tess_ctrl_shader_object_id)
            {
                gl.deleteShader(tess_ctrl_shader_object_id);
            }

            if (tess_eval_shader_object_id)
            {
                gl.deleteShader(tess_eval_shader_object_id);
            }

            gl.deleteShader(vertex_shader_object_id);
        }
        else
        {
            gl.deleteShader(compute_shader_object_id);
        }

        fragment_shader_object_id  = 0;
        vertex_shader_object_id    = 0;
        geometry_shader_object_id  = 0;
        tess_ctrl_shader_object_id = 0;
        tess_eval_shader_object_id = 0;
        compute_shader_object_id   = 0;

        /* Link the program object */
        gl.linkProgram(program_object_id);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() failed.");

        /* Make sure the linking operation succeeded. */
        gl.getProgramiv(program_object_id, GL_LINK_STATUS, &link_status);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() failed.");

        if (link_status != GL_TRUE)
        {
#if IS_DEBUG
            glw::GLint length = 0;
            std::string message;

            /* Get error log length */
            gl.getProgramiv(program_object_id, GL_INFO_LOG_LENGTH, &length);
            GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv");

            message.resize(length, 0);

            /* Get error log */
            gl.getProgramInfoLog(program_object_id, length, 0, &message[0]);
            GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramInfoLog");

            context_id.getTestContext().getLog()
                << tcu::TestLog::Message << "Error message: " << &message[0] << tcu::TestLog::EndMessage;

#if IS_DEBUG_DUMP_ALL_SHADERS
            if (false == test_compute)
            {
                context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(vertex_shader_source);
                context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(tess_ctrl_shader_source);
                context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(tess_eval_shader_source);
                context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(geometry_shader_source);
                context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(fragment_shader_source);
            }
            else
            {
                context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(compute_shader_source);
            }
#endif /* IS_DEBUG_DUMP_ALL_SHADERS */
#endif /* IS_DEBUG */

            TCU_FAIL("Linking was expected to succeed, but the process was unsuccessful.");

            test_result = false;
        }
    }

    if (delete_generated_objects)
    {
        /* Deallocate any resources used. */
        this->delete_objects();
    }

    /* Return test pass if true. */
    if (true == test_result)
    {
        m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    }

    return CONTINUE;
}

/** Adds the specified @param sub_script onto the base_string @param number_of_elements times.
 *  E.g. extend_string("a", [2], 3) would give a[2][2][2].
 *
 * @tparam API               Tested API descriptor
 *
 * @param base_string        The base string that is to be added to.
 * @param sub_string         The string to be repeatedly added
 * @param number_of_elements The number of repetitions.
 *
 *  @return The extended string.
 **/
template <class API>
std::string TestCaseBase<API>::extend_string(std::string base_string, std::string sub_string, size_t number_of_elements)
{
    std::string temp_string = base_string;

    for (size_t sub_script_index = 0; sub_script_index < number_of_elements; sub_script_index++)
    {
        temp_string += sub_string;
    }

    return temp_string;
}

/* Generates the shader source code for the SizedDeclarationsPrimitive
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 *
 **/
template <class API>
void SizedDeclarationsPrimitive<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    for (size_t var_type_index = 0; var_type_index < API::n_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(API::var_types[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            /* Loop round for each var_types ("int", "uint", "float", etc.)
             * We are testing a[][] to a [][][][][][][][], so start counter at 2. */
            for (size_t max_dimension_limit = 2; max_dimension_limit <= API::MAX_ARRAY_DIMENSIONS;
                 max_dimension_limit++)
            {
                // Record the base varTypeModifier + varType
                std::string base_var_type        = var_iterator->second.type;
                std::string base_variable_string = base_var_type;

                for (size_t base_sub_script_index = 0; base_sub_script_index <= max_dimension_limit;
                     base_sub_script_index++)
                {
                    std::string shader_source = "";

                    // Add the shader body start, and the base varTypeModifier + varType + variable name.
                    shader_source += shader_start + "    " + base_variable_string + " a";

                    for (size_t remaining_sub_script_index = base_sub_script_index;
                         remaining_sub_script_index < max_dimension_limit; remaining_sub_script_index++)
                    {
                        /* Add as many array sub_scripts as we can, up to the current dimension limit. */
                        shader_source += "[2]";
                    }

                    /* End line */
                    shader_source += ";\n";

                    /* End main */
                    DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

                    /* Execute test */
                    EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);

                    /* From now on, we'll have an extra sub_script each time. */
                    base_variable_string += "[2]";
                } /* for (int base_sub_script_index = 0; ...) */
            }     /* for (int max_dimension_limit = 2; ...) */
        }         /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/* Generates the shader source code for the SizedDeclarationsStructTypes1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void SizedDeclarationsStructTypes1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string example_struct("struct light {\n"
                               "    float intensity;\n"
                               "    int   position;\n"
                               "};\n\n");
    std::string shader_source;

    for (size_t max_dimension_index = 1; max_dimension_index < API::MAX_ARRAY_DIMENSIONS; max_dimension_index++)
    {
        shader_source = example_struct;
        shader_source += shader_start;
        shader_source += "    light[2]";

        for (size_t temp_dimension_index = 0; temp_dimension_index < max_dimension_index; temp_dimension_index++)
        {
            shader_source += "[2]";
        }

        shader_source += " x;\n";

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);

    } /* for (int max_dimension_index = 1; ...) */
}

/* Generates the shader source code for the SizedDeclarationsStructTypes2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void SizedDeclarationsStructTypes2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string structure_declaration = "struct MyStructure {\n"
                                        "   float a[2], "
                                        "b[2][2], "
                                        "c[2][2][2], "
                                        "d[2][2][2][2], "
                                        "e[2][2][2][2][2], "
                                        "f[2][2][2][2][2][2], "
                                        "g[2][2][2][2][2][2][2], "
                                        "h[2][2][2][2][2][2][2][2];\n"
                                        "} myStructureObject;\n\n";
    std::string shader_source         = structure_declaration;

    shader_source += shader_start;

    /* End main */
    DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

    /* Execute test */
    EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
}

/* Generates the shader source code for the SizedDeclarationsStructTypes3
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void SizedDeclarationsStructTypes3<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string example_struct("struct light {\n"
                               "    float[2] intensity;\n"
                               "    int[2] position;\n"
                               "};\n");
    std::string shader_source;

    for (size_t max_dimension_index = 1; max_dimension_index <= API::MAX_ARRAY_DIMENSIONS; max_dimension_index++)
    {
        shader_source = example_struct;
        shader_source += shader_start;
        shader_source += this->extend_string("    light my_light_object", "[2]", max_dimension_index);
        shader_source += ";\n";

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
    } /* for (int max_dimension_index = 1; ...) */
}

/* Generates the shader source code for the SizedDeclarationsStructTypes4
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void SizedDeclarationsStructTypes4<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string example_struct("struct light {\n"
                               "    float[2] intensity;\n"
                               "    int[2] position;\n"
                               "} lightVar[2]");
    std::string shader_source;

    for (size_t max_dimension_index = 1; max_dimension_index < API::MAX_ARRAY_DIMENSIONS; max_dimension_index++)
    {
        shader_source = example_struct;

        for (size_t temp_dimension_index = 0; temp_dimension_index < max_dimension_index; temp_dimension_index++)
        {
            shader_source += "[2]";
        }
        shader_source += ";\n\n";
        shader_source += shader_start;

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
    } /* for (int max_dimension_index = 1; ...) */
}

/* Generates the shader source code for the SizedDeclarationsTypenameStyle1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void SizedDeclarationsTypenameStyle1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    for (size_t max_dimension_index = 1; max_dimension_index <= API::MAX_ARRAY_DIMENSIONS; max_dimension_index++)
    {
        std::string shader_source = shader_start;

        shader_source += this->extend_string("    float", "[2]", max_dimension_index);
        shader_source += this->extend_string(" x", "[2]", API::MAX_ARRAY_DIMENSIONS - max_dimension_index);
        shader_source += ";\n";

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
    } /* for (int max_dimension_index = 1; ...) */
}

/* Generates the shader source code for the SizedDeclarationsTypenameStyle2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void SizedDeclarationsTypenameStyle2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string shader_source = shader_start;

    shader_source += this->extend_string("    float", "[2]", 2);
    shader_source += this->extend_string(" a", "[2]", 0);
    shader_source += ", ";
    shader_source += this->extend_string("b", "[2]", 1);
    shader_source += ", ";
    shader_source += this->extend_string("c", "[2]", 2);
    shader_source += ", ";
    shader_source += this->extend_string("d", "[2]", 3);
    shader_source += ", ";
    shader_source += this->extend_string("e", "[2]", 4);
    shader_source += ", ";
    shader_source += this->extend_string("f", "[2]", 5);
    shader_source += ", ";
    shader_source += this->extend_string("g", "[2]", 6);
    shader_source += ";\n";

    /* End main */
    DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

    /* Execute test */
    EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
}

/* Generates the shader source code for the SizedDeclarationsTypenameStyle3
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void SizedDeclarationsTypenameStyle3<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string shader_source = "struct{\n" + this->extend_string("    float", "[2]", 2);

    shader_source += this->extend_string(" a", "[2]", 0);
    shader_source += ",";
    shader_source += this->extend_string("    b", "[2]", 1);
    shader_source += ",";
    shader_source += this->extend_string("    c", "[2]", 2);
    shader_source += ",";
    shader_source += this->extend_string("    d", "[2]", 3);
    shader_source += ",";
    shader_source += this->extend_string("    e", "[2]", 4);
    shader_source += ",";
    shader_source += this->extend_string("    f", "[2]", 5);
    shader_source += ",";
    shader_source += this->extend_string("    g", "[2]", 6);
    shader_source += ";\n} x;\n\n";
    shader_source += shader_start;

    /* End main */
    DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

    /* Execute test */
    EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
}

/* Generates the shader source code for the SizedDeclarationsTypenameStyle4
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void SizedDeclarationsTypenameStyle4<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string example_struct_begin("struct light {\n");
    std::string example_struct_end("};\n\n");

    for (size_t max_dimension_index = 1; max_dimension_index <= API::MAX_ARRAY_DIMENSIONS; max_dimension_index++)
    {
        std::string shader_source = example_struct_begin;

        shader_source += this->extend_string("    float", "[2]", max_dimension_index);
        shader_source += this->extend_string(" x", "[2]", API::MAX_ARRAY_DIMENSIONS - max_dimension_index);
        shader_source += ";\n";
        shader_source += example_struct_end;
        shader_source += shader_start;

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
    } /* for (int max_dimension_index = 1; ...) */
}

/* Generates the shader source code for the SizedDeclarationsTypenameStyle5
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void SizedDeclarationsTypenameStyle5<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string example_struct_begin("struct light {\n");
    std::string example_struct_end("};\n\n");

    std::string shader_source = example_struct_begin;

    shader_source += this->extend_string("    float", "[2]", 2);
    shader_source += this->extend_string(" a", "[2]", 0);
    shader_source += ", ";
    shader_source += this->extend_string("b", "[2]", 2);
    shader_source += ", ";
    shader_source += this->extend_string("c", "[2]", 3);
    shader_source += ", ";
    shader_source += this->extend_string("d", "[2]", 4);
    shader_source += ", ";
    shader_source += this->extend_string("e", "[2]", 5);
    shader_source += ", ";
    shader_source += this->extend_string("f", "[2]", 6);
    shader_source += ";\n";
    shader_source += example_struct_end;
    shader_source += shader_start;

    /* End main */
    DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

    /* Execute test */
    EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
}

/* Generates the shader source code for the SizedDeclarationsFunctionParams
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void SizedDeclarationsFunctionParams<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    size_t dimension_index = 0;
    std::string example_struct1("\nvoid my_function(");
    std::string example_struct2(")\n"
                                "{\n"
                                "}\n\n");
    std::string base_variable_string;
    std::string variable_basenames[API::MAX_ARRAY_DIMENSIONS] = {"v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8"};
    std::string full_variable_names[API::MAX_ARRAY_DIMENSIONS];

    for (size_t max_dimension_index = 0; max_dimension_index < API::MAX_ARRAY_DIMENSIONS; max_dimension_index++)
    {
        full_variable_names[max_dimension_index] =
            this->extend_string(variable_basenames[max_dimension_index], "[2]", max_dimension_index + 1);
    }

    for (size_t max_dimension_index = 0; max_dimension_index < API::MAX_ARRAY_DIMENSIONS; max_dimension_index++)
    {
        base_variable_string += "float ";
        base_variable_string += full_variable_names[max_dimension_index];
        base_variable_string += ";\n";
    }

    base_variable_string += example_struct1;
    base_variable_string += this->extend_string("float a", "[2]", 1);
    base_variable_string += ", ";
    base_variable_string += this->extend_string("float b", "[2]", 2);
    base_variable_string += ", ";
    base_variable_string += this->extend_string("float c", "[2]", 3);
    base_variable_string += ", ";
    base_variable_string += this->extend_string("float d", "[2]", 4);
    base_variable_string += ", ";
    base_variable_string += this->extend_string("float e", "[2]", 5);
    base_variable_string += ", ";
    base_variable_string += this->extend_string("float f", "[2]", 6);
    base_variable_string += ", ";
    base_variable_string += this->extend_string("float g", "[2]", 7);
    base_variable_string += ", ";
    base_variable_string += this->extend_string("float h", "[2]", 8);
    base_variable_string += example_struct2;

    std::string shader_source = base_variable_string;

    shader_source += shader_start;
    shader_source += "    my_function(";

    for (dimension_index = 0; dimension_index < API::MAX_ARRAY_DIMENSIONS - 1; dimension_index++)
    {
        shader_source += variable_basenames[dimension_index];
        shader_source += ", ";
    }

    shader_source += variable_basenames[dimension_index];
    shader_source += ");\n";

    /* End main */
    DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

    /* Execute test */
    EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);

    /* Only the previous case should succeed, so start from index 1 rather than 0.
     * The other cases should fail, so only compile them, rather than trying to also link them.
     * We'll swap items 2/3, then 2/4, then 2/5, then 2/6, ...
     * Then we'll swap items 3/4, then 3/5, ...
     * Repeat, starting for 4/5-8, 5/6-8, 6/7-8...
     * Finally, we'll swap items 7/8
     */
    for (size_t swap_item = 1; swap_item < API::MAX_ARRAY_DIMENSIONS; swap_item++)
    {
        for (size_t max_dimension_index = swap_item + 1; max_dimension_index < API::MAX_ARRAY_DIMENSIONS;
             max_dimension_index++)
        {
            std::string temp = variable_basenames[swap_item];

            shader_source                           = base_variable_string;
            variable_basenames[swap_item]           = variable_basenames[max_dimension_index];
            variable_basenames[max_dimension_index] = temp;

            shader_source += shader_start;
            shader_source += "    my_function(";

            for (dimension_index = 0; dimension_index < API::MAX_ARRAY_DIMENSIONS - 1; dimension_index++)
            {
                shader_source += variable_basenames[dimension_index];
                shader_source += ", ";
            }

            shader_source += variable_basenames[dimension_index];
            shader_source += ");\n";

            temp                                    = variable_basenames[swap_item];
            variable_basenames[swap_item]           = variable_basenames[max_dimension_index];
            variable_basenames[max_dimension_index] = temp;

            /* End main */
            DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

            /* Execute test */
            this->execute_negative_test(tested_shader_type, shader_source);
        } /* for (int max_dimension_index = swap_item + 1; ...) */
    }     /* for (int swap_item = 1; ...) */
}

/* Generates the shader source code for the sized_declarations_invalid_sizes1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void sized_declarations_invalid_sizes1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string invalid_declarations[] = {"float x[2][2][2][0];\n", "float x[2][2][0][2];\n", "float x[2][0][2][2];\n",
                                          "float x[0][2][2][2];\n", "float x[2][2][0][0];\n", "float x[2][0][2][0];\n",
                                          "float x[0][2][2][0];\n", "float x[2][0][0][2];\n", "float x[0][2][0][2];\n",
                                          "float x[0][0][2][2];\n", "float x[2][0][0][0];\n", "float x[0][2][0][0];\n",
                                          "float x[0][0][2][0];\n", "float x[0][0][0][2];\n", "float x[0][0][0][0];\n"};

    for (size_t invalid_declarations_index = 0; invalid_declarations_index < DE_LENGTH_OF_ARRAY(invalid_declarations);
         invalid_declarations_index++)
    {
        std::string shader_source;

        shader_source = shader_start;
        shader_source += invalid_declarations[invalid_declarations_index];

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        this->execute_negative_test(tested_shader_type, shader_source);
    } /* for (int invalid_declarations_index = 0; ...) */
}

/* Generates the shader source code for the sized_declarations_invalid_sizes2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void sized_declarations_invalid_sizes2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string invalid_declarations[] = {
        "    float x[2][2][2][-1];\n",   "    float x[2][2][-1][2];\n",   "    float x[2][-1][2][2];\n",
        "    float x[-1][2][2][2];\n",   "    float x[2][2][-1][-1];\n",  "    float x[2][-1][2][-1];\n",
        "    float x[-1][2][2][-1];\n",  "    float x[2][-1][-1][2];\n",  "    float x[-1][2][-1][2];\n",
        "    float x[-1][-1][2][2];\n",  "    float x[2][-1][-1][-1];\n", "    float x[-1][2][-1][-1];\n",
        "    float x[-1][-1][2][-1];\n", "    float x[-1][-1][-1][2];\n", "    float x[-1][-1][-1][-1];\n"};

    for (size_t invalid_declarations_index = 0; invalid_declarations_index < DE_LENGTH_OF_ARRAY(invalid_declarations);
         invalid_declarations_index++)
    {
        std::string shader_source;

        shader_source = shader_start;
        shader_source += invalid_declarations[invalid_declarations_index];

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        this->execute_negative_test(tested_shader_type, shader_source);
    } /* for (int invalid_declarations_index = 0; ...) */
}

/* Generates the shader source code for the sized_declarations_invalid_sizes3
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void sized_declarations_invalid_sizes3<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string invalid_declarations[] = {
        "    float x[2][2][2][a];\n", "    float x[2][2][a][2];\n", "    float x[2][a][2][2];\n",
        "    float x[a][2][2][2];\n", "    float x[2][2][a][a];\n", "    float x[2][a][2][a];\n",
        "    float x[a][2][2][a];\n", "    float x[2][a][a][2];\n", "    float x[a][2][a][2];\n",
        "    float x[a][a][2][2];\n", "    float x[2][a][a][a];\n", "    float x[a][2][a][a];\n",
        "    float x[a][a][2][a];\n", "    float x[a][a][a][2];\n", "    float x[a][a][a][a];\n"};
    std::string non_constant_variable_declaration = "    uint a = 2u;\n";

    for (size_t invalid_declarations_index = 0; invalid_declarations_index < DE_LENGTH_OF_ARRAY(invalid_declarations);
         invalid_declarations_index++)
    {
        std::string shader_source;

        shader_source = shader_start;
        shader_source += non_constant_variable_declaration;
        shader_source += invalid_declarations[invalid_declarations_index];

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        this->execute_negative_test(tested_shader_type, shader_source);
    } /* for (int invalid_declarations_index = 0; ...) */
}

/* Generates the shader source code for the sized_declarations_invalid_sizes4
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void sized_declarations_invalid_sizes4<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string input[] = {"    float x[2,2][2][2];\n", "    float x[2][2,2][2];\n", "    float x[2][2][2,2];\n",
                           "    float x[2,2,2][2];\n",  "    float x[2][2,2,2];\n",  "    float x[2,2,2,2];\n"};

    for (size_t string_index = 0; string_index < sizeof(input) / sizeof(input[0]); string_index++)
    {
        std::string shader_source;

        shader_source += shader_start;
        shader_source += input[string_index];

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        this->execute_negative_test(tested_shader_type, shader_source);
    } /* for (int string_index = 0; ...) */
}

/* Constructs a suitable constructor for the specified number of dimensions.
 *
 * @tparam API            Tested API descriptor
 *
 * @param var_type        The type of the variable
 * @param dimension_index The current recursion level (counts down)
 * @param init_string     The initialisation string
 */
template <class API>
std::string ConstructorsAndUnsizedDeclConstructors1<API>::recursively_initialise(std::string var_type,
                                                                                 size_t dimension_index,
                                                                                 std::string init_string)
{
    std::string temp_string;

    if (dimension_index == 0)
    {
        temp_string = init_string;
    }
    else
    {
        std::string prefix = "\n";

        for (size_t indent_index = dimension_index; indent_index < (API::MAX_ARRAY_DIMENSIONS + 1); indent_index++)
        {
            prefix += "    ";
        }

        prefix += this->extend_string(var_type, "[]", dimension_index);
        prefix += "(";
        for (int sub_script_index = 0; sub_script_index < 2; sub_script_index++)
        {
            temp_string += prefix;
            temp_string += recursively_initialise(var_type, dimension_index - 1, init_string);
            prefix = ", ";
            if (sub_script_index == 1)
            {
                break;
            }
        }
        temp_string += ")";
    }

    return temp_string;
}

/* Generates the shader source code for the ConstructorsAndUnsizedDeclConstructors1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ConstructorsAndUnsizedDeclConstructors1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    //vec4 color = vec4(0.0, 1.0, 0.0, 1.0);
    int num_var_types = API::n_var_types;

    for (int var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(API::var_types[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            for (size_t max_dimension_index = 2; max_dimension_index < API::MAX_ARRAY_DIMENSIONS; max_dimension_index++)
            {
                std::string base_variable_string =
                    this->extend_string("    " + var_iterator->second.type + " a", "[]", max_dimension_index);

                base_variable_string += " = ";
                base_variable_string += recursively_initialise(var_iterator->second.type, max_dimension_index,
                                                               var_iterator->second.initializer_with_ones);
                base_variable_string += ";\n\n";

                std::string shader_source = shader_start + base_variable_string;

                /* End main */
                DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

                /* Execute test */
                EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
            } /* for (int max_dimension_index = 1; ...) */
        }     /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */

    for (int var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(API::var_types[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string base_structure = "struct my_structure\n";

            base_structure += "{\n";
            base_structure += "    " + var_iterator->second.type + " b;\n";
            base_structure += "    " + var_iterator->second.type + " c;\n";
            base_structure += "};\n\n";

            for (size_t max_dimension_index = 1; max_dimension_index < API::MAX_ARRAY_DIMENSIONS; max_dimension_index++)
            {
                std::string outer_separator = "(";
                std::string base_variable_string;

                base_variable_string +=
                    this->extend_string("    " + var_iterator->second.type + " a", "[2]", max_dimension_index);
                base_variable_string += " = ";
                base_variable_string += recursively_initialise(var_iterator->second.type, max_dimension_index,
                                                               var_iterator->second.initializer_with_ones);
                base_variable_string += ";\n\n";

                std::string shader_source = base_structure + shader_start + base_variable_string;

                /* End main */
                DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

                /* Execute test */
                EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
            } /* for (int max_dimension_index = 1; ...) */
        }     /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/* Generates the shader source code for the ConstructorsAndUnsizedDeclConstructors2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ConstructorsAndUnsizedDeclConstructors2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string base_variable_string = "    float[2][2] x = float[2][2](float[4](1.0, 2.0, 3.0, 4.0));\n";
    std::string shader_source        = shader_start + base_variable_string;

    /* End main */
    DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

    /* Execute test */
    this->execute_negative_test(tested_shader_type, shader_source);

    base_variable_string = "float[2][2] x = float[2][2](float[1][4](float[4](1.0, 2.0, 3.0, 4.0)));\n\n";
    shader_source        = base_variable_string + shader_start;

    /* End main */
    DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

    /* Execute test */
    this->execute_negative_test(tested_shader_type, shader_source);
}

/* Generates the shader source code for the ConstructorsAndUnsizedDeclUnsizedConstructors
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ConstructorsAndUnsizedDeclUnsizedConstructors<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string shader_variable_declarations = "= float[2][1][2][1](\n"
                                               "        float[1][2][1](\n"
                                               "            float[2][1]( \n"
                                               "                float[1](12.3), float[1](54.2) \n"
                                               "            )\n"
                                               "        ),\n"
                                               "        float[1][2][1](\n"
                                               "            float[2][1]( \n"
                                               "                float[1]( 3.2), float[1]( 7.4) \n"
                                               "            )\n"
                                               "        )\n"
                                               "    );\n\n";

    std::string input[] = {"float a[2][1][2][]", "float a[2][1][][1]", "float a[2][1][][]", "float a[2][][2][1]",
                           "float a[2][][2][]",  "float a[2][][][1]",  "float a[2][][][]",  "float a[][1][2][1]",
                           "float a[][1][2][]",  "float a[][1][][1]",  "float a[][1][][]",  "float a[][][2][1]",
                           "float a[][][2][]",   "float a[][][][1]",   "float a[][][][]"};

    for (size_t string_index = 0; string_index < sizeof(input) / sizeof(input[0]); string_index++)
    {
        std::string shader_source = shader_start + "    " + input[string_index] + shader_variable_declarations;

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
    } /* for (int string_index = 0; ...) */
}

/* Generates the shader source code for the ConstructorsAndUnsizedDeclConst
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ConstructorsAndUnsizedDeclConst<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string shader_source = "const float[2][2] x = float[2][2](float[2](1.0, 2.0), float[2](3.0, 4.0));\n\n";
    shader_source += shader_start;

    /* End main */
    DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

    /* Execute test */
    EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
}

/* Generates the shader source code for the ConstructorsAndUnsizedDeclInvalidConstructors1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ConstructorsAndUnsizedDeclInvalidConstructors1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    int num_var_types = sizeof(opaque_var_types) / sizeof(opaque_var_types[0]);

    for (int var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(opaque_var_types[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string base_variable_string =
                "uniform " + var_iterator->second.precision + " " + var_iterator->second.type + " my_sampler1;\n" +
                "uniform " + var_iterator->second.precision + " " + var_iterator->second.type + " my_sampler2;\n" +
                "uniform " + var_iterator->second.precision + " " + var_iterator->second.type + " my_sampler3;\n" +
                "uniform " + var_iterator->second.precision + " " + var_iterator->second.type + " my_sampler4;\n\n";

            std::string shader_source = base_variable_string + shader_start;
            shader_source += "    const " + var_iterator->second.type + "[2][2] x = " + var_iterator->second.type +
                             "[2][2](" + var_iterator->second.type + "[2](my_sampler1, my_sampler2), " +
                             var_iterator->second.type + "[2](my_sampler3, my_sampler4));\n\n";

            /* End main */
            DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

            /* Execute test */
            this->execute_negative_test(tested_shader_type, shader_source);
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/* Generates the shader source code for the ConstructorsAndUnsizedDeclInvalidConstructors2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ConstructorsAndUnsizedDeclInvalidConstructors2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string invalid_initializers[] = {"    int x[2][2][0]; \n", "    int x[2][0][2]; \n", "    int x[0][2][2]; \n",
                                          "    int x[2][0][0]; \n", "    int x[0][2][0]; \n", "    int x[0][0][2]; \n",
                                          "    int x[0][0][0]; \n"};

    for (size_t invalid_initializers_index = 0;
         invalid_initializers_index < sizeof(invalid_initializers) / sizeof(invalid_initializers[0]);
         invalid_initializers_index++)
    {
        std::string shader_source;

        shader_source = shader_start;
        shader_source += invalid_initializers[invalid_initializers_index];

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        this->execute_negative_test(tested_shader_type, shader_source);
    } /* for (int invalid_initializers_index = 0; ...) */
}

/* Generates the shader source code for the ConstructorsAndUnsizedDeclInvalidConstructors3
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ConstructorsAndUnsizedDeclInvalidConstructors3<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string invalid_initializers[] = {
        "    int x[2][2][-1]; \n",  "    int x[2][-1][2]; \n",  "    int x[-1][2][2]; \n",  "    int x[2][-1][-1]; \n",
        "    int x[-1][2][-1]; \n", "    int x[-1][-1][2]; \n", "    int x[-1][-1][-1]; \n"};

    for (size_t invalid_initializers_index = 0;
         invalid_initializers_index < sizeof(invalid_initializers) / sizeof(invalid_initializers[0]);
         invalid_initializers_index++)
    {
        std::string shader_source;

        shader_source = shader_start;
        shader_source += invalid_initializers[invalid_initializers_index];

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        this->execute_negative_test(tested_shader_type, shader_source);
    } /* for (int invalid_initializers_index = 0; ...) */
}

/* Generates the shader source code for the ConstructorsAndUnsizedDeclInvalidConstructors4
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ConstructorsAndUnsizedDeclInvalidConstructors4<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string invalid_initializers[] = {"    int x[2][2][a]; \n", "    int x[2][a][2]; \n", "    int x[a][2][2]; \n",
                                          "    int x[2][a][a]; \n", "    int x[a][2][a]; \n", "    int x[a][a][2]; \n",
                                          "    int x[a][a][a]; \n"};
    std::string non_constant_variable_init = "    uint a = 2u;\n";

    for (size_t invalid_initializers_index = 0;
         invalid_initializers_index < sizeof(invalid_initializers) / sizeof(invalid_initializers[0]);
         invalid_initializers_index++)
    {
        std::string shader_source;

        shader_source = shader_start;
        shader_source += non_constant_variable_init;
        shader_source += invalid_initializers[invalid_initializers_index];

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        this->execute_negative_test(tested_shader_type, shader_source);
    } /* for (int invalid_initializers_index = 0; ...) */
}

/* Generates the shader source code for the ConstructorsAndUnsizedDeclConstructorSizing1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ConstructorsAndUnsizedDeclConstructorSizing1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string valid_size_initializers[] = {"[1][1][1][]", "[1][1][][1]", "[1][][1][1]", "[][1][1][1]", "[1][1][][]",
                                             "[1][][1][]",  "[][1][1][]",  "[1][][][1]",  "[][1][][1]",  "[][][1][1]",
                                             "[1][][][]",   "[][1][][]",   "[][][1][]",   "[][][][1]",   "[][][][]"};

    for (size_t var_type_index = 0; var_type_index < API::n_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(API::var_types[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            for (size_t valid_size_initializers_index = 0;
                 valid_size_initializers_index < sizeof(valid_size_initializers) / sizeof(valid_size_initializers[0]);
                 valid_size_initializers_index++)
            {
                std::string shader_source;
                std::string variable_constructor =
                    "    " + var_iterator->second.type + " x" + valid_size_initializers[valid_size_initializers_index] +
                    " = " + var_iterator->second.type + "[1][1][1][1](" + var_iterator->second.type + "[1][1][1](" +
                    var_iterator->second.type + "[1][1](" + var_iterator->second.type + "[1](" +
                    var_iterator->second.initializer_with_zeroes + "))));\n";

                shader_source = shader_start;
                shader_source += variable_constructor;

                /* End main */
                DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

                /* Execute test */
                EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
            } /* for (int valid_size_initializers_index = 0; ...) */
        }     /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/* Generates the shader source code for the ConstructorsAndUnsizedDeclConstructorSizing2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ConstructorsAndUnsizedDeclConstructorSizing2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string shader_source = shader_start;

    shader_source += "    float[] a ="
                     "            float[](1.0, 2.0),"
                     "        b[] ="
                     "         float[][]("
                     "             float[](1.0, 2.0),"
                     "             float[](3.0, 4.0)"
                     "         ),"
                     "        c[][] ="
                     "         float[][][]("
                     "             float[][]("
                     "                 float[](1.0),"
                     "                 float[](2.0)"
                     "             )"
                     "         ),"
                     "        d[][][] ="
                     "         float[][][][]("
                     "             float[][][]("
                     "                 float[][]("
                     "                     float[](1.0, 2.0),"
                     "                     float[](3.0, 4.0),"
                     "                     float[](5.0, 6.0)"
                     "                 )"
                     "             ),"
                     "             float[][][]("
                     "                 float[][]("
                     "                     float[](1.0, 2.0),"
                     "                     float[](3.0, 4.0),"
                     "                     float[](5.0, 6.0)"
                     "                 )"
                     "             )"
                     "         ),"
                     "        e[][][][]="
                     "         float[][][][][]("
                     "             float[][][][]("
                     "                 float[][][]("
                     "                     float[][]("
                     "                         float[](1.0),"
                     "                         float[](2.0)"
                     "                     ),"
                     "                     float[][]("
                     "                         float[](1.0),"
                     "                         float[](2.0)"
                     "                     ),"
                     "                     float[][]("
                     "                         float[](1.0),"
                     "                         float[](2.0)"
                     "                     )"
                     "                 ),"
                     "                 float[][][]("
                     "                     float[][]("
                     "                         float[](1.0),"
                     "                         float[](2.0)"
                     "                     ),"
                     "                     float[][]("
                     "                         float[](1.0),"
                     "                         float[](2.0)"
                     "                     ),"
                     "                     float[][]("
                     "                         float[](1.0),"
                     "                         float[](2.0)"
                     "                     )"
                     "                 )"
                     "             )"
                     "         ),"
                     "        f[][][][][]="
                     "         float[][][][][][]("
                     "             float[][][][][]("
                     "                 float[][][][]("
                     "                     float[][][]("
                     "                         float[][]("
                     "                             float[](1.0)"
                     "                         )"
                     "                     )"
                     "                 )"
                     "             )"
                     "         ),"
                     "        g[][][][][][]="
                     "         float[][][][][][][]("
                     "             float[][][][][][]("
                     "                 float[][][][][]("
                     "                     float[][][][]("
                     "                         float[][][]("
                     "                             float[][]("
                     "                                 float[](1.0)"
                     "                             )"
                     "                         )"
                     "                     )"
                     "                 )"
                     "             )"
                     "         ),"
                     "        h[][][][][][][]="
                     "         float[][][][][][][][]("
                     "             float[][][][][][][]("
                     "                 float[][][][][][]("
                     "                     float[][][][][]("
                     "                         float[][][][]("
                     "                             float[][][]("
                     "                                 float[][]("
                     "                                     float[](1.0)"
                     "                                 )"
                     "                             )"
                     "                         )"
                     "                     )"
                     "                 )"
                     "             )"
                     "         );\n";

    /* End main */
    DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

    /* Execute test */
    EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
}

/* Constructs a suitable constructor for the specified number of dimensions.
 *
 * @tparam API            Tested API descriptor
 *
 * @param var_type        The type of the variable
 * @param dimension_index The current recursion level (counts down)
 * @param init_string     The initialisation string
 */
template <class API>
std::string ConstructorsAndUnsizedDeclStructConstructors<API>::recursively_initialise(std::string var_type,
                                                                                      size_t dimension_index,
                                                                                      std::string init_string)
{
    std::string temp_string;

    if (dimension_index == 0)
    {
        temp_string = var_type + "(" + init_string + ")";
    }
    else
    {
        std::string prefix = "\n";

        for (size_t indent_index = dimension_index; indent_index < (API::MAX_ARRAY_DIMENSIONS + 1); indent_index++)
        {
            prefix += "    ";
        }

        prefix += this->extend_string(var_type, "[]", dimension_index);
        prefix += "(";

        for (int sub_script_index = 0; sub_script_index < 2; sub_script_index++)
        {
            temp_string += prefix;
            temp_string += recursively_initialise(var_type, dimension_index - 1, init_string);
            prefix = ", ";

            if (dimension_index == 1)
            {
                break;
            }
        }
        temp_string += ")";
    }

    return temp_string;
}

/* Generates the shader source code for the ConstructorsAndUnsizedDeclStructConstructors
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ConstructorsAndUnsizedDeclStructConstructors<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string example_structure_definition("struct light {\n"
                                             "    float intensity;\n"
                                             "    int position;\n"
                                             "};\n");
    std::string example_structure_object("    light my_light_variable");

    for (size_t max_dimension_index = 2; max_dimension_index <= API::MAX_ARRAY_DIMENSIONS; max_dimension_index++)
    {
        std::string base_variable_string = this->extend_string(example_structure_object, "[]", max_dimension_index);
        base_variable_string += " = ";
        base_variable_string += recursively_initialise("light", max_dimension_index, "1.0, 2");
        base_variable_string += ";\n\n";

        std::string shader_source = example_structure_definition + shader_start + base_variable_string;

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
    } /* for (int max_dimension_index = 2; ...) */
}

/* Generates the shader source code for the ConstructorsAndUnsizedDeclUnsizedArrays1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ConstructorsAndUnsizedDeclUnsizedArrays1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string base_variable_string;

    for (size_t max_dimension_index = 2; max_dimension_index <= API::MAX_ARRAY_DIMENSIONS; max_dimension_index++)
    {
        base_variable_string = this->extend_string("    int x", "[]", max_dimension_index);
        base_variable_string += ";\n\n";

        std::string shader_source = shader_start + base_variable_string;

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        this->execute_negative_test(tested_shader_type, shader_source);
    } /* for (int max_dimension_index = 2; ...) */
}

/* Generates the shader source code for the ConstructorsAndUnsizedDeclUnsizedArrays2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ConstructorsAndUnsizedDeclUnsizedArrays2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string input[] = {"    float [] x = float[](1), y;\n\n"};

    for (size_t string_index = 0; string_index < sizeof(input) / sizeof(input[0]); string_index++)
    {
        std::string shader_source;

        shader_source += shader_start;
        shader_source += input[string_index];

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        EXECUTE_SHADER_TEST(API::ALLOW_UNSIZED_DECLARATION, tested_shader_type, shader_source);
    } /* for (int string_index = 0; ...) */
}

/* Generates the shader source code for the ConstructorsAndUnsizedDeclUnsizedArrays3
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ConstructorsAndUnsizedDeclUnsizedArrays3<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string base_variable_string("    float[][] x = mat4(0);\n\n");

    std::string shader_source = shader_start + base_variable_string;

    /* End main */
    DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

    /* Execute test */
    this->execute_negative_test(tested_shader_type, shader_source);
}

/* Generates the shader source code for the ConstructorsAndUnsizedDeclUnsizedArrays4
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ConstructorsAndUnsizedDeclUnsizedArrays4<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string example_struct("struct light {\n"
                               "    float[][] intensity;\n"
                               "    int       position;\n"
                               "} myLight;\n\n");

    std::string shader_source = example_struct + shader_start;

    /* End main */
    DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

    /* Execute test */
    this->execute_negative_test(tested_shader_type, shader_source);
}

/* Constructs a suitable constructor for the specified number of dimensions.
 *
 * @tparam API            Tested API descriptor
 *
 * @param dimension_index The current recursion level (counts down)
 * @param init_string     The initialisation string
 */
template <class API>
std::string ExpressionsAssignment1<API>::recursively_initialise(std::string var_type, size_t dimension_index,
                                                                std::string init_string)
{
    std::string temp_string;

    if (dimension_index == 0)
    {
        temp_string = init_string;
    }
    else
    {
        std::string prefix = "\n";

        for (size_t indent_index = dimension_index; indent_index < (API::MAX_ARRAY_DIMENSIONS + 1); indent_index++)
        {
            prefix += "    ";
        }

        prefix += this->extend_string(var_type, "[]", dimension_index);
        prefix += "(";
        for (int sub_script_index = 0; sub_script_index < 2; sub_script_index++)
        {
            temp_string += prefix;
            temp_string += recursively_initialise(var_type, dimension_index - 1, init_string);
            prefix = ", ";
            if (dimension_index == 1)
            {
                break;
            }
        }
        temp_string += ")";
    }

    return temp_string;
}

/* Generates the shader source code for the ExpressionsAssignment1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsAssignment1<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    for (size_t max_dimension_index = 2; max_dimension_index <= API::MAX_ARRAY_DIMENSIONS; max_dimension_index++)
    {
        std::string prefix = "(";
        std::string base_variable_string;

        base_variable_string += this->extend_string("    float x", "[2]", max_dimension_index);
        base_variable_string += " = ";
        base_variable_string += recursively_initialise("float", max_dimension_index, "4.0, 6.0");
        base_variable_string += ";\n";
        base_variable_string += this->extend_string("    float y", "[2]", max_dimension_index);
        base_variable_string += " = ";
        base_variable_string += recursively_initialise("float", max_dimension_index, "1.0, 2.0");
        base_variable_string += ";\n\n";

        std::string shader_source = shader_start + base_variable_string;

        shader_source += "    x = y;\n";

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
    } /* for (int max_dimension_index = 2; ...) */
}

/* Generates the shader source code for the ExpressionsAssignment2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsAssignment2<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string shader_body("    float a[2] = float[](1.0, 2.0);\n"
                            "    float b[2][2] = float[][](float[](1.0, 2.0), float[](1.0, 2.0));\n"
                            "    float c[2][2][2] = float[][][]("
                            "float[][](float[](1.0, 2.0), float[](1.0, 2.0)),"
                            "float[][](float[](1.0, 2.0), float[](1.0, 2.0)));\n"
                            "    float d[2][2][2][2] = float[][][][]("
                            "float[][][]("
                            "float[][](float[](1.0, 2.0), float[](1.0, 2.0)), "
                            "float[][](float[](1.0, 2.0), float[](1.0, 2.0))),"
                            "float[][][]("
                            "float[][](float[](1.0, 2.0), float[](1.0, 2.0)), "
                            "float[][](float[](1.0, 2.0), float[](1.0, 2.0))));\n\n");

    std::string variable_basenames[] = {"a", "b", "c", "d"};
    int number_of_elements           = sizeof(variable_basenames) / sizeof(variable_basenames[0]);

    for (int variable_index = 0; variable_index < number_of_elements; variable_index++)
    {
        for (int value_index = variable_index; value_index < number_of_elements; value_index++)
        {
            std::string shader_source = shader_start + shader_body;

            /* Avoid the situation when a variable is assign to itself. */
            if (variable_index != value_index)
            {
                shader_source += "    " + variable_basenames[variable_index] + " = " + variable_basenames[value_index];
                shader_source += ";\n";

                /* End main */
                DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

                /* Execute test */
                this->execute_negative_test(tested_shader_type, shader_source);
            } /* if(variable_index != value_index) */
        }     /* for (int value_index = variable_index; ...) */
    }         /* for (int variable_index = 0; ...) */
}

/* Generates the shader source code for the ExpressionsAssignment3
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsAssignment3<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string prefix, base_variable_string;

    const int test_array_dimensions = 4;

    prefix = this->extend_string("    float a", "[1]", 4);
    prefix += " = float[][][][](\n"
              "       float[][][](\n"
              "           float[][](\n"
              "               float[](1.0))));\n";

    prefix += "    float b";

    for (int permutation = 0; permutation < (1 << test_array_dimensions); permutation++)
    {
        base_variable_string = prefix;

        for (int sub_script_index = test_array_dimensions - 1; sub_script_index >= 0; sub_script_index--)
        {
            if (permutation & (1 << sub_script_index))
            {
                base_variable_string += "[1]";
            }
            else
            {
                base_variable_string += "[2]";
            }
        }

        base_variable_string += ";\n\n";

        if (permutation != (1 << test_array_dimensions) - 1)
        {
            std::string shader_source = shader_start + base_variable_string;

            shader_source += "    b = a;\n";

            /* End main */
            DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

            /* Execute test */
            this->execute_negative_test(tested_shader_type, shader_source);
        } /* if (permutation != (1 << test_array_dimensions) - 1) */
    }     /* for (int permutation = 0; ...) */
}

/* Generates the shader source code for the ExpressionsTypeRestrictions1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsTypeRestrictions1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    int num_var_types = sizeof(opaque_var_types) / sizeof(opaque_var_types[0]);

    for (int var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(opaque_var_types[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string shader_source = "uniform " + var_iterator->second.precision + " " + var_iterator->second.type +
                                        " var1[2][2];\n"
                                        "uniform " +
                                        var_iterator->second.precision + " " + var_iterator->second.type +
                                        " var2[2][2];\n\n";
            shader_source += shader_start;

            shader_source += "    var1 = var2;\n";

            /* End main */
            DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

            /* Execute test */
            this->execute_negative_test(tested_shader_type, shader_source);
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/* Generates the shader source code for the ExpressionsTypeRestrictions2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsTypeRestrictions2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    int num_var_types = sizeof(opaque_var_types) / sizeof(opaque_var_types[0]);

    for (int var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(opaque_var_types[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string shader_source = "uniform " + var_iterator->second.precision + " " + var_iterator->second.type +
                                        " sampler1;\n"
                                        "uniform " +
                                        var_iterator->second.precision + " " + var_iterator->second.type +
                                        " sampler2;\n"
                                        "uniform " +
                                        var_iterator->second.precision + " " + var_iterator->second.type +
                                        " sampler3;\n"
                                        "uniform " +
                                        var_iterator->second.precision + " " + var_iterator->second.type +
                                        " sampler4;\n"
                                        "struct light1 {\n"
                                        "    " +
                                        var_iterator->second.type +
                                        " var1[2][2];\n"
                                        "};\n\n";
            shader_source += shader_start;

            shader_source +=
                ("    light1 x = light1(" + var_iterator->second.type + "[][](" + var_iterator->second.type +
                 "[](sampler1, sampler2), " + var_iterator->second.type + "[](sampler3, sampler4)));\n");
            shader_source += "    light1 y = x;\n\n";

            /* End main */
            DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

            /* Execute test */
            this->execute_negative_test(tested_shader_type, shader_source);
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/* Generates the shader source code for the ExpressionsIndexingScalar1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsIndexingScalar1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    for (size_t var_type_index = 0; var_type_index < API::n_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(API::var_types[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string shader_source = shader_start + "    " + var_iterator->second.type + " x[1][2][3][4];\n\n";

            shader_source += "    for (uint i = 0u; i < 2u; i++) {\n";
            shader_source += "        for (uint j = 0u; j < 3u; j++) {\n";
            shader_source += "            for (uint k = 0u; k < 4u; k++) {\n";
            shader_source += "                x[0][i][j][k] = " + var_iterator->second.initializer_with_ones + ";\n";
            shader_source += "            }\n";
            shader_source += "        }\n";
            shader_source += "    }\n";

            /* End main */
            DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

            /* Execute test */
            EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    }
}

/* Generates the shader source code for the ExpressionsIndexingScalar2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsIndexingScalar2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string base_shader_string, shader_source;

    // This test tests arrays with 4 dimensions, e.g. x[1][1][1][1]
    const int test_array_dimensions = 4;

    base_shader_string = "float a[1][2][3][4];\n";
    base_shader_string += "float b = 2.0;\n\n";
    base_shader_string += shader_start;

    // There are 16 permutations, so loop 4x4 times.
    for (int permutation = 0; permutation < (1 << test_array_dimensions); permutation++)
    {
        shader_source = base_shader_string + "    a"; // a var called 'a'

        for (int sub_script_index = test_array_dimensions - 1; sub_script_index >= 0; sub_script_index--)
        {
            /* If any bit is set for a particular number then add
             * a valid array sub_script at that place, otherwise
             * add an invalid array sub_script. */
            if (permutation & (1 << sub_script_index))
            {
                shader_source += "[0]";
            }
            else
            {
                shader_source += "[-1]";
            }
        }

        shader_source += " = b;\n";

        if (permutation != (1 << test_array_dimensions) - 1)
        {
            /* End main */
            DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

            /* Execute test */
            this->execute_negative_test(tested_shader_type, shader_source);
        } /* if (permutation != (1 << test_array_dimensions) - 1) */
    }     /* for (int permutation = 0; ...) */
}

/* Generates the shader source code for the ExpressionsIndexingScalar3
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsIndexingScalar3<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string base_shader_string;
    std::string shader_source;
    const int test_array_dimensions = 4;

    base_shader_string = "float a[1][2][3][4];\n";
    base_shader_string += "float b = 2.0;\n\n";
    base_shader_string += shader_start;

    for (int permutation = 0; permutation < (1 << test_array_dimensions); permutation++)
    {
        shader_source = base_shader_string + "    a";

        for (int sub_script_index = test_array_dimensions - 1; sub_script_index >= 0; sub_script_index--)
        {
            if (permutation & (1 << sub_script_index))
            {
                shader_source += "[0]";
            }
            else
            {
                shader_source += "[4]";
            }
        }

        shader_source += " = b;\n";

        if (permutation != (1 << test_array_dimensions) - 1)
        {
            /* End main */
            DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

            /* Execute test */
            this->execute_negative_test(tested_shader_type, shader_source);
        } /* if (permutation != (1 << test_array_dimensions) - 1) */
    }     /* for (int permutation = 0; ...) */
}

/* Generates the shader source code for the ExpressionsIndexingScalar4
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsIndexingScalar4<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string base_shader_string;
    std::string shader_source;

    const int test_array_dimensions = 4;

    base_shader_string = "float a[1][2][3][4];\n";
    base_shader_string += "float b = 2.0;\n\n";
    base_shader_string += shader_start;

    for (int permutation = 0; permutation < (1 << test_array_dimensions); permutation++)
    {
        shader_source = base_shader_string + "    a";

        for (int sub_script_index = test_array_dimensions - 1; sub_script_index >= 0; sub_script_index--)
        {
            if (permutation & (1 << sub_script_index))
            {
                shader_source += "[0]";
            }
            else
            {
                shader_source += "[]";
            }
        }

        shader_source += " = b;\n";

        if (permutation != (1 << test_array_dimensions) - 1)
        {
            /* End main */
            DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

            /* Execute test */
            this->execute_negative_test(tested_shader_type, shader_source);
        } /* if (permutation != (1 << test_array_dimensions) - 1) */
    }     /* for (int permutation = 0; ...) */
}

/* Generates the shader source code for the ExpressionsIndexingArray1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsIndexingArray1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string shader_source;
    std::string variable_declaration = "float x[1][1][1][1][1][1][1][1];\n\n";

    std::string variable_initializations[] = {
        "x[0]                      = float[1][1][1][1][1][1][1]("
        "float[1][1][1][1][1][1](float[1][1][1][1][1](float[1][1][1][1](float[1][1][1](float[1][1](float[1](1.0)))))));"
        "\n",
        "x[0][0]                   = "
        "float[1][1][1][1][1][1](float[1][1][1][1][1](float[1][1][1][1](float[1][1][1](float[1][1](float[1](1.0))))));"
        "\n",
        "x[0][0][0]                = "
        "float[1][1][1][1][1](float[1][1][1][1](float[1][1][1](float[1][1](float[1](1.0)))));\n",
        "x[0][0][0][0]             = float[1][1][1][1](float[1][1][1](float[1][1](float[1](1.0))));\n",
        "x[0][0][0][0][0]          = float[1][1][1](float[1][1](float[1](1.0)));\n",
        "x[0][0][0][0][0][0]       = float[1][1](float[1](1.0));\n",
        "x[0][0][0][0][0][0][0]    = float[1](1.0);\n",
        "x[0][0][0][0][0][0][0][0] = 1.0;\n"};

    for (size_t string_index = 0; string_index < sizeof(variable_initializations) / sizeof(variable_initializations[0]);
         string_index++)
    {
        shader_source = variable_declaration + shader_start;
        shader_source += "    " + variable_initializations[string_index];

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
    } /* for (int string_index = 0; ...) */
}

/* Constructs a suitable constructor for the specified number of dimensions.
 *
 * @tparam API            Tested API descriptor
 *
 * @param dimension_index The current recursion level (counts down)
 * @param init_string     The initialisation string
 */
template <class API>
std::string ExpressionsIndexingArray2<API>::recursively_initialise(std::string var_type, size_t dimension_index,
                                                                   std::string init_string)
{
    std::string temp_string;

    if (dimension_index == 0)
    {
        temp_string = init_string;
    }
    else
    {
        std::string prefix = "\n";

        for (size_t indent_index = dimension_index; indent_index < (API::MAX_ARRAY_DIMENSIONS + 1); indent_index++)
        {
            prefix += "    ";
        }

        prefix += this->extend_string(var_type, "[]", dimension_index);
        prefix += "(";
        for (int sub_script_index = 0; sub_script_index < 2; sub_script_index++)
        {
            temp_string += prefix;
            temp_string += recursively_initialise(var_type, dimension_index - 1, init_string);
            prefix = ", ";
            if (dimension_index == 1)
            {
                break;
            }
        }
        temp_string += ")";
    }

    return temp_string;
}

/* Generates the shader source code for the ExpressionsIndexingArray2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsIndexingArray2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string variable_initialiser = "    float[](float[](float(float(float(float(float(float(1.0))))))));\n";

    std::string x_variable_initializaton =
        "    float x[2][2][2][2][2][2][2][1] = " + recursively_initialise("float", API::MAX_ARRAY_DIMENSIONS, "1.0") +
        ";\n";
    std::string y_variable_initializaton =
        "    float y[2][2][2][2][2][2][2][1] = " + recursively_initialise("float", API::MAX_ARRAY_DIMENSIONS, "1.0") +
        ";\n";

    std::string shader_code_common_part = shader_start + x_variable_initializaton + y_variable_initializaton;

    for (size_t max_dimension_index = 1; max_dimension_index <= API::MAX_ARRAY_DIMENSIONS; max_dimension_index++)
    {
        std::string iteration_specific_shader_code_part;

        iteration_specific_shader_code_part += this->extend_string("    x", "[0]", max_dimension_index);
        iteration_specific_shader_code_part += " = ";
        iteration_specific_shader_code_part += this->extend_string("y", "[0]", max_dimension_index);
        iteration_specific_shader_code_part += ";\n";

        std::string shader_source = shader_code_common_part + iteration_specific_shader_code_part;

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
    }
}

/* Generates the shader source code for the ExpressionsIndexingArray3
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsIndexingArray3<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string input[] = {"    x[ivec2(0)] = 1.0;\n\n", "    x[ivec3(0)] = 1.0;\n\n", "    x[ivec4(0)] = 1.0;\n\n"};

    for (size_t string_index = 0; string_index < sizeof(input) / sizeof(input[0]); string_index++)
    {
        std::string shader_source = shader_start + this->extend_string("    float x", "[2]", (int)string_index + 2) +
                                    ";\n\n" + input[string_index];

        /* End main */
        DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

        /* Execute test */
        this->execute_negative_test(tested_shader_type, shader_source);
    } /* for (int string_index = 0; ...) */
}

/* Generates the shader source code for the ExpressionsDynamicIndexing1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsDynamicIndexing1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string expression_type_declarations = "uniform int a;\n"
                                               "const int b = 0;\n"
                                               "int c = 0;\n"
                                               "float x[2][2];\n";

    std::string expressions[] = {"a", "b", "c", "0 + 1"};
    std::string shader_source;

    for (size_t write_index = 0; write_index < sizeof(expressions) / sizeof(expressions[0]); write_index++)
    {
        for (size_t read_index = 0; read_index < sizeof(expressions) / sizeof(expressions[0]); read_index++)
        {
            shader_source = expression_type_declarations;
            shader_source += shader_start;
            shader_source += "    x[";
            shader_source += expressions[write_index];
            shader_source += "][";
            shader_source += expressions[read_index];
            shader_source += "] = 1.0;\n\n";

            /* End main */
            DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

            /* Execute test */
            EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
        } /* for (int read_index = 0; ...) */
    }     /* for (int write_index = 0; ...) */
}

/* Generates the shader source code for the ExpressionsDynamicIndexing2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsDynamicIndexing2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    int num_var_types                             = sizeof(opaque_var_types) / sizeof(opaque_var_types[0]);
    const std::string invalid_size_declarations[] = {"[0][0][0][y]", "[0][0][y][0]", "[0][y][0][0]", "[y][0][0][0]",
                                                     "[0][0][y][y]", "[0][y][0][y]", "[y][0][0][y]", "[0][y][y][0]",
                                                     "[y][0][y][0]", "[y][y][0][0]", "[0][y][y][y]", "[y][0][y][y]",
                                                     "[y][y][0][y]", "[y][y][y][0]", "[y][y][y][y]"};

    bool dynamic_indexing_supported = false;
    if (glu::contextSupports(this->context_id.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
        glu::contextSupports(this->context_id.getRenderContext().getType(), glu::ApiType::core(4, 0)) ||
        this->context_id.getContextInfo().isExtensionSupported("GL_EXT_gpu_shader5"))
    {
        dynamic_indexing_supported = true;
    }

    for (int var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(opaque_var_types[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            int num_invalid_size_declarations =
                sizeof(invalid_size_declarations) / sizeof(invalid_size_declarations[0]);

            for (int invalid_size_index = 0; invalid_size_index < num_invalid_size_declarations; invalid_size_index++)
            {
                std::string shader_source = "int y = 1;\n";

                shader_source += "uniform " + var_iterator->second.precision + " " + var_iterator->second.type +
                                 " x[2][2][2][2];\n\n";
                shader_source += "void main()\n";
                shader_source += "{\n";
                shader_source += ("    " + var_iterator->second.type_of_result_of_texture_function +
                                  " color = texture(x" + invalid_size_declarations[invalid_size_index] + ", " +
                                  var_iterator->second.coord_param_for_texture_function + ");\n");

                /* End main */
                DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

                if (dynamic_indexing_supported)
                {
                    EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, true);
                }
                else
                {
                    this->execute_negative_test(tested_shader_type, shader_source);
                }
            } /* for (int invalid_size_index = 0; ...) */
        }     /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/* Generates the shader source code for the ExpressionsEquality1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsEquality1<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    int num_var_types = API::n_var_types;

    for (int var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(API::var_types[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string shader_source = shader_start;

            shader_source += "    ";
            shader_source += var_iterator->second.type;
            shader_source += "[][] x = ";
            shader_source += var_iterator->second.type;
            shader_source += "[][](";
            shader_source += var_iterator->second.type;
            shader_source += "[](";
            shader_source += var_iterator->second.initializer_with_zeroes;
            shader_source += ",";
            shader_source += var_iterator->second.initializer_with_zeroes;
            shader_source += "),";
            shader_source += var_iterator->second.type;
            shader_source += "[](";
            shader_source += var_iterator->second.initializer_with_zeroes;
            shader_source += ",";
            shader_source += var_iterator->second.initializer_with_zeroes;
            shader_source += "));\n";
            shader_source += "    ";
            shader_source += var_iterator->second.type;
            shader_source += "[][] y = ";
            shader_source += var_iterator->second.type;
            shader_source += "[][](";
            shader_source += var_iterator->second.type;
            shader_source += "[](";
            shader_source += var_iterator->second.initializer_with_zeroes;
            shader_source += ",";
            shader_source += var_iterator->second.initializer_with_zeroes;
            shader_source += "),";
            shader_source += var_iterator->second.type;
            shader_source += "[](";
            shader_source += var_iterator->second.initializer_with_zeroes;
            shader_source += ",";
            shader_source += var_iterator->second.initializer_with_zeroes;
            shader_source += "));\n\n";
            shader_source += "    float result = 0.0;\n\n";
            shader_source += "    if (x == y)\n";
            shader_source += "    {\n";
            shader_source += "        result = 1.0;\n";
            shader_source += "    }\n";
            shader_source += "    if (y != x)\n";
            shader_source += "    {\n";
            shader_source += "        result = 2.0;\n";
            shader_source += "    }\n";

            /* End main */
            DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

            /* Execute test */
            EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    }
}

/* Generates the shader source code for the ExpressionsEquality2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsEquality2<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    int num_var_types = API::n_var_types;

    for (int var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(API::var_types[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string shader_source = "struct light {\n    float intensity;\n    int position;\n};\n\n";

            shader_source += shader_start;
            shader_source += "    light[][] x =";
            shader_source += "light";
            shader_source += "[][](";
            shader_source += "light";
            shader_source += "[](light(1.0, 1)),";
            shader_source += "light";
            shader_source += "[](light(2.0, 2)));\n\n";
            shader_source += "    light[][] y =";
            shader_source += "light";
            shader_source += "[][](";
            shader_source += "light";
            shader_source += "[](light(3.0, 3)),";
            shader_source += "light";
            shader_source += "[](light(4.0, 4)));\n\n";
            shader_source += "    float result = 0.0;\n\n";
            shader_source += "    if (x == y)\n";
            shader_source += "    {\n";
            shader_source += "        result = 1.0;\n";
            shader_source += "    }\n";
            shader_source += "    if (y != x)\n";
            shader_source += "    {\n";
            shader_source += "        result = 2.0;\n";
            shader_source += "    }\n";

            /* Apply stage specific stuff */
            switch (tested_shader_type)
            {
            case TestCaseBase<API>::VERTEX_SHADER_TYPE:
                shader_source += "\n    gl_Position = vec4(0.0,0.0,0.0,1.0);\n";
                break;
            case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
                shader_source += "\n    gl_FragDepth = result;\n";
                break;
            case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
                break;
            case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
                shader_source += emit_quad;
                break;
            case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
                shader_source += set_tesseation;
                break;
            case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
                break;
            default:
                TCU_FAIL("Unrecognized shader type.");
                break;
            }

            /* End main function */
            shader_source += shader_end;

            /* Execute test */
            EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    }
}

/* Generates the shader source code for the ExpressionsLength1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsLength1<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string array_declaration      = "    int x[4][3][2][1];\n\n";
    std::string case_specific_string[] = {"    if (x.length() != 4) {\n"
                                          "        result = 0.0f;\n    }\n",
                                          "    if (x[0].length() != 3) {\n"
                                          "        result = 0.0f;\n    }\n",
                                          "    if (x[0][0].length() != 2) {\n"
                                          "        result = 0.0f;\n    }\n",
                                          "    if (x[0][0][0].length() != 1) {\n"
                                          "        result = 0.0f;\n    }\n"};
    const bool test_compute            = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type);

    for (size_t case_specific_string_index = 0;
         case_specific_string_index < sizeof(case_specific_string) / sizeof(case_specific_string[0]);
         case_specific_string_index++)
    {
        const std::string &test_snippet = case_specific_string[case_specific_string_index];

        if (false == test_compute)
        {
            execute_draw_test(tested_shader_type, array_declaration, test_snippet);
        }
        else
        {
            execute_dispatch_test(tested_shader_type, array_declaration, test_snippet);
        }

        /* Deallocate any resources used. */
        this->delete_objects();
    } /* for (int case_specific_string_index = 0; ...) */
}

/** Executes test for compute program
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 * @param tested_declaration Declaration used to prepare shader
 * @param tested_snippet     Snippet used to prepare shader
 **/
template <class API>
void ExpressionsLength1<API>::execute_dispatch_test(typename TestCaseBase<API>::TestShaderType tested_shader_type,
                                                    const std::string &tested_declaration,
                                                    const std::string &tested_snippet)
{
    const std::string &compute_shader_source =
        prepare_compute_shader(tested_shader_type, tested_declaration, tested_snippet);
    const glw::Functions &gl = this->context_id.getRenderContext().getFunctions();

    this->execute_positive_test(empty_string, empty_string, empty_string, empty_string, empty_string,
                                compute_shader_source, false, false);

    /* We are now ready to verify whether the returned size is correct. */
    unsigned char buffer[4]           = {0};
    glw::GLuint framebuffer_object_id = 0;
    glw::GLint location               = -1;
    glw::GLuint texture_object_id     = 0;
    glw::GLuint vao_id                = 0;

    gl.useProgram(this->program_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed.");

    gl.genTextures(1, &texture_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed.");

    gl.bindTexture(GL_TEXTURE_2D, texture_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() failed.");

    gl.texStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 1);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() failed.");

    gl.bindImageTexture(0 /* image unit */, texture_object_id, 0 /* level */, GL_FALSE /* layered */, 0 /* layer */,
                        GL_WRITE_ONLY, GL_RGBA8);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture() failed.");

    location = gl.getUniformLocation(this->program_object_id, "uni_image");
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation() failed.");

    if (-1 == location)
    {
        TCU_FAIL("Uniform is inactive");
    }

    gl.uniform1i(location, 0 /* image unit */);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i() failed.");

    gl.genVertexArrays(1, &vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() failed.");

    gl.bindVertexArray(vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() failed.");

    gl.dispatchCompute(1, 1, 1);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");

    gl.genFramebuffers(1, &framebuffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() failed.");

    gl.bindFramebuffer(GL_FRAMEBUFFER, framebuffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() failed.");

    gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_object_id, 0);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() failed.");

    gl.viewport(0, 0, 1, 1);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() failed.");

    gl.readBuffer(GL_COLOR_ATTACHMENT0);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glReadBuffer() failed.");

    gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() failed.");

    if (buffer[0] != 255)
    {
        TCU_FAIL("Invalid array size was returned.");
    }

    /* Delete generated objects. */
    gl.deleteTextures(1, &texture_object_id);
    gl.deleteFramebuffers(1, &framebuffer_object_id);
    gl.deleteVertexArrays(1, &vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "An error ocurred while deleting generated objects.");
}

/** Executes test for draw program
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 * @param tested_declaration Declaration used to prepare shader
 * @param tested_snippet     Snippet used to prepare shader
 **/
template <class API>
void ExpressionsLength1<API>::execute_draw_test(typename TestCaseBase<API>::TestShaderType tested_shader_type,
                                                const std::string &tested_declaration,
                                                const std::string &tested_snippet)
{
    const glw::Functions &gl = this->context_id.getRenderContext().getFunctions();

    if (API::USE_ALL_SHADER_STAGES)
    {
        const std::string &compute_shader_source = empty_string;
        const std::string &fragment_shader_source =
            this->prepare_fragment_shader(tested_shader_type, tested_declaration, tested_snippet);
        const std::string &geometry_shader_source =
            this->prepare_geometry_shader(tested_shader_type, tested_declaration, tested_snippet);
        const std::string &tess_ctrl_shader_source =
            this->prepare_tess_ctrl_shader(tested_shader_type, tested_declaration, tested_snippet);
        const std::string &tess_eval_shader_source =
            this->prepare_tess_eval_shader(tested_shader_type, tested_declaration, tested_snippet);
        const std::string &vertex_shader_source =
            this->prepare_vertex_shader(tested_shader_type, tested_declaration, tested_snippet);

        switch (tested_shader_type)
        {
        case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */
        case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
            this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false);
            break;

        case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */
        case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
            this->execute_positive_test(vertex_shader_source, tess_ctrl_shader_source, tess_eval_shader_source,
                                        geometry_shader_source, fragment_shader_source, compute_shader_source, false,
                                        false);
            break;

        default:
            TCU_FAIL("Invalid enum");
            break;
        }
    }
    else
    {
        const std::string &fragment_shader_source =
            this->prepare_fragment_shader(tested_shader_type, tested_declaration, tested_snippet);
        const std::string &vertex_shader_source =
            this->prepare_vertex_shader(tested_shader_type, tested_declaration, tested_snippet);

        this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false);
    }

    /* We are now ready to verify whether the returned size is correct. */
    unsigned char buffer[4]           = {0};
    glw::GLuint framebuffer_object_id = 0;
    glw::GLuint texture_object_id     = 0;
    glw::GLuint vao_id                = 0;

    gl.useProgram(this->program_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed.");

    gl.genTextures(1, &texture_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed.");

    gl.bindTexture(GL_TEXTURE_2D, texture_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() failed.");

    gl.texStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 1);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() failed.");

    gl.genFramebuffers(1, &framebuffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() failed.");

    gl.bindFramebuffer(GL_FRAMEBUFFER, framebuffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() failed.");

    gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_object_id, 0);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() failed.");

    gl.viewport(0, 0, 1, 1);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() failed.");

    gl.genVertexArrays(1, &vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() failed.");

    gl.bindVertexArray(vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() failed.");

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: /* Fall through */
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        gl.drawArrays(GL_TRIANGLE_FAN, 0, 4);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        /* Tesselation patch set up */
        gl.patchParameteri(GL_PATCH_VERTICES, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "PatchParameteri");

        gl.drawArrays(GL_PATCHES, 0, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        gl.drawArrays(GL_POINTS, 0, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");
        break;

    default:
        TCU_FAIL("Invalid enum");
        break;
    }

    gl.readBuffer(GL_COLOR_ATTACHMENT0);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glReadBuffer() failed.");

    gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() failed.");

    if (buffer[0] != 255)
    {
        TCU_FAIL("Invalid array size was returned.");
    }

    /* Delete generated objects. */
    gl.deleteTextures(1, &texture_object_id);
    gl.deleteFramebuffers(1, &framebuffer_object_id);
    gl.deleteVertexArrays(1, &vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "An error ocurred while deleting generated objects.");
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 * @param tested_declaration Declaration used to prepare shader
 * @param tested_snippet     Snippet used to prepare shader
 **/
template <class API>
std::string ExpressionsLength1<API>::prepare_compute_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &tested_declaration,
    const std::string &tested_snippet)
{
    std::string compute_shader_source;

    if (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type)
    {
        compute_shader_source = "writeonly uniform image2D uni_image;\n"
                                "\n"
                                "void main()\n"
                                "{\n"
                                "    float result = 1u;\n"
                                "\n";
        compute_shader_source += tested_declaration;
        compute_shader_source += tested_snippet;
        compute_shader_source += "\n"
                                 "    imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), vec4(result, 0, 0, 0));\n"
                                 "}\n"
                                 "\n";
    }

    return compute_shader_source;
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 * @param tested_declaration Declaration used to prepare shader
 * @param tested_snippet     Snippet used to prepare shader
 **/
template <class API>
std::string ExpressionsLength1<API>::prepare_fragment_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &tested_declaration,
    const std::string &tested_snippet)
{
    std::string fragment_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        break;

    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        fragment_shader_source = "out vec4 colour;\n"
                                 "\n"
                                 "void main()\n"
                                 "{\n";
        fragment_shader_source += tested_declaration;
        fragment_shader_source += "    float result = 1.0f;\n";
        fragment_shader_source += tested_snippet;
        fragment_shader_source += "    colour = vec4(result);\n"
                                  "}\n\n";
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        fragment_shader_source = "in float fs_result;\n\n"
                                 "out vec4 colour;\n\n"
                                 "void main()\n"
                                 "{\n"
                                 "    colour =  vec4(fs_result);\n"
                                 "}\n"
                                 "\n";
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return fragment_shader_source;
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 * @param tested_declaration Declaration used to prepare shader
 * @param tested_snippet     Snippet used to prepare shader
 **/
template <class API>
std::string ExpressionsLength1<API>::prepare_geometry_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &tested_declaration,
    const std::string &tested_snippet)
{
    std::string geometry_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        geometry_shader_source = "layout(points)                           in;\n"
                                 "layout(triangle_strip, max_vertices = 4) out;\n"
                                 "\n"
                                 "in  float tes_result[];\n"
                                 "out float fs_result;\n"
                                 "\n"
                                 "void main()\n"
                                 "{\n"
                                 "    gl_Position  = vec4(-1, -1, 0, 1);\n"
                                 "    fs_result    = tes_result[0];\n"
                                 "    EmitVertex();\n"
                                 "    gl_Position  = vec4(-1, 1, 0, 1);\n"
                                 "    fs_result    = tes_result[0];\n"
                                 "    EmitVertex();\n"
                                 "    gl_Position  = vec4(1, -1, 0, 1);\n"
                                 "    fs_result    = tes_result[0];\n"
                                 "    EmitVertex();\n"
                                 "    gl_Position  = vec4(1, 1, 0, 1);\n"
                                 "    fs_result    = tes_result[0];\n"
                                 "    EmitVertex();\n"
                                 "}\n";
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        geometry_shader_source = "layout(points)                           in;\n"
                                 "layout(triangle_strip, max_vertices = 4) out;\n"
                                 "\n"
                                 "out float fs_result;\n"
                                 "\n"
                                 "void main()\n"
                                 "{\n";
        geometry_shader_source += tested_declaration;
        geometry_shader_source += "    float result = 1.0;\n\n";
        geometry_shader_source += tested_snippet;
        geometry_shader_source += "\n    gl_Position  = vec4(-1, -1, 0, 1);\n"
                                  "    fs_result    = result;\n"
                                  "    EmitVertex();\n"
                                  "    gl_Position  = vec4(-1, 1, 0, 1);\n"
                                  "    fs_result    = result;\n"
                                  "    EmitVertex();\n"
                                  "    gl_Position  = vec4(1, -1, 0, 1);\n"
                                  "    fs_result    = result;\n"
                                  "    EmitVertex();\n"
                                  "    gl_Position  = vec4(1, 1, 0, 1);\n"
                                  "    fs_result    = result;\n"
                                  "    EmitVertex();\n"
                                  "}\n";
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return geometry_shader_source;
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 * @param tested_declaration Declaration used to prepare shader
 * @param tested_snippet     Snippet used to prepare shader
 **/
template <class API>
std::string ExpressionsLength1<API>::prepare_tess_ctrl_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &tested_declaration,
    const std::string &tested_snippet)
{
    std::string tess_ctrl_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        tess_ctrl_shader_source = "layout(vertices = 1) out;\n"
                                  "\n"
                                  "out float tcs_result[];\n"
                                  "\n"
                                  "void main()\n"
                                  "{\n";
        tess_ctrl_shader_source += tested_declaration;
        tess_ctrl_shader_source += "    float result = 1.0;\n\n";
        tess_ctrl_shader_source += tested_snippet;
        tess_ctrl_shader_source += "    tcs_result[gl_InvocationID] = result;\n"
                                   "\n"
                                   "    gl_TessLevelOuter[0] = 1.0;\n"
                                   "    gl_TessLevelOuter[1] = 1.0;\n"
                                   "    gl_TessLevelOuter[2] = 1.0;\n"
                                   "    gl_TessLevelOuter[3] = 1.0;\n"
                                   "    gl_TessLevelInner[0] = 1.0;\n"
                                   "    gl_TessLevelInner[1] = 1.0;\n"
                                   "}\n";
        break;

    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        tess_ctrl_shader_source = default_tc_shader_source;
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return tess_ctrl_shader_source;
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 * @param tested_declaration Declaration used to prepare shader
 * @param tested_snippet     Snippet used to prepare shader
 **/
template <class API>
std::string ExpressionsLength1<API>::prepare_tess_eval_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &tested_declaration,
    const std::string &tested_snippet)
{
    std::string tess_eval_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        tess_eval_shader_source = "layout(isolines, point_mode) in;\n"
                                  "\n"
                                  "in  float tcs_result[];\n"
                                  "out float tes_result;\n"
                                  "\n"
                                  "void main()\n"
                                  "{\n"
                                  "    tes_result = tcs_result[0];\n"
                                  "}\n";
        break;

    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        tess_eval_shader_source = "layout(isolines, point_mode) in;\n"
                                  "\n"
                                  "out float tes_result;\n"
                                  "\n"
                                  "void main()\n"
                                  "{\n";
        tess_eval_shader_source += tested_declaration;
        tess_eval_shader_source += "    float result = 1.0;\n\n";
        tess_eval_shader_source += tested_snippet;
        tess_eval_shader_source += "    tes_result = result;\n"
                                   "}\n";
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return tess_eval_shader_source;
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 * @param tested_declaration Declaration used to prepare shader
 * @param tested_snippet     Snippet used to prepare shader
 **/
template <class API>
std::string ExpressionsLength1<API>::prepare_vertex_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &tested_declaration,
    const std::string &tested_snippet)
{
    std::string vertex_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        break;

    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        vertex_shader_source = "/** GL_TRIANGLE_FAN-type quad vertex data. */\n"
                               "const vec4 vertex_positions[4] = vec4[4](vec4( 1.0, -1.0, 0.0, 1.0),\n"
                               "                                         vec4(-1.0, -1.0, 0.0, 1.0),\n"
                               "                                         vec4(-1.0,  1.0, 0.0, 1.0),\n"
                               "                                         vec4( 1.0,  1.0, 0.0, 1.0) );\n"
                               "\n"
                               "void main()\n"
                               "{\n"
                               "    gl_Position = vertex_positions[gl_VertexID];"
                               "}\n\n";
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        vertex_shader_source = default_vertex_shader_source;
        break;

    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        vertex_shader_source = "out float fs_result;\n"
                               "\n"
                               "/** GL_TRIANGLE_FAN-type quad vertex data. */\n"
                               "const vec4 vertex_positions[4] = vec4[4](vec4( 1.0, -1.0, 0.0, 1.0),\n"
                               "                                         vec4(-1.0, -1.0, 0.0, 1.0),\n"
                               "                                         vec4(-1.0,  1.0, 0.0, 1.0),\n"
                               "                                         vec4( 1.0,  1.0, 0.0, 1.0) );\n"
                               "\n"
                               "void main()\n"
                               "{\n";
        vertex_shader_source += tested_declaration;
        vertex_shader_source += "    float result = 1.0;\n\n";
        vertex_shader_source += tested_snippet;
        vertex_shader_source += "    gl_Position = vertex_positions[gl_VertexID];\n"
                                "    fs_result = result;\n";
        vertex_shader_source += shader_end;
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return vertex_shader_source;
}

/* Generates the shader source code for the ExpressionsLength2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsLength2<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string array_declaration      = "    int x[1][2][3][4];\n\n";
    std::string case_specific_string[] = {"    if (x.length() != 1) {\n"
                                          "        result = 0.0f;\n    }\n",
                                          "    if (x[0].length() != 2) {\n"
                                          "        result = 0.0f;\n    }\n",
                                          "    if (x[0][0].length() != 3) {\n"
                                          "        result = 0.0f;\n    }\n",
                                          "    if (x[0][0][0].length() != 4) {\n"
                                          "        result = 0.0f;\n    }\n"};
    const bool test_compute            = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type);

    for (size_t case_specific_string_index = 0;
         case_specific_string_index < sizeof(case_specific_string) / sizeof(case_specific_string[0]);
         case_specific_string_index++)
    {
        const std::string &test_snippet = case_specific_string[case_specific_string_index];

        if (false == test_compute)
        {
            this->execute_draw_test(tested_shader_type, array_declaration, test_snippet);
        }
        else
        {
            this->execute_dispatch_test(tested_shader_type, array_declaration, test_snippet);
        }

        /* Deallocate any resources used. */
        this->delete_objects();
    } /* for (int case_specific_string_index = 0; ...) */
}

/* Generates the shader source code for the ExpressionsLength3
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsLength3<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string array_declaration = "    int x[1][1][1][1];\n\n";
    std::string input[]           = {"    if (x[].length() != 2) {\n"
                                               "        result = 0.0f;\n    }\n",
                                     "    if (x[][].length() != 2)  {\n"
                                               "        result = 0.0f;\n    }\n",
                                     "    if (x[][][].length() != 2)  {\n"
                                               "        result = 0.0f;\n    }\n"};

    for (size_t string_index = 0; string_index < sizeof(input) / sizeof(input[0]); string_index++)
    {
        std::string shader_source;
        const std::string &test_snippet = input[string_index];

        switch (tested_shader_type)
        {
        case TestCaseBase<API>::VERTEX_SHADER_TYPE:
            shader_source = this->prepare_vertex_shader(tested_shader_type, array_declaration, test_snippet);
            break;

        case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
            shader_source = this->prepare_fragment_shader(tested_shader_type, array_declaration, test_snippet);
            break;

        case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
            shader_source = this->prepare_compute_shader(tested_shader_type, array_declaration, test_snippet);
            break;

        case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
            shader_source = this->prepare_geometry_shader(tested_shader_type, array_declaration, test_snippet);
            break;

        case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
            shader_source = this->prepare_tess_ctrl_shader(tested_shader_type, array_declaration, test_snippet);
            break;

        case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
            shader_source = this->prepare_tess_eval_shader(tested_shader_type, array_declaration, test_snippet);
            break;

        default:
            TCU_FAIL("Unrecognized shader type.");
            break;
        } /* switch (tested_shader_type) */

        this->execute_negative_test(tested_shader_type, shader_source);
    } /* for (int string_index = 0; ...) */
}

/* Generates the shader source code for the ExpressionsInvalid1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsInvalid1<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    std::string shader_variable_declarations =
        "    mat2  y       = mat2(0.0);\n"
        "    float x[2][2] = float[2][2](float[2](4.0, 5.0), float[2](6.0, 7.0));\n\n";

    std::string shader_source = shader_start + shader_variable_declarations;

    shader_source += "    y = x;\n";

    DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

    this->execute_negative_test(tested_shader_type, shader_source);
}

/* Generates the shader source code for the ExpressionsInvalid2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void ExpressionsInvalid2<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type)
{

    std::string shader_variable_declarations[] = {" x", " y"};
    std::string variable_relation_opeartors[]  = {
        "    float result = 0.0;\n\n    if(x < y)\n    {\n        result = 1.0;\n    }\n\n\n",
        "    float result = 0.0;\n\n    if(x <= y)\n    {\n        result = 1.0;\n    }\n\n\n",
        "    float result = 0.0;\n\n    if(x > y)\n    {\n        result = 1.0;\n    }\n\n\n",
        "    float result = 0.0;\n\n    if(x >= y)\n    {\n        result = 1.0;\n    }\n\n\n"};
    std::string valid_relation_opeartors =
        "    float result = 0.0;\n\n    if(x == y)\n    {\n        result = 1.0;\n    }\n\n\n";

    for (size_t var_type_index = 0; var_type_index < API::n_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(API::var_types[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string base_variable_string;

            for (size_t variable_declaration_index = 0;
                 variable_declaration_index <
                 sizeof(shader_variable_declarations) / sizeof(shader_variable_declarations[0]);
                 variable_declaration_index++)
            {
                base_variable_string += var_iterator->second.type;
                base_variable_string += shader_variable_declarations[variable_declaration_index];

                base_variable_string += "[1][1][1][1][1][1][1][1] = ";

                for (size_t sub_script_index = 0; sub_script_index < API::MAX_ARRAY_DIMENSIONS; sub_script_index++)
                {
                    base_variable_string += this->extend_string(var_iterator->second.type, "[1]",
                                                                API::MAX_ARRAY_DIMENSIONS - sub_script_index);
                    base_variable_string += "(";
                }

                base_variable_string += var_iterator->second.initializer_with_ones;

                for (size_t sub_script_index = 0; sub_script_index < API::MAX_ARRAY_DIMENSIONS; sub_script_index++)
                {
                    base_variable_string += ")";
                }

                base_variable_string += ";\n";
            } /* for (int variable_declaration_index = 0; ...) */

            /* Run positive case */
            {
                std::string shader_source;

                shader_source = base_variable_string + "\n";
                shader_source += shader_start + valid_relation_opeartors;

                DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

                EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
            }

            /* Run negative cases */
            for (size_t string_index = 0;
                 string_index < sizeof(variable_relation_opeartors) / sizeof(variable_relation_opeartors[0]);
                 string_index++)
            {
                std::string shader_source;

                shader_source = base_variable_string + "\n";
                shader_source += shader_start + variable_relation_opeartors[string_index];

                DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

                this->execute_negative_test(tested_shader_type, shader_source);
            } /* for (int string_index = 0; ...) */
        }     /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/* Generates the shader source code for the InteractionFunctionCalls1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void InteractionFunctionCalls1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {
        VAR_TYPE_INT,  VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2,
        VAR_TYPE_VEC3, VAR_TYPE_VEC4,  VAR_TYPE_MAT2,  VAR_TYPE_MAT3,  VAR_TYPE_MAT4};
    static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {
        VAR_TYPE_INT,  VAR_TYPE_FLOAT,  VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, VAR_TYPE_IVEC4,
        VAR_TYPE_VEC2, VAR_TYPE_VEC3,   VAR_TYPE_VEC4,  VAR_TYPE_MAT2,  VAR_TYPE_MAT3,
        VAR_TYPE_MAT4, VAR_TYPE_DOUBLE, VAR_TYPE_DMAT2, VAR_TYPE_DMAT3, VAR_TYPE_DMAT4};
    static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const std::string iteration_loop_end      = "                }\n"
                                                "            }\n"
                                                "        }\n"
                                                "    }\n";
    const std::string iteration_loop_start    = "    for (uint a = 0u; a < 2u; a++)\n"
                                                "    {\n"
                                                "        for (uint b = 0u; b < 2u; b++)\n"
                                                "        {\n"
                                                "            for (uint c = 0u; c < 2u; c++)\n"
                                                "            {\n"
                                                "                for (uint d = 0u; d < 2u; d++)\n"
                                                "                {\n";
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;
    const bool test_compute                   = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type);

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string iterator_declaration = "    " + var_iterator->second.iterator_type +
                                               " iterator = " + var_iterator->second.iterator_initialization + ";\n";

            std::string function_definition;
            std::string function_use;
            std::string verification;

            function_definition = "void my_function(out ";
            function_definition += var_iterator->second.type;
            function_definition += " output_array[2][2][2][2]) {\n";
            function_definition += iterator_declaration;
            function_definition += iteration_loop_start;
            function_definition += "                                   output_array[a][b][c][d] = " +
                                   var_iterator->second.variable_type_initializer1 + ";\n";
            function_definition +=
                "                                   iterator += " + var_iterator->second.iterator_type + "(1);\n";
            function_definition += iteration_loop_end;
            function_definition += "}";

            function_use = "    " + var_iterator->second.type + " my_array[2][2][2][2];\n";
            function_use += "    my_function(my_array);";

            verification = iterator_declaration;
            verification += "    float result = 1.0;\n";
            verification += iteration_loop_start;
            verification += "                                   if (my_array[a][b][c][d] " +
                            var_iterator->second.specific_element +
                            " != iterator)\n"
                            "                                   {\n"
                            "                                       result = 0.0;\n"
                            "                                   }\n"
                            "                                   iterator += " +
                            var_iterator->second.iterator_type + "(1);\n";
            verification += iteration_loop_end;

            if (false == test_compute)
            {
                execute_draw_test(tested_shader_type, function_definition, function_use, verification);
            }
            else
            {
                execute_dispatch_test(tested_shader_type, function_definition, function_use, verification);
            }

            /* Deallocate any resources used. */
            this->delete_objects();
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/** Executes test for compute program
 *
 * @tparam API                Tested API descriptor
 *
 * @param tested_shader_type  The type of shader that is being tested
 * @param function_definition Definition used to prepare shader
 * @param function_use        Snippet that makes use of defined function
 * @param verification        Snippet that verifies results
 **/
template <class API>
void InteractionFunctionCalls1<API>::execute_dispatch_test(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &function_definition,
    const std::string &function_use, const std::string &verification)
{
    const std::string &compute_shader_source =
        prepare_compute_shader(tested_shader_type, function_definition, function_use, verification);
    const glw::Functions &gl = this->context_id.getRenderContext().getFunctions();

    this->execute_positive_test(empty_string, empty_string, empty_string, empty_string, empty_string,
                                compute_shader_source, false, false);

    /* We are now ready to verify whether the returned size is correct. */
    unsigned char buffer[4]           = {0};
    glw::GLuint framebuffer_object_id = 0;
    glw::GLint location               = -1;
    glw::GLuint texture_object_id     = 0;
    glw::GLuint vao_id                = 0;

    gl.useProgram(this->program_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed.");

    gl.genTextures(1, &texture_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed.");

    gl.bindTexture(GL_TEXTURE_2D, texture_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() failed.");

    gl.texStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 1);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() failed.");

    gl.bindImageTexture(0 /* image unit */, texture_object_id, 0 /* level */, GL_FALSE /* layered */, 0 /* layer */,
                        GL_WRITE_ONLY, GL_RGBA8);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture() failed.");

    location = gl.getUniformLocation(this->program_object_id, "uni_image");
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation() failed.");

    if (-1 == location)
    {
        TCU_FAIL("Uniform is inactive");
    }

    gl.uniform1i(location, 0 /* image unit */);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i() failed.");

    gl.genVertexArrays(1, &vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() failed.");

    gl.bindVertexArray(vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() failed.");

    gl.dispatchCompute(1, 1, 1);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");

    gl.genFramebuffers(1, &framebuffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() failed.");

    gl.bindFramebuffer(GL_FRAMEBUFFER, framebuffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() failed.");

    gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_object_id, 0);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() failed.");

    gl.viewport(0, 0, 1, 1);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() failed.");

    gl.readBuffer(GL_COLOR_ATTACHMENT0);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glReadBuffer() failed.");

    gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() failed.");

    if (buffer[0] != 255)
    {
        TCU_FAIL("Invalid array size was returned.");
    }

    /* Delete generated objects. */
    gl.deleteTextures(1, &texture_object_id);
    gl.deleteFramebuffers(1, &framebuffer_object_id);
    gl.deleteVertexArrays(1, &vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "An error ocurred while deleting generated objects.");
}

/** Executes test for draw program
 *
 * @tparam API                Tested API descriptor
 *
 * @param tested_shader_type  The type of shader that is being tested
 * @param function_definition Definition used to prepare shader
 * @param function_use        Snippet that makes use of defined function
 * @param verification        Snippet that verifies results
 **/
template <class API>
void InteractionFunctionCalls1<API>::execute_draw_test(typename TestCaseBase<API>::TestShaderType tested_shader_type,
                                                       const std::string &function_definition,
                                                       const std::string &function_use, const std::string &verification)
{
    const glw::Functions &gl = this->context_id.getRenderContext().getFunctions();

    if (API::USE_ALL_SHADER_STAGES)
    {
        const std::string &compute_shader_source = empty_string;
        const std::string &fragment_shader_source =
            this->prepare_fragment_shader(tested_shader_type, function_definition, function_use, verification);
        const std::string &geometry_shader_source =
            this->prepare_geometry_shader(tested_shader_type, function_definition, function_use, verification);
        const std::string &tess_ctrl_shader_source =
            this->prepare_tess_ctrl_shader(tested_shader_type, function_definition, function_use, verification);
        const std::string &tess_eval_shader_source =
            this->prepare_tess_eval_shader(tested_shader_type, function_definition, function_use, verification);
        const std::string &vertex_shader_source =
            this->prepare_vertex_shader(tested_shader_type, function_definition, function_use, verification);

        switch (tested_shader_type)
        {
        case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */
        case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
            this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false);
            break;

        case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */
        case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
            this->execute_positive_test(vertex_shader_source, tess_ctrl_shader_source, tess_eval_shader_source,
                                        geometry_shader_source, fragment_shader_source, compute_shader_source, false,
                                        false);
            break;

        default:
            TCU_FAIL("Invalid enum");
            break;
        }
    }
    else
    {
        const std::string &fragment_shader_source =
            this->prepare_fragment_shader(tested_shader_type, function_definition, function_use, verification);
        const std::string &vertex_shader_source =
            this->prepare_vertex_shader(tested_shader_type, function_definition, function_use, verification);

        this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false);
    }

    /* We are now ready to verify whether the returned size is correct. */
    unsigned char buffer[4]           = {0};
    glw::GLuint framebuffer_object_id = 0;
    glw::GLuint texture_object_id     = 0;
    glw::GLuint vao_id                = 0;

    gl.useProgram(this->program_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed.");

    gl.genTextures(1, &texture_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed.");

    gl.bindTexture(GL_TEXTURE_2D, texture_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() failed.");

    gl.texStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 1);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() failed.");

    gl.genFramebuffers(1, &framebuffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() failed.");

    gl.bindFramebuffer(GL_FRAMEBUFFER, framebuffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() failed.");

    gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_object_id, 0);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() failed.");

    gl.viewport(0, 0, 1, 1);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() failed.");

    gl.genVertexArrays(1, &vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() failed.");

    gl.bindVertexArray(vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() failed.");

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: /* Fall through */
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        gl.drawArrays(GL_TRIANGLE_FAN, 0, 4);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        /* Tesselation patch set up */
        gl.patchParameteri(GL_PATCH_VERTICES, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "PatchParameteri");

        gl.drawArrays(GL_PATCHES, 0, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        gl.drawArrays(GL_POINTS, 0, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");
        break;

    default:
        TCU_FAIL("Invalid enum");
        break;
    }

    gl.readBuffer(GL_COLOR_ATTACHMENT0);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glReadBuffer() failed.");

    gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() failed.");

    if (buffer[0] != 255)
    {
        TCU_FAIL("Invalid array size was returned.");
    }

    /* Delete generated objects. */
    gl.bindTexture(GL_TEXTURE_2D, 0);
    gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
    gl.bindVertexArray(0);
    gl.deleteTextures(1, &texture_object_id);
    gl.deleteFramebuffers(1, &framebuffer_object_id);
    gl.deleteVertexArrays(1, &vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "An error ocurred while deleting generated objects.");
}

/** Prepare shader
 *
 * @tparam API                Tested API descriptor
 *
 * @param tested_shader_type  The type of shader that is being tested
 * @param function_definition Definition used to prepare shader
 * @param function_use        Snippet that makes use of defined function
 * @param verification        Snippet that verifies results
 **/
template <class API>
std::string InteractionFunctionCalls1<API>::prepare_compute_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &function_definition,
    const std::string &function_use, const std::string &verification)
{
    std::string compute_shader_source;

    if (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type)
    {
        compute_shader_source = "writeonly uniform image2D uni_image;\n"
                                "\n";

        /* User-defined function definition. */
        compute_shader_source += function_definition;
        compute_shader_source += "\n\n";

        /* Main function definition. */
        compute_shader_source += shader_start;
        compute_shader_source += function_use;
        compute_shader_source += "\n\n";
        compute_shader_source += verification;
        compute_shader_source += "\n\n";
        compute_shader_source += "\n"
                                 "    imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), vec4(result, 0, 0, 0));\n"
                                 "}\n"
                                 "\n";
    }

    return compute_shader_source;
}

/** Prepare shader
 *
 * @tparam API                Tested API descriptor
 *
 * @param tested_shader_type  The type of shader that is being tested
 * @param function_definition Definition used to prepare shader
 * @param function_use        Snippet that makes use of defined function
 * @param verification        Snippet that verifies results
 **/
template <class API>
std::string InteractionFunctionCalls1<API>::prepare_fragment_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &function_definition,
    const std::string &function_use, const std::string &verification)
{
    std::string fragment_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        break;

    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        fragment_shader_source = "out vec4 colour;\n\n";

        /* User-defined function definition. */
        fragment_shader_source += function_definition;
        fragment_shader_source += "\n\n";

        /* Main function definition. */
        fragment_shader_source += shader_start;
        fragment_shader_source += function_use;
        fragment_shader_source += "\n\n";
        fragment_shader_source += verification;
        fragment_shader_source += "\n\n";
        fragment_shader_source += "    colour = vec4(result);\n";
        fragment_shader_source += shader_end;
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        fragment_shader_source = "in float fs_result;\n\n"
                                 "out vec4 colour;\n\n"
                                 "void main()\n"
                                 "{\n"
                                 "    colour =  vec4(fs_result);\n"
                                 "}\n"
                                 "\n";
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return fragment_shader_source;
}

/** Prepare shader
 *
 * @tparam API                Tested API descriptor
 *
 * @param tested_shader_type  The type of shader that is being tested
 * @param function_definition Definition used to prepare shader
 * @param function_use        Snippet that makes use of defined function
 * @param verification        Snippet that verifies results
 **/
template <class API>
std::string InteractionFunctionCalls1<API>::prepare_geometry_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &function_definition,
    const std::string &function_use, const std::string &verification)
{
    std::string geometry_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        geometry_shader_source = "layout(points)                           in;\n"
                                 "layout(triangle_strip, max_vertices = 4) out;\n"
                                 "\n"
                                 "in  float tes_result[];\n"
                                 "out float fs_result;\n"
                                 "\n"
                                 "void main()\n"
                                 "{\n"
                                 "    gl_Position  = vec4(-1, -1, 0, 1);\n"
                                 "    fs_result    = tes_result[0];\n"
                                 "    EmitVertex();\n"
                                 "    gl_Position  = vec4(-1, 1, 0, 1);\n"
                                 "    fs_result    = tes_result[0];\n"
                                 "    EmitVertex();\n"
                                 "    gl_Position  = vec4(1, -1, 0, 1);\n"
                                 "    fs_result    = tes_result[0];\n"
                                 "    EmitVertex();\n"
                                 "    gl_Position  = vec4(1, 1, 0, 1);\n"
                                 "    fs_result    = tes_result[0];\n"
                                 "    EmitVertex();\n"
                                 "}\n";
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        geometry_shader_source = "layout(points)                           in;\n"
                                 "layout(triangle_strip, max_vertices = 4) out;\n"
                                 "\n"
                                 "out float fs_result;\n"
                                 "\n";

        /* User-defined function definition. */
        geometry_shader_source += function_definition;
        geometry_shader_source += "\n\n";

        /* Main function definition. */
        geometry_shader_source += shader_start;
        geometry_shader_source += function_use;
        geometry_shader_source += "\n\n";
        geometry_shader_source += verification;
        geometry_shader_source += "\n\n";
        geometry_shader_source += "\n    gl_Position  = vec4(-1, -1, 0, 1);\n"
                                  "    fs_result    = result;\n"
                                  "    EmitVertex();\n"
                                  "    gl_Position  = vec4(-1, 1, 0, 1);\n"
                                  "    fs_result    = result;\n"
                                  "    EmitVertex();\n"
                                  "    gl_Position  = vec4(1, -1, 0, 1);\n"
                                  "    fs_result    = result;\n"
                                  "    EmitVertex();\n"
                                  "    gl_Position  = vec4(1, 1, 0, 1);\n"
                                  "    fs_result    = result;\n"
                                  "    EmitVertex();\n"
                                  "}\n";
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return geometry_shader_source;
}

/** Prepare shader
 *
 * @tparam API                Tested API descriptor
 *
 * @param tested_shader_type  The type of shader that is being tested
 * @param function_definition Definition used to prepare shader
 * @param function_use        Snippet that makes use of defined function
 * @param verification        Snippet that verifies results
 **/
template <class API>
std::string InteractionFunctionCalls1<API>::prepare_tess_ctrl_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &function_definition,
    const std::string &function_use, const std::string &verification)
{
    std::string tess_ctrl_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        tess_ctrl_shader_source = "layout(vertices = 1) out;\n"
                                  "\n"
                                  "out float tcs_result[];\n"
                                  "\n";

        /* User-defined function definition. */
        tess_ctrl_shader_source += function_definition;
        tess_ctrl_shader_source += "\n\n";

        /* Main function definition. */
        tess_ctrl_shader_source += shader_start;
        tess_ctrl_shader_source += function_use;
        tess_ctrl_shader_source += "\n\n";
        tess_ctrl_shader_source += verification;
        tess_ctrl_shader_source += "\n\n";
        tess_ctrl_shader_source += "    tcs_result[gl_InvocationID] = result;\n"
                                   "\n"
                                   "    gl_TessLevelOuter[0] = 1.0;\n"
                                   "    gl_TessLevelOuter[1] = 1.0;\n"
                                   "    gl_TessLevelOuter[2] = 1.0;\n"
                                   "    gl_TessLevelOuter[3] = 1.0;\n"
                                   "    gl_TessLevelInner[0] = 1.0;\n"
                                   "    gl_TessLevelInner[1] = 1.0;\n"
                                   "}\n";
        break;

    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        tess_ctrl_shader_source = default_tc_shader_source;
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return tess_ctrl_shader_source;
}

/** Prepare shader
 *
 * @tparam API                Tested API descriptor
 *
 * @param tested_shader_type  The type of shader that is being tested
 * @param function_definition Definition used to prepare shader
 * @param function_use        Snippet that makes use of defined function
 * @param verification        Snippet that verifies results
 **/
template <class API>
std::string InteractionFunctionCalls1<API>::prepare_tess_eval_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &function_definition,
    const std::string &function_use, const std::string &verification)
{
    std::string tess_eval_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        tess_eval_shader_source = "layout(isolines, point_mode) in;\n"
                                  "\n"
                                  "in  float tcs_result[];\n"
                                  "out float tes_result;\n"
                                  "\n"
                                  "void main()\n"
                                  "{\n"
                                  "    tes_result = tcs_result[0];\n"
                                  "}\n";
        break;

    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        tess_eval_shader_source = "layout(isolines, point_mode) in;\n"
                                  "\n"
                                  "out float tes_result;\n"
                                  "\n";

        /* User-defined function definition. */
        tess_eval_shader_source += function_definition;
        tess_eval_shader_source += "\n\n";

        /* Main function definition. */
        tess_eval_shader_source += shader_start;
        tess_eval_shader_source += function_use;
        tess_eval_shader_source += "\n\n";
        tess_eval_shader_source += verification;
        tess_eval_shader_source += "\n\n";
        tess_eval_shader_source += "    tes_result = result;\n"
                                   "}\n";
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return tess_eval_shader_source;
}

/** Prepare shader
 *
 * @tparam API                Tested API descriptor
 *
 * @param tested_shader_type  The type of shader that is being tested
 * @param function_definition Definition used to prepare shader
 * @param function_use        Snippet that makes use of defined function
 * @param verification        Snippet that verifies results
 **/
template <class API>
std::string InteractionFunctionCalls1<API>::prepare_vertex_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &function_definition,
    const std::string &function_use, const std::string &verification)
{
    std::string vertex_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        break;

    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        vertex_shader_source = "/** GL_TRIANGLE_FAN-type quad vertex data. */\n"
                               "const vec4 vertex_positions[4] = vec4[4](vec4( 1.0, -1.0, 0.0, 1.0),\n"
                               "                                         vec4(-1.0, -1.0, 0.0, 1.0),\n"
                               "                                         vec4(-1.0,  1.0, 0.0, 1.0),\n"
                               "                                         vec4( 1.0,  1.0, 0.0, 1.0) );\n"
                               "\n"
                               "void main()\n"
                               "{\n"
                               "    gl_Position = vertex_positions[gl_VertexID];"
                               "}\n\n";
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        vertex_shader_source = default_vertex_shader_source;
        break;

    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        /* Vertex shader source. */
        vertex_shader_source = "out float fs_result;\n\n";
        vertex_shader_source += "/** GL_TRIANGLE_FAN-type quad vertex data. */\n"
                                "const vec4 vertex_positions[4] = vec4[4](vec4( 1.0, -1.0, 0.0, 1.0),\n"
                                "                                         vec4(-1.0, -1.0, 0.0, 1.0),\n"
                                "                                         vec4(-1.0,  1.0, 0.0, 1.0),\n"
                                "                                         vec4( 1.0,  1.0, 0.0, 1.0) );\n\n";

        /* User-defined function definition. */
        vertex_shader_source += function_definition;
        vertex_shader_source += "\n\n";

        /* Main function definition. */
        vertex_shader_source += shader_start;
        vertex_shader_source += function_use;
        vertex_shader_source += "\n\n";
        vertex_shader_source += verification;
        vertex_shader_source += "\n\n";
        vertex_shader_source += "    fs_result   = result;\n"
                                "    gl_Position = vertex_positions[gl_VertexID];\n";
        vertex_shader_source += shader_end;
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return vertex_shader_source;
}

/* Generates the shader source code for the InteractionFunctionCalls2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void InteractionFunctionCalls2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {
        VAR_TYPE_INT,  VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2,
        VAR_TYPE_VEC3, VAR_TYPE_VEC4,  VAR_TYPE_MAT2,  VAR_TYPE_MAT3,  VAR_TYPE_MAT4};
    static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {
        VAR_TYPE_INT,  VAR_TYPE_FLOAT,  VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, VAR_TYPE_IVEC4,
        VAR_TYPE_VEC2, VAR_TYPE_VEC3,   VAR_TYPE_VEC4,  VAR_TYPE_MAT2,  VAR_TYPE_MAT3,
        VAR_TYPE_MAT4, VAR_TYPE_DOUBLE, VAR_TYPE_DMAT2, VAR_TYPE_DMAT3, VAR_TYPE_DMAT4};
    static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const std::string iteration_loop_end      = "                }\n"
                                                "            }\n"
                                                "        }\n"
                                                "    }\n";
    const std::string iteration_loop_start    = "    for (uint a = 0u; a < 2u; a++)\n"
                                                "    {\n"
                                                "        for (uint b = 0u; b < 2u; b++)\n"
                                                "        {\n"
                                                "            for (uint c = 0u; c < 2u; c++)\n"
                                                "            {\n"
                                                "                for (uint d = 0u; d < 2u; d++)\n"
                                                "                {\n";
    const std::string multiplier_array        = "const int[] multiplier_array = int[]( 1,  2,  3,  4,  5,  6,  7,  8,\n"
                                                "                                     11, 12, 13, 14, 15, 16, 17, 18,\n"
                                                "                                     21, 22, 23, 24, 25, 26, 27, 28,\n"
                                                "                                     31, 32, 33, 34, 35, 36, 37, 38,\n"
                                                "                                     41, 42, 43, 44, 45, 46, 47, 48,\n"
                                                "                                     51, 52, 53, 54, 55, 56, 57, 58,\n"
                                                "                                     61, 62, 63, 64, 65, 66, 67, 68,\n"
                                                "                                     71, 72, 73, 74, 75, 76, 77, 78,\n"
                                                "                                     81, 82, 83, 84, 85, 86, 87, 88);\n";
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;
    const bool test_compute                   = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type);

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string function_definition;
            std::string function_use;
            std::string verification;

            function_definition += multiplier_array;
            function_definition += "void my_function(inout ";
            function_definition += var_iterator->second.type;
            function_definition += " inout_array[2][2][2][2]) {\n"
                                   "    uint i = 0u;\n";
            function_definition += iteration_loop_start;
            function_definition +=
                "                                   inout_array[a][b][c][d] *= " + var_iterator->second.iterator_type +
                "(multiplier_array[i % 64u]);\n";
            function_definition += "                                   i+= 1u;\n";
            function_definition += iteration_loop_end;
            function_definition += "}";

            function_use += "    float result = 1.0;\n";
            function_use += "    uint iterator = 0u;\n";
            function_use += "    " + var_iterator->second.type + " my_array[2][2][2][2];\n";
            function_use += iteration_loop_start;
            function_use += "                                   my_array[a][b][c][d] = " +
                            var_iterator->second.variable_type_initializer2 + ";\n";
            function_use += iteration_loop_end;
            function_use += "    my_function(my_array);";

            verification += iteration_loop_start;
            verification += "                                   if (my_array[a][b][c][d] " +
                            var_iterator->second.specific_element + "!= " + var_iterator->second.iterator_type +
                            "(multiplier_array[iterator % 64u]))\n"
                            "                                   {\n"
                            "                                       result = 0.0;\n"
                            "                                   }\n"
                            "                                   iterator += 1u;\n";
            verification += iteration_loop_end;

            if (false == test_compute)
            {
                this->execute_draw_test(tested_shader_type, function_definition, function_use, verification);
            }
            else
            {
                this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification);
            }

            /* Deallocate any resources used. */
            this->delete_objects();
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/* Generates the shader source code for the InteractionArgumentAliasing1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void InteractionArgumentAliasing1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4};
    static const size_t num_var_types_es                 = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4,
                                                            VAR_TYPE_DOUBLE, VAR_TYPE_DMAT4};
    static const size_t num_var_types_gl                 = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const std::string iteration_loop_end      = "                }\n"
                                                "            }\n"
                                                "        }\n"
                                                "    }\n";
    const std::string iteration_loop_start    = "    for (uint a = 0u; a < 2u; a++)\n"
                                                "    {\n"
                                                "        for (uint b = 0u; b < 2u; b++)\n"
                                                "        {\n"
                                                "            for (uint c = 0u; c < 2u; c++)\n"
                                                "            {\n"
                                                "                for (uint d = 0u; d < 2u; d++)\n"
                                                "                {\n";
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;
    const bool test_compute                   = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type);

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string array_declaration = var_iterator->second.type + " z[2][2][2][2];\n\n";

            std::string function_definition;
            std::string function_use;
            std::string verification;

            function_definition += "bool gfunc(" + var_iterator->second.type + " x[2][2][2][2], ";
            function_definition += var_iterator->second.type + " y[2][2][2][2])\n";
            function_definition += "{\n";
            function_definition += "    " + iteration_loop_start;
            function_definition +=
                "                               x[a][b][c][d] = " + var_iterator->second.type + "(123);\n";
            function_definition += "    " + iteration_loop_end;
            function_definition += "\n";
            function_definition += "    " + iteration_loop_start;
            function_definition += "                                   if(y[a][b][c][d]";
            if (var_iterator->second.type == "mat4") // mat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != float";
            }
            else if (var_iterator->second.type == "dmat4") // dmat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != double";
            }
            else
            {
                function_definition += " != ";
                function_definition += var_iterator->second.type;
            }
            function_definition += "(((a*8u)+(b*4u)+(c*2u)+d))) {return false;}\n";
            function_definition += "    " + iteration_loop_end;
            function_definition += "  return true;\n";
            function_definition += "}";

            function_use += "    " + array_declaration;
            function_use += "    " + iteration_loop_start;
            function_use += "                                   z[a][b][c][d] = ";
            function_use += var_iterator->second.type;
            function_use += "(((a*8u)+(b*4u)+(c*2u)+d));\n";
            function_use += "    " + iteration_loop_end;

            verification += "    float result = 0.0;\n";
            verification += "    if(gfunc(z, z) == true)\n";
            verification += "    {\n";
            verification += "        result = 1.0;\n\n";
            verification += "    }\n";
            verification += "    else\n";
            verification += "    {\n";
            verification += "        result = 0.0;\n\n";
            verification += "    }\n";

            if (false == test_compute)
            {
                this->execute_draw_test(tested_shader_type, function_definition, function_use, verification);
            }
            else
            {
                this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification);
            }

            /* Deallocate any resources used. */
            this->delete_objects();
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    }
}

/* Generates the shader source code for the InteractionArgumentAliasing2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void InteractionArgumentAliasing2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4};
    static const size_t num_var_types_es                 = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4,
                                                            VAR_TYPE_DOUBLE, VAR_TYPE_DMAT4};
    static const size_t num_var_types_gl                 = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const std::string iteration_loop_end      = "                }\n"
                                                "            }\n"
                                                "        }\n"
                                                "    }\n";
    const std::string iteration_loop_start    = "    for (uint a = 0u; a < 2u; a++)\n"
                                                "    {\n"
                                                "        for (uint b = 0u; b < 2u; b++)\n"
                                                "        {\n"
                                                "            for (uint c = 0u; c < 2u; c++)\n"
                                                "            {\n"
                                                "                for (uint d = 0u; d < 2u; d++)\n"
                                                "                {\n";
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;
    const bool test_compute                   = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type);

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string array_declaration = var_iterator->second.type + " z[2][2][2][2];\n\n";

            std::string function_definition;
            std::string function_use;
            std::string verification;

            function_definition += "bool gfunc(" + var_iterator->second.type + " x[2][2][2][2], ";
            function_definition += var_iterator->second.type + " y[2][2][2][2])\n";
            function_definition += "{\n";
            function_definition += "    " + iteration_loop_start;
            function_definition +=
                "                                   y[a][b][c][d] = " + var_iterator->second.type + "(123);\n";
            function_definition += "    " + iteration_loop_end;
            function_definition += "\n";
            function_definition += "    " + iteration_loop_start;
            function_definition += "                                   if(x[a][b][c][d]";
            if (var_iterator->second.type == "mat4") // mat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != float";
            }
            else if (var_iterator->second.type == "dmat4") // dmat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != double";
            }
            else
            {
                function_definition += " != ";
                function_definition += var_iterator->second.type;
            }
            function_definition += "(((a*8u)+(b*4u)+(c*2u)+d))) {return false;}\n";
            function_definition += "    " + iteration_loop_end;
            function_definition += "  return true;\n";
            function_definition += "}";

            function_use += "    " + array_declaration;
            function_use += "    " + iteration_loop_start;
            function_use += "                                   z[a][b][c][d] = ";
            function_use += var_iterator->second.type;
            function_use += "(((a*8u)+(b*4u)+(c*2u)+d));\n";
            function_use += "    " + iteration_loop_end;

            verification += "    float result = 0.0;\n";
            verification += "    if(gfunc(z, z) == true)\n";
            verification += "    {\n";
            verification += "        result = 1.0;\n\n";
            verification += "    }\n";
            verification += "    else\n";
            verification += "    {\n";
            verification += "        result = 0.0;\n\n";
            verification += "    }\n";

            if (false == test_compute)
            {
                this->execute_draw_test(tested_shader_type, function_definition, function_use, verification);
            }
            else
            {
                this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification);
            }

            /* Deallocate any resources used. */
            this->delete_objects();
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    }
}

/* Generates the shader source code for the InteractionArgumentAliasing3
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void InteractionArgumentAliasing3<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4};
    static const size_t num_var_types_es                 = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4,
                                                            VAR_TYPE_DOUBLE, VAR_TYPE_DMAT4};
    static const size_t num_var_types_gl                 = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const std::string iteration_loop_end      = "                }\n"
                                                "            }\n"
                                                "        }\n"
                                                "    }\n";
    const std::string iteration_loop_start    = "    for (uint a = 0u; a < 2u; a++)\n"
                                                "    {\n"
                                                "        for (uint b = 0u; b < 2u; b++)\n"
                                                "        {\n"
                                                "            for (uint c = 0u; c < 2u; c++)\n"
                                                "            {\n"
                                                "                for (uint d = 0u; d < 2u; d++)\n"
                                                "                {\n";
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;
    const bool test_compute                   = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type);

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string array_declaration = var_iterator->second.type + " z[2][2][2][2];\n\n";

            std::string function_definition;
            std::string function_use;
            std::string verification;

            function_definition += "bool gfunc(out " + var_iterator->second.type + " x[2][2][2][2], ";
            function_definition += var_iterator->second.type + " y[2][2][2][2])\n";
            function_definition += "{\n";
            function_definition += "    " + iteration_loop_start;
            function_definition +=
                "                                   x[a][b][c][d] = " + var_iterator->second.type + "(123);\n";
            function_definition += "    " + iteration_loop_end;
            function_definition += "\n";
            function_definition += "    " + iteration_loop_start;
            function_definition += "                                   if(y[a][b][c][d]";
            if (var_iterator->second.type == "mat4") // mat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != float";
            }
            else if (var_iterator->second.type == "dmat4") // dmat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != double";
            }
            else
            {
                function_definition += " != ";
                function_definition += var_iterator->second.type;
            }
            function_definition += "(((a*8u)+(b*4u)+(c*2u)+d))) {return false;}\n";
            function_definition += "    " + iteration_loop_end;
            function_definition += "  return true;\n";
            function_definition += "}\n\n";

            function_use += "    " + array_declaration;
            function_use += "    " + iteration_loop_start;
            function_use += "                                   z[a][b][c][d] = ";
            function_use += var_iterator->second.type;
            function_use += "(((a*8u)+(b*4u)+(c*2u)+d));\n";
            function_use += "    " + iteration_loop_end;

            verification += "    float result = 0.0;\n";
            verification += "    if(gfunc(z, z) == true)\n";
            verification += "    {\n";
            verification += "        result = 1.0;\n\n";
            verification += "    }\n";
            verification += "    else\n";
            verification += "    {\n";
            verification += "        result = 0.0;\n\n";
            verification += "    }\n";

            if (false == test_compute)
            {
                this->execute_draw_test(tested_shader_type, function_definition, function_use, verification);
            }
            else
            {
                this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification);
            }

            /* Deallocate any resources used. */
            this->delete_objects();
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    }
}

/* Generates the shader source code for the InteractionArgumentAliasing4
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void InteractionArgumentAliasing4<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4};
    static const size_t num_var_types_es                 = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4,
                                                            VAR_TYPE_DOUBLE, VAR_TYPE_DMAT4};
    static const size_t num_var_types_gl                 = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const std::string iteration_loop_end      = "                }\n"
                                                "            }\n"
                                                "        }\n"
                                                "    }\n";
    const std::string iteration_loop_start    = "    for (uint a = 0u; a < 2u; a++)\n"
                                                "    {\n"
                                                "        for (uint b = 0u; b < 2u; b++)\n"
                                                "        {\n"
                                                "            for (uint c = 0u; c < 2u; c++)\n"
                                                "            {\n"
                                                "                for (uint d = 0u; d < 2u; d++)\n"
                                                "                {\n";
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;
    const bool test_compute                   = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type);

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string array_declaration = var_iterator->second.type + "[2][2][2][2] z;\n\n";

            std::string function_definition;
            std::string function_use;
            std::string verification;

            function_definition += "bool gfunc(" + var_iterator->second.type + " x[2][2][2][2], ";
            function_definition += "out " + var_iterator->second.type + " y[2][2][2][2])\n";
            function_definition += "{\n";
            function_definition += "    " + iteration_loop_start;
            function_definition +=
                "                                   y[a][b][c][d] = " + var_iterator->second.type + "(123);\n";
            function_definition += "    " + iteration_loop_end;
            function_definition += "\n";
            function_definition += "    " + iteration_loop_start;
            function_definition += "                                   if(x[a][b][c][d]";
            if (var_iterator->second.type == "mat4") // mat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != float";
            }
            else if (var_iterator->second.type == "dmat4") // dmat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != double";
            }
            else
            {
                function_definition += " != ";
                function_definition += var_iterator->second.type;
            }
            function_definition += "(((a*8u)+(b*4u)+(c*2u)+d))) {return false;}\n";
            function_definition += "    " + iteration_loop_end;
            function_definition += "  return true;\n";
            function_definition += "}\n\n";

            function_use += "    " + array_declaration;
            function_use += "    " + iteration_loop_start;
            function_use += "                                   z[a][b][c][d] = ";
            function_use += var_iterator->second.type;
            function_use += "(((a*8u)+(b*4u)+(c*2u)+d));\n";
            function_use += "    " + iteration_loop_end;

            verification += "    float result = 0.0;\n";
            verification += "    if(gfunc(z, z) == true)\n";
            verification += "    {\n";
            verification += "        result = 1.0;\n\n";
            verification += "    }\n";
            verification += "    else\n";
            verification += "    {\n";
            verification += "        result = 0.0;\n\n";
            verification += "    }\n";

            if (false == test_compute)
            {
                this->execute_draw_test(tested_shader_type, function_definition, function_use, verification);
            }
            else
            {
                this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification);
            }

            /* Deallocate any resources used. */
            this->delete_objects();
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    }
}

/* Generates the shader source code for the InteractionArgumentAliasing3
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void InteractionArgumentAliasing5<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4};
    static const size_t num_var_types_es                 = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4,
                                                            VAR_TYPE_DOUBLE, VAR_TYPE_DMAT4};
    static const size_t num_var_types_gl                 = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const std::string iteration_loop_end      = "                }\n"
                                                "            }\n"
                                                "        }\n"
                                                "    }\n";
    const std::string iteration_loop_start    = "    for (uint a = 0u; a < 2u; a++)\n"
                                                "    {\n"
                                                "        for (uint b = 0u; b < 2u; b++)\n"
                                                "        {\n"
                                                "            for (uint c = 0u; c < 2u; c++)\n"
                                                "            {\n"
                                                "                for (uint d = 0u; d < 2u; d++)\n"
                                                "                {\n";
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;
    const bool test_compute                   = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type);

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string array_declaration = var_iterator->second.type + "[2][2][2][2] z;\n\n";

            std::string function_definition;
            std::string function_use;
            std::string verification;

            function_definition += "bool gfunc(inout " + var_iterator->second.type + " x[2][2][2][2], ";
            function_definition += var_iterator->second.type + " y[2][2][2][2])\n";
            function_definition += "{\n";
            function_definition += "    " + iteration_loop_start;
            function_definition +=
                "                                   x[a][b][c][d] = " + var_iterator->second.type + "(123);\n";
            function_definition += "    " + iteration_loop_end;
            function_definition += "\n";
            function_definition += "    " + iteration_loop_start;
            function_definition += "                                   if(y[a][b][c][d]";
            if (var_iterator->second.type == "mat4") // mat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != float";
            }
            else if (var_iterator->second.type == "dmat4") // dmat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != double";
            }
            else
            {
                function_definition += " != ";
                function_definition += var_iterator->second.type;
            }
            function_definition += "(((a*8u)+(b*4u)+(c*2u)+d))) {return false;}\n";
            function_definition += "    " + iteration_loop_end;
            function_definition += "  return true;\n";
            function_definition += "}\n\n";

            function_use += "    " + array_declaration;
            function_use += "    " + iteration_loop_start;
            function_use += "                                   z[a][b][c][d] = ";
            function_use += var_iterator->second.type;
            function_use += "(((a*8u)+(b*4u)+(c*2u)+d));\n";
            function_use += "    " + iteration_loop_end;

            verification += "    float result = 0.0;\n";
            verification += "    if(gfunc(z, z) == true)\n";
            verification += "    {\n";
            verification += "        result = 1.0;\n\n";
            verification += "    }\n";
            verification += "    else\n";
            verification += "    {\n";
            verification += "        result = 0.0;\n\n";
            verification += "    }\n";

            if (false == test_compute)
            {
                this->execute_draw_test(tested_shader_type, function_definition, function_use, verification);
            }
            else
            {
                this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification);
            }

            /* Deallocate any resources used. */
            this->delete_objects();
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    }
}

/* Generates the shader source code for the InteractionArgumentAliasing4
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void InteractionArgumentAliasing6<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4};
    static const size_t num_var_types_es                 = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4,
                                                            VAR_TYPE_DOUBLE, VAR_TYPE_DMAT4};
    static const size_t num_var_types_gl                 = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const std::string iteration_loop_end      = "                }\n"
                                                "            }\n"
                                                "        }\n"
                                                "    }\n";
    const std::string iteration_loop_start    = "    for (uint a = 0u; a < 2u; a++)\n"
                                                "    {\n"
                                                "        for (uint b = 0u; b < 2u; b++)\n"
                                                "        {\n"
                                                "            for (uint c = 0u; c < 2u; c++)\n"
                                                "            {\n"
                                                "                for (uint d = 0u; d < 2u; d++)\n"
                                                "                {\n";
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;
    const bool test_compute                   = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type);

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string array_declaration = var_iterator->second.type + "[2][2][2][2] z;\n\n";

            std::string function_definition;
            std::string function_use;
            std::string verification;

            function_definition += "bool gfunc(" + var_iterator->second.type + " x[2][2][2][2], ";
            function_definition += "inout " + var_iterator->second.type + " y[2][2][2][2])\n";
            function_definition += "{\n";
            function_definition += "    " + iteration_loop_start;
            function_definition +=
                "                                   y[a][b][c][d] = " + var_iterator->second.type + "(123);\n";
            function_definition += "    " + iteration_loop_end;
            function_definition += "\n";
            function_definition += "    " + iteration_loop_start;
            function_definition += "                                   if(x[a][b][c][d]";
            if (var_iterator->second.type == "mat4") // mat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != float";
            }
            else if (var_iterator->second.type == "dmat4") // dmat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != double";
            }
            else
            {
                function_definition += " != ";
                function_definition += var_iterator->second.type;
            }
            function_definition += "(((a*8u)+(b*4u)+(c*2u)+d))) {return false;}\n";
            function_definition += "    " + iteration_loop_end;
            function_definition += "  return true;\n";
            function_definition += "}\n\n";

            function_use += "    " + array_declaration;
            function_use += "    " + iteration_loop_start;
            function_use += "                                   z[a][b][c][d] = ";
            function_use += var_iterator->second.type;
            function_use += "(((a*8u)+(b*4u)+(c*2u)+d));\n";
            function_use += "    " + iteration_loop_end;

            verification += "    float result = 0.0;\n";
            verification += "    if(gfunc(z, z) == true)\n";
            verification += "    {\n";
            verification += "        result = 1.0;\n\n";
            verification += "    }\n";
            verification += "    else\n";
            verification += "    {\n";
            verification += "        result = 0.0;\n\n";
            verification += "    }\n";

            if (false == test_compute)
            {
                this->execute_draw_test(tested_shader_type, function_definition, function_use, verification);
            }
            else
            {
                this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification);
            }

            /* Deallocate any resources used. */
            this->delete_objects();
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    }
}

/* Generates the shader source code for the InteractionUniforms1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void InteractionUniforms1<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT};
    static const size_t num_var_types_es                 = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT,
                                                            VAR_TYPE_DOUBLE};
    static const size_t num_var_types_gl                 = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const glw::Functions &gl                  = this->context_id.getRenderContext().getFunctions();
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string uniform_definition;
            std::string uniform_use;

            uniform_definition += "uniform ";
            uniform_definition += var_iterator->second.precision;
            uniform_definition += " ";
            uniform_definition += var_iterator->second.type;
            uniform_definition += " my_uniform_1[1][1][1][1];\n\n";

            uniform_use = "    float result = float(my_uniform_1[0][0][0][0]);\n";

            if (API::USE_ALL_SHADER_STAGES)
            {
                const std::string &compute_shader_source =
                    this->prepare_compute_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &fragment_shader_source =
                    this->prepare_fragment_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &geometry_shader_source =
                    this->prepare_geometry_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &tess_ctrl_shader_source =
                    this->prepare_tess_ctrl_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &tess_eval_shader_source =
                    this->prepare_tess_eval_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &vertex_shader_source =
                    this->prepare_vertex_shader(tested_shader_type, uniform_definition, uniform_use);

                switch (tested_shader_type)
                {
                case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */
                case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
                    this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false);
                    break;

                case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
                case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
                case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */
                case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
                    this->execute_positive_test(vertex_shader_source, tess_ctrl_shader_source, tess_eval_shader_source,
                                                geometry_shader_source, fragment_shader_source, compute_shader_source,
                                                false, false);
                    break;

                default:
                    TCU_FAIL("Invalid enum");
                    break;
                }
            }
            else
            {
                const std::string &fragment_shader_source =
                    this->prepare_fragment_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &vertex_shader_source =
                    this->prepare_vertex_shader(tested_shader_type, uniform_definition, uniform_use);

                this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false);
            }

            glw::GLint uniform_location = -1;

            /* Make program object active. */
            gl.useProgram(this->program_object_id);
            GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed.");

            /* Get uniform location. */
            uniform_location = gl.getUniformLocation(this->program_object_id, "my_uniform_1[0][0][0][0]");
            GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation() failed.");

            if (uniform_location == -1)
            {
                TCU_FAIL("Uniform is not found or is considered as not active.");
            }

            switch (var_type_index)
            {
            case 0: //float type of uniform is considered
            {
                glw::GLfloat uniform_value = 1.0f;

                gl.uniform1f(uniform_location, uniform_value);
                GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1f() failed.");

                break;
            }
            case 1: //int type of uniform is considered
            {
                glw::GLint uniform_value = 1;

                gl.uniform1i(uniform_location, uniform_value);
                GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i() failed.");

                break;
            }
            case 2: //uint type of uniform is considered
            {
                glw::GLuint uniform_value = 1;

                gl.uniform1ui(uniform_location, uniform_value);
                GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1ui() failed.");

                break;
            }
            case 3: //double type of uniform is considered
            {
                glw::GLdouble uniform_value = 1.0;

                gl.uniform1d(uniform_location, uniform_value);
                GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1d() failed.");

                break;
            }
            default:
            {
                TCU_FAIL("Invalid variable-type index.");

                break;
            }
            } /* switch (var_type_index) */

            /* Deallocate any resources used. */
            this->delete_objects();
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 * @param uniform_definition Definition used to prepare shader
 * @param uniform_use        Snippet that use defined uniform
 **/
template <class API>
std::string InteractionUniforms1<API>::prepare_compute_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &uniform_definition,
    const std::string &uniform_use)
{
    std::string compute_shader_source;

    if (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type)
    {
        compute_shader_source = "writeonly uniform image2D uni_image;\n"
                                "\n";

        /* User-defined function definition. */
        compute_shader_source += uniform_definition;
        compute_shader_source += "\n\n";

        /* Main function definition. */
        compute_shader_source += shader_start;
        compute_shader_source += uniform_use;
        compute_shader_source += "\n\n";
        compute_shader_source += "\n"
                                 "    imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), vec4(result, 0, 0, 0));\n"
                                 "}\n"
                                 "\n";
    }

    return compute_shader_source;
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 * @param uniform_definition Definition used to prepare shader
 * @param uniform_use        Snippet that use defined uniform
 **/
template <class API>
std::string InteractionUniforms1<API>::prepare_fragment_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &uniform_definition,
    const std::string &uniform_use)
{
    std::string fragment_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        break;

    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        fragment_shader_source = "out vec4 colour;\n\n";

        /* User-defined function definition. */
        fragment_shader_source += uniform_definition;
        fragment_shader_source += "\n\n";

        /* Main function definition. */
        fragment_shader_source += shader_start;
        fragment_shader_source += uniform_use;
        fragment_shader_source += "\n\n";
        fragment_shader_source += "    colour = vec4(result);\n";
        fragment_shader_source += shader_end;
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        fragment_shader_source = "in float fs_result;\n\n"
                                 "out vec4 colour;\n\n"
                                 "void main()\n"
                                 "{\n"
                                 "    colour =  vec4(fs_result);\n"
                                 "}\n"
                                 "\n";
        break;

    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        fragment_shader_source = default_fragment_shader_source;
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return fragment_shader_source;
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 * @param uniform_definition Definition used to prepare shader
 * @param uniform_use        Snippet that use defined uniform
 **/
template <class API>
std::string InteractionUniforms1<API>::prepare_geometry_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &uniform_definition,
    const std::string &uniform_use)
{
    std::string geometry_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        geometry_shader_source = "layout(points)                           in;\n"
                                 "layout(triangle_strip, max_vertices = 4) out;\n"
                                 "\n"
                                 "in  float tes_result[];\n"
                                 "out float fs_result;\n"
                                 "\n"
                                 "void main()\n"
                                 "{\n"
                                 "    gl_Position  = vec4(-1, -1, 0, 1);\n"
                                 "    fs_result    = tes_result[0];\n"
                                 "    EmitVertex();\n"
                                 "    gl_Position  = vec4(-1, 1, 0, 1);\n"
                                 "    fs_result    = tes_result[0];\n"
                                 "    EmitVertex();\n"
                                 "    gl_Position  = vec4(1, -1, 0, 1);\n"
                                 "    fs_result    = tes_result[0];\n"
                                 "    EmitVertex();\n"
                                 "    gl_Position  = vec4(1, 1, 0, 1);\n"
                                 "    fs_result    = tes_result[0];\n"
                                 "    EmitVertex();\n"
                                 "}\n";
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        geometry_shader_source = "layout(points)                           in;\n"
                                 "layout(triangle_strip, max_vertices = 4) out;\n"
                                 "\n"
                                 "out float fs_result;\n"
                                 "\n";

        /* User-defined function definition. */
        geometry_shader_source += uniform_definition;
        geometry_shader_source += "\n\n";

        /* Main function definition. */
        geometry_shader_source += shader_start;
        geometry_shader_source += uniform_use;
        geometry_shader_source += "\n\n";
        geometry_shader_source += "\n    gl_Position  = vec4(-1, -1, 0, 1);\n"
                                  "    fs_result    = result;\n"
                                  "    EmitVertex();\n"
                                  "    gl_Position  = vec4(-1, 1, 0, 1);\n"
                                  "    fs_result    = result;\n"
                                  "    EmitVertex();\n"
                                  "    gl_Position  = vec4(1, -1, 0, 1);\n"
                                  "    fs_result    = result;\n"
                                  "    EmitVertex();\n"
                                  "    gl_Position  = vec4(1, 1, 0, 1);\n"
                                  "    fs_result    = result;\n"
                                  "    EmitVertex();\n"
                                  "}\n";
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return geometry_shader_source;
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 * @param uniform_definition Definition used to prepare shader
 * @param uniform_use        Snippet that use defined uniform
 **/
template <class API>
std::string InteractionUniforms1<API>::prepare_tess_ctrl_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &uniform_definition,
    const std::string &uniform_use)
{
    std::string tess_ctrl_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        tess_ctrl_shader_source = "layout(vertices = 1) out;\n"
                                  "\n"
                                  "out float tcs_result[];\n"
                                  "\n";

        /* User-defined function definition. */
        tess_ctrl_shader_source += uniform_definition;
        tess_ctrl_shader_source += "\n\n";

        /* Main function definition. */
        tess_ctrl_shader_source += shader_start;
        tess_ctrl_shader_source += uniform_use;
        tess_ctrl_shader_source += "\n\n";
        tess_ctrl_shader_source += "    tcs_result[gl_InvocationID] = result;\n"
                                   "\n"
                                   "    gl_TessLevelOuter[0] = 1.0;\n"
                                   "    gl_TessLevelOuter[1] = 1.0;\n"
                                   "    gl_TessLevelOuter[2] = 1.0;\n"
                                   "    gl_TessLevelOuter[3] = 1.0;\n"
                                   "    gl_TessLevelInner[0] = 1.0;\n"
                                   "    gl_TessLevelInner[1] = 1.0;\n"
                                   "}\n";
        break;

    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        tess_ctrl_shader_source = default_tc_shader_source;
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return tess_ctrl_shader_source;
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 * @param uniform_definition Definition used to prepare shader
 * @param uniform_use        Snippet that use defined uniform
 **/
template <class API>
std::string InteractionUniforms1<API>::prepare_tess_eval_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &uniform_definition,
    const std::string &uniform_use)
{
    std::string tess_eval_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        tess_eval_shader_source = "layout(isolines, point_mode) in;\n"
                                  "\n"
                                  "in  float tcs_result[];\n"
                                  "out float tes_result;\n"
                                  "\n"
                                  "void main()\n"
                                  "{\n"
                                  "    tes_result = tcs_result[0];\n"
                                  "}\n";
        break;

    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        tess_eval_shader_source = "layout(isolines, point_mode) in;\n"
                                  "\n"
                                  "out float tes_result;\n"
                                  "\n";

        /* User-defined function definition. */
        tess_eval_shader_source += uniform_definition;
        tess_eval_shader_source += "\n\n";

        /* Main function definition. */
        tess_eval_shader_source += shader_start;
        tess_eval_shader_source += uniform_use;
        tess_eval_shader_source += "\n\n";
        tess_eval_shader_source += "    tes_result = result;\n"
                                   "}\n";
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return tess_eval_shader_source;
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 * @param uniform_definition Definition used to prepare shader
 * @param uniform_use        Snippet that use defined uniform
 **/
template <class API>
std::string InteractionUniforms1<API>::prepare_vertex_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &uniform_definition,
    const std::string &uniform_use)
{
    std::string vertex_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        break;

    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        vertex_shader_source = default_vertex_shader_source;
        break;

    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        /* User-defined function definition. */
        vertex_shader_source += uniform_definition;

        /* Main function definition. */
        vertex_shader_source += shader_start;
        vertex_shader_source += uniform_use;
        vertex_shader_source += "    gl_Position = vec4(result);\n";
        vertex_shader_source += shader_end;
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return vertex_shader_source;
}

/* Generates the shader source code for the InteractionUniforms2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void InteractionUniforms2<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4};
    static const size_t num_var_types_es                 = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4,
                                                            VAR_TYPE_DOUBLE, VAR_TYPE_DMAT4};
    static const size_t num_var_types_gl                 = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const std::string array_initializers[] = {"int[2][2][2][2](\n"
                                              "    int[2][2][2](\n"
                                              "        int[2][2](\n"
                                              "            int[2]( 1,  2),\n"
                                              "            int[2]( 3,  4)\n"
                                              "        ),\n"
                                              "        int[2][2](\n"
                                              "            int[2]( 5,  6),\n"
                                              "            int[2]( 7,  8)\n"
                                              "        )\n"
                                              "    ),\n"
                                              "    int[2][2][2](\n"
                                              "        int[2][2](\n"
                                              "            int[2](11, 12),\n"
                                              "            int[2](13, 14)\n"
                                              "        ),\n"
                                              "        int[2][2](\n"
                                              "            int[2](15, 16),\n"
                                              "            int[2](17, 18)\n"
                                              "        )\n"
                                              "    )\n"
                                              ")",

                                              "float[2][2][2][2](\n"
                                              "    float[2][2][2](\n"
                                              "        float[2][2](\n"
                                              "            float[2](1.0, 2.0),\n"
                                              "            float[2](3.0, 4.0)),\n"
                                              "        float[2][2](\n"
                                              "            float[2](5.0, 6.0),\n"
                                              "            float[2](7.0, 8.0))),\n"
                                              "    float[2][2][2](\n"
                                              "        float[2][2](\n"
                                              "            float[2](1.1, 2.1),\n"
                                              "            float[2](3.1, 4.1)\n"
                                              "        ),\n"
                                              "        float[2][2](\n"
                                              "            float[2](5.1, 6.1),\n"
                                              "            float[2](7.1, 8.1)\n"
                                              "        )\n"
                                              "    )\n"
                                              ")",

                                              "mat4[2][2][2][2](\n"
                                              "    mat4[2][2][2](\n"
                                              "        mat4[2][2](\n"
                                              "            mat4[2]( mat4(1),  mat4(2)),\n"
                                              "            mat4[2]( mat4(3),  mat4(4))\n"
                                              "        ),\n"
                                              "        mat4[2][2](\n"
                                              "            mat4[2](mat4(5),  mat4(6)),\n"
                                              "            mat4[2](mat4(7),  mat4(8))\n"
                                              "        )\n"
                                              "    ),\n"
                                              "    mat4[2][2][2](\n"
                                              "        mat4[2][2](\n"
                                              "            mat4[2](mat4(9),  mat4(10)),\n"
                                              "            mat4[2](mat4(11),  mat4(12))\n"
                                              "        ),\n"
                                              "        mat4[2][2](\n"
                                              "            mat4[2](mat4(13),  mat4(14)),\n"
                                              "            mat4[2](mat4(15),  mat4(16))\n"
                                              "        )\n"
                                              "    )\n"
                                              ")",

                                              "double[2][2][2][2](\n"
                                              "    double[2][2][2](\n"
                                              "        double[2][2](\n"
                                              "            double[2](1.0, 2.0),\n"
                                              "            double[2](3.0, 4.0)),\n"
                                              "        double[2][2](\n"
                                              "            double[2](5.0, 6.0),\n"
                                              "            double[2](7.0, 8.0))),\n"
                                              "    double[2][2][2](\n"
                                              "        double[2][2](\n"
                                              "            double[2](1.1, 2.1),\n"
                                              "            double[2](3.1, 4.1)\n"
                                              "        ),\n"
                                              "        double[2][2](\n"
                                              "            double[2](5.1, 6.1),\n"
                                              "            double[2](7.1, 8.1)\n"
                                              "        )\n"
                                              "    )\n"
                                              ")",

                                              "dmat4[2][2][2][2](\n"
                                              "    dmat4[2][2][2](\n"
                                              "        dmat4[2][2](\n"
                                              "            dmat4[2]( dmat4(1),  dmat4(2)),\n"
                                              "            dmat4[2]( dmat4(3),  dmat4(4))\n"
                                              "        ),\n"
                                              "        dmat4[2][2](\n"
                                              "            dmat4[2](dmat4(5),  dmat4(6)),\n"
                                              "            dmat4[2](dmat4(7),  dmat4(8))\n"
                                              "        )\n"
                                              "    ),\n"
                                              "    dmat4[2][2][2](\n"
                                              "        dmat4[2][2](\n"
                                              "            dmat4[2](dmat4(9),   dmat4(10)),\n"
                                              "            dmat4[2](dmat4(11),  dmat4(12))\n"
                                              "        ),\n"
                                              "        dmat4[2][2](\n"
                                              "            dmat4[2](dmat4(13),  dmat4(14)),\n"
                                              "            dmat4[2](dmat4(15),  dmat4(16))\n"
                                              "        )\n"
                                              "    )\n"
                                              ")"};

    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string base_variable_string;

            for (int initialiser_selector = 1; initialiser_selector >= 0; initialiser_selector--)
            {
                // We normally do all 16 possible permutations of [4][4][4][4] items (15..0).
                // However, in this case we will skip the case that will work,
                // so we'll merely process permutations 14..0
                for (int permutation_index = 14; permutation_index >= 0; permutation_index--)
                {
                    base_variable_string =
                        "uniform " + var_iterator->second.precision + " " + var_iterator->second.type + " x";

                    // for all 4 possible sub_script entries
                    for (int sub_script_entry_index = 3; sub_script_entry_index >= 0; sub_script_entry_index--)
                    {
                        if (permutation_index & (1 << sub_script_entry_index))
                        {
                            // In this case, we'll use a valid sub_script
                            base_variable_string += "[2]";
                        }
                        else
                        {
                            // In this case, we'll use an invalid sub_script
                            base_variable_string += "[]";
                        }
                    }

                    if (initialiser_selector == 0)
                    {
                        // We'll use an initialiser
                        base_variable_string += " = " + array_initializers[var_type_index];
                    }

                    base_variable_string += ";\n\n";

                    std::string shader_source = base_variable_string + shader_start;

                    /* End main */
                    DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

                    /* Execute test:
                     *
                     * This will succeed in case of allowed unsized
                     * declarations and when at least one of these is
                     * true:
                     *   1. There is an initialiser.
                     *   2. Only the outermost dimension is unsized,
                     *      as in [][2][2][2].
                     */
                    EXECUTE_SHADER_TEST(API::ALLOW_UNSIZED_DECLARATION &&
                                            (initialiser_selector == 0 || permutation_index == 7),
                                        tested_shader_type, shader_source);
                } /* for (int permutation_index = 14; ...) */
            }     /* for (int initialiser_selector  = 1; ...) */
        }         /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/* Generates the shader source code for the InteractionUniformBuffers1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void InteractionUniformBuffers1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT};
    static const size_t num_var_types_es                 = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT,
                                                            VAR_TYPE_DOUBLE};
    static const size_t num_var_types_gl                 = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string shader_source;

            shader_source += "uniform uBlocka {\n";
            shader_source += "    " + var_iterator->second.type + " x[1][1][1][1][1][1];\n";
            shader_source += "};\n\n";
            shader_source += shader_start;

            /* End main */
            DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

            /* Execute test */
            EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    }
}

/* Generates the shader source code for the InteractionUniformBuffers2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void InteractionUniformBuffers2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT};
    static const size_t num_var_types_es                 = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT,
                                                            VAR_TYPE_DOUBLE};
    static const size_t num_var_types_gl                 = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const glw::Functions &gl                  = this->context_id.getRenderContext().getFunctions();
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    /* Iterate through float / int / uint values. */
    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string uniform_definition;
            std::string uniform_use;

            uniform_definition += "layout (std140) uniform uniform_block_name\n"
                                  "{\n";
            uniform_definition += "    ";
            uniform_definition += var_iterator->second.type;
            uniform_definition += " my_uniform_1[1][1][1][1];\n"
                                  "};\n";

            uniform_use = "    float result = float(my_uniform_1[0][0][0][0]);\n";

            if (API::USE_ALL_SHADER_STAGES)
            {
                const std::string &compute_shader_source =
                    this->prepare_compute_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &fragment_shader_source =
                    this->prepare_fragment_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &geometry_shader_source =
                    this->prepare_geometry_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &tess_ctrl_shader_source =
                    this->prepare_tess_ctrl_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &tess_eval_shader_source =
                    this->prepare_tess_eval_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &vertex_shader_source =
                    this->prepare_vertex_shader(tested_shader_type, uniform_definition, uniform_use);

                switch (tested_shader_type)
                {
                case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */
                case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
                    this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false);
                    break;

                case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
                case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
                case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */
                case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
                    this->execute_positive_test(vertex_shader_source, tess_ctrl_shader_source, tess_eval_shader_source,
                                                geometry_shader_source, fragment_shader_source, compute_shader_source,
                                                false, false);
                    break;

                default:
                    TCU_FAIL("Invalid enum");
                    break;
                }
            }
            else
            {
                const std::string &fragment_shader_source =
                    this->prepare_fragment_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &vertex_shader_source =
                    this->prepare_vertex_shader(tested_shader_type, uniform_definition, uniform_use);

                this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false);
            }

            glw::GLuint buffer_object_id      = 0;
            glw::GLint my_uniform_block_index = GL_INVALID_INDEX;

            gl.useProgram(this->program_object_id);
            GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed.");

            my_uniform_block_index = gl.getUniformBlockIndex(this->program_object_id, "uniform_block_name");
            GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformBlockIndex() failed.");

            if ((unsigned)my_uniform_block_index == GL_INVALID_INDEX)
            {
                TCU_FAIL("Uniform block not found or is considered as not active.");
            }

            gl.genBuffers(1, &buffer_object_id);
            GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() failed.");

            gl.bindBuffer(GL_UNIFORM_BUFFER, buffer_object_id);
            GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() failed.");

            switch (var_type_index)
            {
            case 0: //float type of uniform is considered
            {
                glw::GLfloat buffer_data[] = {0.0f, 1.0f, 2.0f,  3.0f,  4.0f,  5.0f,  6.0f,  7.0f,
                                              8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f};

                gl.bufferData(GL_UNIFORM_BUFFER, sizeof(buffer_data), buffer_data, GL_STATIC_DRAW);
                GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed.");

                break;
            }       /* float case */
            case 1: //int type of uniform is considered
            {

                glw::GLint buffer_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};

                gl.bufferData(GL_UNIFORM_BUFFER, sizeof(buffer_data), buffer_data, GL_STATIC_DRAW);
                GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed.");

                break;
            }       /* int case */
            case 2: //uint type of uniform is considered
            {
                glw::GLuint buffer_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};

                gl.bufferData(GL_UNIFORM_BUFFER, sizeof(buffer_data), buffer_data, GL_STATIC_DRAW);
                GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed.");

                break;
            }       /* uint case */
            case 3: //double type of uniform is considered
            {
                glw::GLdouble buffer_data[] = {0.0, 1.0, 2.0,  3.0,  4.0,  5.0,  6.0,  7.0,
                                               8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0};

                gl.bufferData(GL_UNIFORM_BUFFER, sizeof(buffer_data), buffer_data, GL_STATIC_DRAW);
                GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed.");

                break;
            } /* double case */
            default:
            {
                TCU_FAIL("Invalid variable-type index.");

                break;
            }
            } /* switch (var_type_index) */

            gl.uniformBlockBinding(this->program_object_id, my_uniform_block_index, 0);
            GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformBlockBinding() failed.");

            gl.bindBufferBase(GL_UNIFORM_BUFFER, 0, buffer_object_id);
            GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() failed.");

            if (TestCaseBase<API>::COMPUTE_SHADER_TYPE != tested_shader_type)
            {
                execute_draw_test(tested_shader_type);
            }
            else
            {
                execute_dispatch_test();
            }

            /* Deallocate any resources used. */
            gl.deleteBuffers(1, &buffer_object_id);
            this->delete_objects();
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/** Executes test for compute program
 *
 * @tparam API Tested API descriptor
 **/
template <class API>
void InteractionUniformBuffers2<API>::execute_dispatch_test()
{
    const glw::Functions &gl = this->context_id.getRenderContext().getFunctions();

    gl.dispatchCompute(1, 1, 1);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");
}

/** Executes test for draw program
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 **/
template <class API>
void InteractionUniformBuffers2<API>::execute_draw_test(typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    const glw::Functions &gl = this->context_id.getRenderContext().getFunctions();

    glw::GLuint vao_id = 0;

    gl.genVertexArrays(1, &vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() failed.");

    gl.bindVertexArray(vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() failed.");

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
    case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        gl.drawArrays(GL_POINTS, 0, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        /* Tesselation patch set up */
        gl.patchParameteri(GL_PATCH_VERTICES, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "PatchParameteri");

        gl.drawArrays(GL_PATCHES, 0, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");
        break;

    default:
        TCU_FAIL("Invalid enum");
        break;
    }

    gl.deleteVertexArrays(1, &vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteVertexArrays() failed.");
}

/* Generates the shader source code for the InteractionUniformBuffers3
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void InteractionUniformBuffers3<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT};
    static const size_t num_var_types_es                 = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT,
                                                            VAR_TYPE_DOUBLE};
    static const size_t num_var_types_gl                 = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const std::string invalid_size_declarations[] = {"[2][2][2][]", "[2][2][][2]", "[2][][2][2]", "[][2][2][2]",
                                                     "[2][2][][]",  "[2][][2][]",  "[][2][2][]",  "[2][][][2]",
                                                     "[][2][][2]",  "[][][2][2]",  "[2][][][]",   "[][2][][]",
                                                     "[][][2][]",   "[][][][2]",   "[][][][]"};

    const std::string array_initializers[]    = {"float[2][2][2][2](float[2][2][2](float[2][2](float[2](1.0, 2.0),"
                                                    "float[2](3.0, 4.0)),"
                                                    "float[2][2](float[2](5.0, 6.0),"
                                                    "float[2](7.0, 8.0))),"
                                                    "float[2][2][2](float[2][2](float[2](1.1, 2.1),"
                                                    "float[2](3.1, 4.1)),"
                                                    "float[2][2](float[2](5.1, 6.1),"
                                                    "float[2](7.1, 8.1))));\n",

                                                 "int[2][2][2][2](int[2][2][2](int[2][2](int[2]( 1,  2),"
                                                    "int[2]( 3,  4)),"
                                                    "int[2][2](int[2]( 5,  6),"
                                                    "int[2]( 7,  8))),"
                                                    "int[2][2][2](int[2][2](int[2](11, 12),"
                                                    "int[2](13, 14)),"
                                                    "int[2][2](int[2](15, 16),"
                                                    "int[2](17, 18))));\n",

                                                 "uint[2][2][2][2](uint[2][2][2](uint[2][2](uint[2]( 1u,  2u),"
                                                    "uint[2]( 3u,  4u)),"
                                                    "uint[2][2](uint[2]( 5u,  6u),"
                                                    "uint[2]( 7u,  8u))),"
                                                    "uint[2][2][2](uint[2][2](uint[2](11u, 12u),"
                                                    "uint[2](13u, 14u)),"
                                                    "uint[2][2](uint[2](15u, 16u),"
                                                    "uint[2](17u, 18u))));\n",

                                                 "double[2][2][2][2](double[2][2][2](double[2][2](double[2](1.0, 2.0),"
                                                    "double[2](3.0, 4.0)),"
                                                    "double[2][2](double[2](5.0, 6.0),"
                                                    "double[2](7.0, 8.0))),"
                                                    "double[2][2][2](double[2][2](double[2](1.1, 2.1),"
                                                    "double[2](3.1, 4.1)),"
                                                    "double[2][2](double[2](5.1, 6.1),"
                                                    "double[2](7.1, 8.1))));\n"};
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    /* Iterate through float/ int/ uint types.
     * Case: without initializer.
     */
    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            for (size_t invalid_size_declarations_index = 0;
                 invalid_size_declarations_index <
                 sizeof(invalid_size_declarations) / sizeof(invalid_size_declarations[0]);
                 invalid_size_declarations_index++)
            {
                std::string shader_source;

                shader_source = "layout (std140) uniform MyUniform {\n";
                shader_source += "    " + var_iterator->second.type +
                                 invalid_size_declarations[invalid_size_declarations_index] + " my_variable;\n";
                shader_source += "};\n\n";
                shader_source += shader_start;

                /* End main */
                DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

                /* Execute test */
                EXECUTE_SHADER_TEST(API::ALLOW_UNSIZED_DECLARATION && invalid_size_declarations_index == 3,
                                    tested_shader_type, shader_source);
            } /* for (int invalid_size_declarations_index = 0; ...) */
        }
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */

    /* Iterate through float/ int/ uint types.
     * Case: with initializer.
     */
    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            for (size_t invalid_size_declarations_index = 0;
                 invalid_size_declarations_index <
                 sizeof(invalid_size_declarations) / sizeof(invalid_size_declarations[0]);
                 invalid_size_declarations_index++)
            {
                std::string shader_source;

                shader_source = "layout (std140) uniform MyUniform {\n";
                shader_source += "    " + var_iterator->second.type +
                                 invalid_size_declarations[invalid_size_declarations_index] +
                                 " my_variable = " + array_initializers[var_type_index];
                shader_source += "};\n\n";
                shader_source += shader_start;

                /* End main */
                DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

                /* Execute test */
                this->execute_negative_test(tested_shader_type, shader_source);
            } /* for (int invalid_size_declarations_index = 0; ...) */
        }     /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/* Generates the shader source code for the InteractionStorageBuffers1
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void InteractionStorageBuffers1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT};
    static const size_t num_var_types_es                 = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT,
                                                            VAR_TYPE_DOUBLE};
    static const size_t num_var_types_gl                 = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string shader_source;

            shader_source += "buffer uBlocka {\n";
            shader_source += "    " + var_iterator->second.type + " x[1][1][1][1][1][1];\n";
            shader_source += "};\n\n";
            shader_source += shader_start;

            /* End main */
            DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

            /* Execute test */
            EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false);
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    }
}

/* Generates the shader source code for the InteractionUniformBuffers2
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void InteractionStorageBuffers2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT};
    static const size_t num_var_types_es                 = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT,
                                                            VAR_TYPE_DOUBLE};
    static const size_t num_var_types_gl                 = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const glw::Functions &gl                  = this->context_id.getRenderContext().getFunctions();
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    /* Iterate through float / int / uint values. */
    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string uniform_definition;
            std::string uniform_use;

            uniform_definition += "layout (std140) buffer storage_block_name\n"
                                  "{\n";
            uniform_definition += "    ";
            uniform_definition += var_iterator->second.type;
            uniform_definition += " my_storage_1[1][1][1][1];\n"
                                  "};\n";

            uniform_use = "    float result = float(my_storage_1[0][0][0][0]);\n";

            if (API::USE_ALL_SHADER_STAGES)
            {
                const std::string &compute_shader_source =
                    this->prepare_compute_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &fragment_shader_source =
                    this->prepare_fragment_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &geometry_shader_source =
                    this->prepare_geometry_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &tess_ctrl_shader_source =
                    this->prepare_tess_ctrl_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &tess_eval_shader_source =
                    this->prepare_tess_eval_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &vertex_shader_source =
                    this->prepare_vertex_shader(tested_shader_type, uniform_definition, uniform_use);

                switch (tested_shader_type)
                {
                case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */
                case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
                    this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false);
                    break;

                case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
                case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
                case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */
                case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
                    this->execute_positive_test(vertex_shader_source, tess_ctrl_shader_source, tess_eval_shader_source,
                                                geometry_shader_source, fragment_shader_source, compute_shader_source,
                                                false, false);
                    break;

                default:
                    TCU_FAIL("Invalid enum");
                    break;
                }
            }
            else
            {
                const std::string &fragment_shader_source =
                    this->prepare_fragment_shader(tested_shader_type, uniform_definition, uniform_use);
                const std::string &vertex_shader_source =
                    this->prepare_vertex_shader(tested_shader_type, uniform_definition, uniform_use);

                this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false);
            }

            glw::GLuint buffer_object_id      = 0;
            glw::GLint my_storage_block_index = GL_INVALID_INDEX;

            gl.useProgram(this->program_object_id);
            GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed.");

            my_storage_block_index =
                gl.getProgramResourceIndex(this->program_object_id, GL_SHADER_STORAGE_BLOCK, "storage_block_name");
            GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramResourceIndex() failed.");

            if ((unsigned)my_storage_block_index == GL_INVALID_INDEX)
            {
                TCU_FAIL("Uniform block not found or is considered as not active.");
            }

            gl.genBuffers(1, &buffer_object_id);
            GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() failed.");

            gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, buffer_object_id);
            GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() failed.");

            switch (var_type_index)
            {
            case 0: //float type of uniform is considered
            {
                glw::GLfloat buffer_data[] = {0.0f, 1.0f, 2.0f,  3.0f,  4.0f,  5.0f,  6.0f,  7.0f,
                                              8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f};

                gl.bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(buffer_data), buffer_data, GL_STATIC_DRAW);
                GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed.");

                break;
            }       /* float case */
            case 1: //int type of uniform is considered
            {

                glw::GLint buffer_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};

                gl.bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(buffer_data), buffer_data, GL_STATIC_DRAW);
                GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed.");

                break;
            }       /* int case */
            case 2: //uint type of uniform is considered
            {
                glw::GLuint buffer_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};

                gl.bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(buffer_data), buffer_data, GL_STATIC_DRAW);
                GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed.");

                break;
            }       /* uint case */
            case 3: //double type of uniform is considered
            {
                glw::GLdouble buffer_data[] = {0.0, 1.0, 2.0,  3.0,  4.0,  5.0,  6.0,  7.0,
                                               8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0};

                gl.bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(buffer_data), buffer_data, GL_STATIC_DRAW);
                GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed.");

                break;
            } /* double case */
            default:
            {
                TCU_FAIL("Invalid variable-type index.");

                break;
            }
            } /* switch (var_type_index) */

            gl.shaderStorageBlockBinding(this->program_object_id, my_storage_block_index, 0);
            GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformBlockBinding() failed.");

            gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, buffer_object_id);
            GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() failed.");

            if (TestCaseBase<API>::COMPUTE_SHADER_TYPE != tested_shader_type)
            {
                execute_draw_test(tested_shader_type);
            }
            else
            {
                execute_dispatch_test();
            }

            /* Deallocate any resources used. */
            gl.deleteBuffers(1, &buffer_object_id);
            this->delete_objects();
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/** Executes test for compute program
 *
 * @tparam API               Tested API descriptor
 **/
template <class API>
void InteractionStorageBuffers2<API>::execute_dispatch_test()
{
    const glw::Functions &gl = this->context_id.getRenderContext().getFunctions();

    gl.dispatchCompute(1, 1, 1);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");
}

/** Executes test for draw program
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 **/
template <class API>
void InteractionStorageBuffers2<API>::execute_draw_test(typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    const glw::Functions &gl = this->context_id.getRenderContext().getFunctions();

    glw::GLuint vao_id = 0;

    gl.genVertexArrays(1, &vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() failed.");

    gl.bindVertexArray(vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() failed.");

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
    case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        gl.drawArrays(GL_POINTS, 0, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        /* Tesselation patch set up */
        gl.patchParameteri(GL_PATCH_VERTICES, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "PatchParameteri");

        gl.drawArrays(GL_PATCHES, 0, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");
        break;

    default:
        TCU_FAIL("Invalid enum");
        break;
    }

    gl.deleteVertexArrays(1, &vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteVertexArrays() failed.");
}

/* Generates the shader source code for the InteractionUniformBuffers3
 * array tests, and attempts to compile each test shader, for both
 * vertex and fragment shaders.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 *                           (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE).
 */
template <class API>
void InteractionStorageBuffers3<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT};
    static const size_t num_var_types_es                 = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT,
                                                            VAR_TYPE_DOUBLE};
    static const size_t num_var_types_gl                 = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const std::string invalid_size_declarations[] = {"[2][2][2][]", "[2][2][][2]", "[2][][2][2]", "[][2][2][2]",
                                                     "[2][2][][]",  "[2][][2][]",  "[][2][2][]",  "[2][][][2]",
                                                     "[][2][][2]",  "[][][2][2]",  "[2][][][]",   "[][2][][]",
                                                     "[][][2][]",   "[][][][2]",   "[][][][]"};
    const std::string array_initializers[]        = {"float[2][2][2][2](float[2][2][2](float[2][2](float[2](1.0, 2.0),"
                                                            "float[2](3.0, 4.0)),"
                                                            "float[2][2](float[2](5.0, 6.0),"
                                                            "float[2](7.0, 8.0))),"
                                                            "float[2][2][2](float[2][2](float[2](1.1, 2.1),"
                                                            "float[2](3.1, 4.1)),"
                                                            "float[2][2](float[2](5.1, 6.1),"
                                                            "float[2](7.1, 8.1))));\n",

                                                     "int[2][2][2][2](int[2][2][2](int[2][2](int[2]( 1,  2),"
                                                            "int[2]( 3,  4)),"
                                                            "int[2][2](int[2]( 5,  6),"
                                                            "int[2]( 7,  8))),"
                                                            "int[2][2][2](int[2][2](int[2](11, 12),"
                                                            "int[2](13, 14)),"
                                                            "int[2][2](int[2](15, 16),"
                                                            "int[2](17, 18))));\n",

                                                     "uint[2][2][2][2](uint[2][2][2](uint[2][2](uint[2]( 1u,  2u),"
                                                            "uint[2]( 3u,  4u)),"
                                                            "uint[2][2](uint[2]( 5u,  6u),"
                                                            "uint[2]( 7u,  8u))),"
                                                            "uint[2][2][2](uint[2][2](uint[2](11u, 12u),"
                                                            "uint[2](13u, 14u)),"
                                                            "uint[2][2](uint[2](15u, 16u),"
                                                            "uint[2](17u, 18u))));\n",

                                                     "double[2][2][2][2](double[2][2][2](double[2][2](double[2](1.0, 2.0),"
                                                            "double[2](3.0, 4.0)),"
                                                            "double[2][2](double[2](5.0, 6.0),"
                                                            "double[2](7.0, 8.0))),"
                                                            "double[2][2][2](double[2][2](double[2](1.1, 2.1),"
                                                            "double[2](3.1, 4.1)),"
                                                            "double[2][2](double[2](5.1, 6.1),"
                                                            "double[2](7.1, 8.1))));\n"};
    const glcts::test_var_type *var_types_set     = var_types_set_es;
    size_t num_var_types                          = num_var_types_es;

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    /* Iterate through float/ int/ uint types.
     * Case: without initializer.
     */
    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            for (size_t invalid_size_declarations_index = 0;
                 invalid_size_declarations_index <
                 sizeof(invalid_size_declarations) / sizeof(invalid_size_declarations[0]);
                 invalid_size_declarations_index++)
            {
                std::string shader_source;

                shader_source = "layout (std140) buffer MyStorage {\n";
                shader_source += "    " + var_iterator->second.type +
                                 invalid_size_declarations[invalid_size_declarations_index] + " my_variable;\n";
                shader_source += "};\n\n";
                shader_source += shader_start;

                /* End main */
                DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

                /* Execute test */
                EXECUTE_SHADER_TEST(API::ALLOW_UNSIZED_DECLARATION && invalid_size_declarations_index == 3,
                                    tested_shader_type, shader_source);
            } /* for (int invalid_size_declarations_index = 0; ...) */
        }
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */

    /* Iterate through float/ int/ uint types.
     * Case: with initializer.
     */
    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            for (size_t invalid_size_declarations_index = 0;
                 invalid_size_declarations_index <
                 sizeof(invalid_size_declarations) / sizeof(invalid_size_declarations[0]);
                 invalid_size_declarations_index++)
            {
                std::string shader_source;

                shader_source = "layout (std140) buffer MyStorage {\n";
                shader_source += "    " + var_iterator->second.type +
                                 invalid_size_declarations[invalid_size_declarations_index] +
                                 " my_variable = " + array_initializers[var_type_index];
                shader_source += "};\n\n";
                shader_source += shader_start;

                /* End main */
                DEFAULT_MAIN_ENDING(tested_shader_type, shader_source);

                /* Execute test */
                this->execute_negative_test(tested_shader_type, shader_source);
            } /* for (int invalid_size_declarations_index = 0; ...) */
        }     /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/* Generates the shader source code for the InteractionInterfaceArrays1
 * array test, and attempts to compile the test shader.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested.
 */
template <class API>
void InteractionInterfaceArrays1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    /* Shader source with invalid buffer (buffer cannot be of arrays of arrays type). */
    const std::string invalid_buffer_shader_source = "layout(std140) buffer MyBuffer\n"
                                                     "{\n"
                                                     "    float f;\n"
                                                     "    int   i;\n"
                                                     "    uint  ui;\n"
                                                     "} myBuffers[2][2];\n\n"
                                                     "void main()\n"
                                                     "{\n";

    /* Verify that buffer arrays of arrays type is rejected. */
    {
        std::string source = invalid_buffer_shader_source;

        DEFAULT_MAIN_ENDING(tested_shader_type, source);

        EXECUTE_SHADER_TEST(API::ALLOW_A_OF_A_ON_INTERFACE_BLOCKS, tested_shader_type, source);
    }
}

/* Generates the shader source code for the InteractionInterfaceArrays2
 * array test, and attempts to compile the test shader.
 *
 * @tparam API              Tested API descriptor
 *
 * @param input_shader_type The type of shader that is being tested.
 */
template <class API>
void InteractionInterfaceArrays2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType input_shader_type)
{
    /* Shader source with invalid input (input cannot be of arrays of arrays type). */
    const std::string input_variable_shader_source[] = {"in  float inout_variable",
                                                        "[2][2];\n"
                                                        "out float result",
                                                        ";\n\n"
                                                        "void main()\n"
                                                        "{\n"
                                                        "    result",
                                                        " = inout_variable", "[0][0];\n"};
    /* Shader source with invalid output (output cannot be of arrays of arrays type). */
    const std::string output_variable_shader_source[] = {"out float inout_variable",
                                                         "[2][2];\n\n"
                                                         "void main()\n"
                                                         "{\n"
                                                         "    inout_variable",
                                                         "[0][0] = 0.0;\n"
                                                         "    inout_variable",
                                                         "[0][1] = 1.0;\n"
                                                         "    inout_variable",
                                                         "[1][0] = 2.0;\n"
                                                         "    inout_variable",
                                                         "[1][1] = 3.0;\n"};

    const typename TestCaseBase<API>::TestShaderType &output_shader_type =
        this->get_output_shader_type(input_shader_type);
    std::string input_source;
    std::string output_source;

    this->prepare_sources(input_shader_type, output_shader_type, input_variable_shader_source,
                          output_variable_shader_source, input_source, output_source);

    /* Verify that INPUTs and OUTPUTs arrays of arrays type is rejected. */
    if (TestCaseBase<API>::COMPUTE_SHADER_TYPE != input_shader_type)
    {
        if (API::ALLOW_A_OF_A_ON_INTERFACE_BLOCKS)
        {

            if (API::USE_ALL_SHADER_STAGES)
            {
                const std::string &compute_shader_source = empty_string;
                const std::string &fragment_shader_source =
                    this->prepare_fragment_shader(input_shader_type, input_source, output_source);
                const std::string &geometry_shader_source =
                    this->prepare_geometry_shader(input_shader_type, input_source, output_source);
                const std::string &tess_ctrl_shader_source =
                    this->prepare_tess_ctrl_shader_source(input_shader_type, input_source, output_source);
                const std::string &tess_eval_shader_source =
                    this->prepare_tess_eval_shader_source(input_shader_type, input_source, output_source);
                const std::string &vertex_shader_source =
                    this->prepare_vertex_shader(input_shader_type, input_source, output_source);

                this->execute_positive_test(vertex_shader_source, tess_ctrl_shader_source, tess_eval_shader_source,
                                            geometry_shader_source, fragment_shader_source, compute_shader_source, true,
                                            false);
            }
            else
            {
                const std::string &fragment_shader_source =
                    this->prepare_fragment_shader(input_shader_type, input_source, output_source);
                const std::string &vertex_shader_source =
                    this->prepare_vertex_shader(input_shader_type, input_source, output_source);

                this->execute_positive_test(vertex_shader_source, fragment_shader_source, true, false);
            }
        }
        else
        {
            this->execute_negative_test(input_shader_type, input_source);
            this->execute_negative_test(output_shader_type, output_source);
        }
    }
}

/** Gets the shader type to test for the outputs
 *
 * @tparam API              Tested API descriptor
 *
 * @param input_shader_type The type of input shader that is being tested
 **/
template <class API>
const typename TestCaseBase<API>::TestShaderType InteractionInterfaceArrays2<API>::get_output_shader_type(
    const typename TestCaseBase<API>::TestShaderType &input_shader_type)
{
    switch (input_shader_type)
    {
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        return TestCaseBase<API>::FRAGMENT_SHADER_TYPE;

    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        if (API::USE_ALL_SHADER_STAGES)
        {
            return TestCaseBase<API>::GEOMETRY_SHADER_TYPE;
        }
        else
        {
            return TestCaseBase<API>::VERTEX_SHADER_TYPE;
        }

    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        return TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        return TestCaseBase<API>::VERTEX_SHADER_TYPE;

    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        return TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE;

    default:
        TCU_FAIL("Unrecognized shader type.");
        break;
    }

    return input_shader_type;
}

/** Prepare fragment shader
 *
 * @tparam API              Tested API descriptor
 *
 * @param input_shader_type The type of input shader that is being tested
 * @param input_source      Shader in case we want to test inputs for this shader
 * @param output_source     Shader in case we want to test outputs for this shader
 **/
template <class API>
const std::string InteractionInterfaceArrays2<API>::prepare_fragment_shader(
    const typename TestCaseBase<API>::TestShaderType &input_shader_type, const std::string &input_source,
    const std::string &output_source)
{
    switch (input_shader_type)
    {
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        return output_source;

    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        return input_source;

    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        break;

    default:
        TCU_FAIL("Unrecognized shader type.");
        break;
    }

    return default_fragment_shader_source;
}

/** Prepare geometry shader
 *
 * @tparam API              Tested API descriptor
 *
 * @param input_shader_type The type of input shader that is being tested
 * @param input_source      Shader in case we want to test inputs for this shader
 * @param output_source     Shader in case we want to test outputs for this shader
 **/
template <class API>
const std::string InteractionInterfaceArrays2<API>::prepare_geometry_shader(
    const typename TestCaseBase<API>::TestShaderType &input_shader_type, const std::string &input_source,
    const std::string &output_source)
{
    switch (input_shader_type)
    {
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        if (API::USE_ALL_SHADER_STAGES)
        {
            return output_source;
        }
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        return input_source;

    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        break;

    default:
        TCU_FAIL("Unrecognized shader type.");
        break;
    }

    return default_geometry_shader_source;
}

/** Prepare tessellation control shader
 *
 * @tparam API              Tested API descriptor
 *
 * @param input_shader_type The type of input shader that is being tested
 * @param input_source      Shader in case we want to test inputs for this shader
 * @param output_source     Shader in case we want to test outputs for this shader
 **/
template <class API>
const std::string InteractionInterfaceArrays2<API>::prepare_tess_ctrl_shader_source(
    const typename TestCaseBase<API>::TestShaderType &input_shader_type, const std::string &input_source,
    const std::string &output_source)
{
    switch (input_shader_type)
    {
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        return input_source;

    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        return output_source;

    default:
        TCU_FAIL("Unrecognized shader type.");
        break;
    }

    return default_tc_shader_source;
}

/** Prepare tessellation evaluation shader
 *
 * @tparam API              Tested API descriptor
 *
 * @param input_shader_type The type of input shader that is being tested
 * @param input_source      Shader in case we want to test inputs for this shader
 * @param output_source     Shader in case we want to test outputs for this shader
 **/
template <class API>
const std::string InteractionInterfaceArrays2<API>::prepare_tess_eval_shader_source(
    const typename TestCaseBase<API>::TestShaderType &input_shader_type, const std::string &input_source,
    const std::string &output_source)
{
    switch (input_shader_type)
    {
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        return output_source;

    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        return input_source;

    default:
        TCU_FAIL("Unrecognized shader type.");
        break;
    }

    return default_te_shader_source;
}

/** Prepare vertex shader
 *
 * @tparam API              Tested API descriptor
 *
 * @param input_shader_type The type of input shader that is being tested
 * @param input_source      Shader in case we want to test inputs for this shader
 * @param output_source     Shader in case we want to test outputs for this shader
 **/
template <class API>
const std::string InteractionInterfaceArrays2<API>::prepare_vertex_shader(
    const typename TestCaseBase<API>::TestShaderType &input_shader_type, const std::string &input_source,
    const std::string &output_source)
{
    switch (input_shader_type)
    {
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        return input_source;

    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        if (!API::USE_ALL_SHADER_STAGES)
        {
            return output_source;
        }
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        return output_source;

    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        break;

    default:
        TCU_FAIL("Unrecognized shader type.");
        break;
    }

    return default_vertex_shader_source;
}

/** Prepare the inputs and outputs shaders
 *
 * @tparam API                 Tested API descriptor
 *
 * @param input_shader_type    The type of input shader that is being tested
 * @param output_shader_type   The type of output shader that is being tested
 * @param input_shader_source  Snippet used to prepare the input shader
 * @param output_shader_source Snippet used to prepare the output shader
 * @param input_source         Resulting input shader
 * @param output_source        Resulting output shader
 **/
template <class API>
void InteractionInterfaceArrays2<API>::prepare_sources(
    const typename TestCaseBase<API>::TestShaderType &input_shader_type,
    const typename TestCaseBase<API>::TestShaderType &output_shader_type, const std::string *input_shader_source,
    const std::string *output_shader_source, std::string &input_source, std::string &output_source)
{
    if (TestCaseBase<API>::COMPUTE_SHADER_TYPE != input_shader_type)
    {
        input_source += input_shader_source[0];
        output_source += output_shader_source[0];

        if ((TestCaseBase<API>::GEOMETRY_SHADER_TYPE == input_shader_type) ||
            (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == input_shader_type) ||
            (TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE == input_shader_type))
        {
            input_source += "[]";
        }

        if (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == output_shader_type)
        {
            output_source += "[]";
        }

        input_source += input_shader_source[1];
        output_source += output_shader_source[1];

        if (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == input_shader_type)
        {
            input_source += "[]";
        }

        if (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == output_shader_type)
        {
            output_source += "[gl_InvocationID]";
        }

        input_source += input_shader_source[2];
        output_source += output_shader_source[2];

        if (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == input_shader_type)
        {
            input_source += "[gl_InvocationID]";
        }

        if (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == output_shader_type)
        {
            output_source += "[gl_InvocationID]";
        }

        input_source += input_shader_source[3];
        output_source += output_shader_source[3];

        if ((TestCaseBase<API>::GEOMETRY_SHADER_TYPE == input_shader_type) ||
            (TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE == input_shader_type))
        {
            input_source += "[0]";
        }

        if (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == input_shader_type)
        {
            input_source += "[gl_InvocationID]";
        }

        if (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == output_shader_type)
        {
            output_source += "[gl_InvocationID]";
        }

        input_source += input_shader_source[4];
        output_source += output_shader_source[4];

        if (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == output_shader_type)
        {
            output_source += "[gl_InvocationID]";
        }

        output_source += output_shader_source[5];

        DEFAULT_MAIN_ENDING(input_shader_type, input_source);
        DEFAULT_MAIN_ENDING(output_shader_type, output_source);
    }
}

/* Generates the shader source code for the InteractionInterfaceArrays3
 * array test, and attempts to compile the test shader.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested.
 */
template <class API>
void InteractionInterfaceArrays3<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    /* Shader source with invalid uniform block (uniform block cannot be of arrays of arrays type). */
    const std::string invalid_uniform_block_shader_source = "layout(std140) uniform MyUniformBlock\n"
                                                            "{\n"
                                                            "    float f;\n"
                                                            "    int   i;\n"
                                                            "    uint  ui;\n"
                                                            "} myUniformBlocks[2][2];\n\n"
                                                            "void main()\n"
                                                            "{\n";

    /* Verify that uniform block arrays of arrays type is rejected. */
    {
        std::string source = invalid_uniform_block_shader_source;

        DEFAULT_MAIN_ENDING(tested_shader_type, source);

        EXECUTE_SHADER_TEST(API::ALLOW_A_OF_A_ON_INTERFACE_BLOCKS, tested_shader_type, source);
    }
}

/* Generates the shader source code for the InteractionInterfaceArrays4
 * array test, and attempts to compile the test shader.
 *
 * @tparam API              Tested API descriptor
 *
 * @param input_shader_type The type of shader that is being tested.
 */
template <class API>
void InteractionInterfaceArrays4<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType input_shader_type)
{
    /* Shader source with invalid input (input cannot be of arrays of arrays type). */
    const std::string input_block_shader_source[] = {"in  InOutBlock {\n"
                                                     "    float inout_variable;\n"
                                                     "} inout_block",
                                                     "[2][2];\n"
                                                     "out float result",
                                                     ";\n\n"
                                                     "void main()\n"
                                                     "{\n"
                                                     "    result",
                                                     " = inout_block", "[0][0].inout_variable;\n"};
    /* Shader source with invalid output (output cannot be of arrays of arrays type). */
    const std::string output_block_shader_source[] = {"out InOutBlock {\n"
                                                      "    float inout_variable;\n"
                                                      "} inout_block",
                                                      "[2][2];\n"
                                                      "\n"
                                                      "void main()\n"
                                                      "{\n"
                                                      "    inout_block",
                                                      "[0][0].inout_variable = 0.0;\n"
                                                      "    inout_block",
                                                      "[0][1].inout_variable = 1.0;\n"
                                                      "    inout_block",
                                                      "[1][0].inout_variable = 2.0;\n"
                                                      "    inout_block",
                                                      "[1][1].inout_variable = 3.0;\n"};

    const typename TestCaseBase<API>::TestShaderType &output_shader_type =
        this->get_output_shader_type(input_shader_type);
    std::string input_source;
    std::string output_source;

    this->prepare_sources(input_shader_type, output_shader_type, input_block_shader_source, output_block_shader_source,
                          input_source, output_source);

    /* Verify that INPUTs and OUTPUTs arrays of arrays type is rejected. */
    if ((TestCaseBase<API>::VERTEX_SHADER_TYPE != input_shader_type) &&
        (TestCaseBase<API>::COMPUTE_SHADER_TYPE != input_shader_type))
    {
        if (API::ALLOW_A_OF_A_ON_INTERFACE_BLOCKS && API::ALLOW_IN_OUT_INTERFACE_BLOCKS)
        {

            if (API::USE_ALL_SHADER_STAGES)
            {
                const std::string &compute_shader_source = empty_string;
                const std::string &fragment_shader_source =
                    this->prepare_fragment_shader(input_shader_type, input_source, output_source);
                const std::string &geometry_shader_source =
                    this->prepare_geometry_shader(input_shader_type, input_source, output_source);
                const std::string &tess_ctrl_shader_source =
                    this->prepare_tess_ctrl_shader_source(input_shader_type, input_source, output_source);
                const std::string &tess_eval_shader_source =
                    this->prepare_tess_eval_shader_source(input_shader_type, input_source, output_source);
                const std::string &vertex_shader_source =
                    this->prepare_vertex_shader(input_shader_type, input_source, output_source);

                this->execute_positive_test(vertex_shader_source, tess_ctrl_shader_source, tess_eval_shader_source,
                                            geometry_shader_source, fragment_shader_source, compute_shader_source, true,
                                            false);
            }
            else
            {
                const std::string &fragment_shader_source =
                    this->prepare_fragment_shader(input_shader_type, input_source, output_source);
                const std::string &vertex_shader_source =
                    this->prepare_vertex_shader(input_shader_type, input_source, output_source);

                this->execute_positive_test(vertex_shader_source, fragment_shader_source, true, false);
            }
        }
        else
        {
            this->execute_negative_test(input_shader_type, input_source);
            this->execute_negative_test(output_shader_type, output_source);
        }
    }
}

/** Calulate smallest denominator for values over 1
 *
 * @param value Value in question
 *
 * @return Smallest denominator
 **/
size_t findSmallestDenominator(const size_t value)
{
    /* Skip 0 and 1 */
    for (size_t i = 2; i < value; ++i)
    {
        if (0 == value % i)
        {
            return i;
        }
    }

    return value;
}

/** Check if left is bigger than right
 *
 * @tparam T Type of values

 * @param l  Left value
 * @param r  Right value
 *
 * @return true if l > r, false otherwise
 **/
template <class T>
bool more(const T &l, const T &r)
{
    return l > r;
}

/** Prepare dimensions of array with given number of entries
 *
 * @tparam API       Tested API descriptor
 *
 * @param n_entries  Number of entries
 * @param dimensions Storage for dimesnions
 **/
template <class API>
void prepareDimensions(size_t n_entries, std::vector<size_t> &dimensions)
{
    if (dimensions.empty())
        return;

    const size_t last = dimensions.size() - 1;

    /* Calculate */
    for (size_t i = 0; i < last; ++i)
    {
        const size_t denom = findSmallestDenominator(n_entries);

        n_entries /= denom;

        dimensions[i] = denom;
    }

    dimensions[last] = n_entries;

    /* Sort */
    std::sort(dimensions.begin(), dimensions.end(), more<size_t>);
}

/* Generates the shader source code for the AtomicDeclarationTest
 * and attempts to compile each shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 */
template <class API>
void AtomicDeclarationTest<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const char *indent_step         = "    ";
    static const char *uniform_atomic_uint = "layout(binding = 0) uniform atomic_uint";

    const glw::Functions &gl = this->context_id.getRenderContext().getFunctions();

    std::string comment;
    std::vector<size_t> dimensions;
    std::string indent;
    std::string indexing;
    std::string invalid_definition = uniform_atomic_uint;
    std::string invalid_iteration;
    std::string invalid_shader_source;
    std::string loop_end;
    glw::GLint max_atomics = 0;
    glw::GLenum pname      = 0;
    std::string valid_shader_source;
    std::string valid_definition = uniform_atomic_uint;
    std::string valid_iteration;

    /* Select pname of max for stage */
    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        pname = GL_MAX_COMPUTE_ATOMIC_COUNTERS;
        break;
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        pname = GL_MAX_FRAGMENT_ATOMIC_COUNTERS;
        break;
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        pname = GL_MAX_GEOMETRY_ATOMIC_COUNTERS;
        break;
    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        pname = GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS;
        break;
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        pname = GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS;
        break;
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        pname = GL_MAX_VERTEX_ATOMIC_COUNTERS;
        break;
    default:
        TCU_FAIL("Invalid enum");
        break;
    }

    /* Get maximum */
    gl.getIntegerv(pname, &max_atomics);
    GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv");

    if (0 == max_atomics)
    {
        /* Not supported - skip */
        return;
    }
    else
    {
        dimensions.resize(API::MAX_ARRAY_DIMENSIONS);
        prepareDimensions<API>(max_atomics, dimensions);
    }

    /* Prepare parts of shader */
    for (size_t i = API::MAX_ARRAY_DIMENSIONS; i != 0; --i)
    {
        char it[16];
        char max[16];

        indent += indent_step;

        loop_end.insert(0, "}\n");
        loop_end.insert(0, indent);

        sprintf(it, "i%u", (unsigned int)(API::MAX_ARRAY_DIMENSIONS - i));

        indexing += "[";
        indexing += it;
        indexing += "]";

        sprintf(max, "%u", (unsigned int)(dimensions[i - 1]));

        valid_definition += "[";
        valid_definition += max;
        valid_definition += "]";

        valid_iteration += indent;
        valid_iteration += "for (uint ";
        valid_iteration += it;
        valid_iteration += " = 0; ";
        valid_iteration += it;
        valid_iteration += " < ";
        valid_iteration += max;
        valid_iteration += "; ++";
        valid_iteration += it;
        valid_iteration += ")\n";
        valid_iteration += indent;
        valid_iteration += "{\n";

        if (1 == i)
        {
            sprintf(max, "%u", (unsigned int)(dimensions[i - 1] + 1));
        }
        invalid_definition += "[";
        invalid_definition += max;
        invalid_definition += "]";

        invalid_iteration += indent;
        invalid_iteration += "for (uint ";
        invalid_iteration += it;
        invalid_iteration += " = 0; ";
        invalid_iteration += it;
        invalid_iteration += " < ";
        invalid_iteration += max;
        invalid_iteration += "; ++";
        invalid_iteration += it;
        invalid_iteration += ")\n";
        invalid_iteration += indent;
        invalid_iteration += "{\n";
    }

    {
        char max[16];

        sprintf(max, "%u", (unsigned int)(max_atomics));
        comment += "/* MAX_*_ATOMIC_COUNTERS = ";
        comment += max;
        comment += " */\n";
    }

    /* Prepare invalid source */
    invalid_shader_source += comment;
    invalid_shader_source += invalid_definition;
    invalid_shader_source += " a;\n\nvoid main()\n{\n";
    invalid_shader_source += invalid_iteration;
    invalid_shader_source += indent;
    invalid_shader_source += indent_step;
    invalid_shader_source += "atomicCounterIncrement( a";
    invalid_shader_source += indexing;
    invalid_shader_source += " );\n";
    invalid_shader_source += loop_end;

    /* Prepare valid source */
    valid_shader_source += comment;
    valid_shader_source += valid_definition;
    valid_shader_source += " a;\n\nvoid main()\n{\n";
    valid_shader_source += valid_iteration;
    valid_shader_source += indent;
    valid_shader_source += indent_step;
    valid_shader_source += "atomicCounterIncrement( a";
    valid_shader_source += indexing;
    valid_shader_source += " );\n";
    valid_shader_source += loop_end;

    /* End main */
    DEFAULT_MAIN_ENDING(tested_shader_type, invalid_shader_source);
    DEFAULT_MAIN_ENDING(tested_shader_type, valid_shader_source);

    /* Execute test */
    EXECUTE_POSITIVE_TEST(tested_shader_type, valid_shader_source, true, false);

    /* Expect build failure for invalid shader source */
    {
        bool negative_build_test_result = false;

        try
        {
            EXECUTE_POSITIVE_TEST(tested_shader_type, invalid_shader_source, true, false);
        }
        catch (...)
        {
            negative_build_test_result = true;
        }

        if (false == negative_build_test_result)
        {
            TCU_FAIL("It was expected that build process will fail");
        }
    }
}

/* Generates the shader source code for the AtomicUsageTest
 * and attempts to compile each shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 */
template <class API>
void AtomicUsageTest<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    const glw::Functions &gl = this->context_id.getRenderContext().getFunctions();

    glw::GLint max_atomics  = 0;
    glw::GLint max_bindings = 0;
    glw::GLint max_size     = 0;
    glw::GLenum pname       = 0;

    /* Select pname of max for stage */
    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        pname = GL_MAX_COMPUTE_ATOMIC_COUNTERS;
        break;
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        pname = GL_MAX_FRAGMENT_ATOMIC_COUNTERS;
        break;
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        pname = GL_MAX_GEOMETRY_ATOMIC_COUNTERS;
        break;
    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        pname = GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS;
        break;
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        pname = GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS;
        break;
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        pname = GL_MAX_VERTEX_ATOMIC_COUNTERS;
        break;
    default:
        TCU_FAIL("Invalid enum");
        break;
    }

    /* Get limits */
    gl.getIntegerv(pname, &max_atomics);
    GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv");

    gl.getIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, &max_bindings);
    GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv");

    gl.getIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE, &max_size);
    GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv");

    if (0 == max_atomics)
    {
        /* Not supported - skip */
        return;
    }

    const glw::GLuint last_binding = (glw::GLuint)max_bindings - 1;
    const glw::GLuint offset       = (glw::GLuint)max_size / 2;
    glw::GLuint n_entries =
        std::min((glw::GLuint)(max_size - offset) / (glw::GLuint)sizeof(glw::GLuint), (glw::GLuint)max_atomics);

    if (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type)
    {
        glw::GLint max_uniform_locations = 0;

        gl.getIntegerv(GL_MAX_UNIFORM_LOCATIONS, &max_uniform_locations);
        GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv");

        max_atomics = std::min(max_atomics, (max_uniform_locations - 1));
        n_entries   = (glw::GLuint)std::min((glw::GLint)n_entries, (max_uniform_locations - 1));
    }

    execute(tested_shader_type, last_binding, 0 /* offset */, max_atomics);
    execute(tested_shader_type, last_binding, offset, n_entries);
}

/* Generates the shader source code for the AtomicUsageTest
 * and attempts to compile each shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 * @param binding            Binding index
 * @param offset             Offset of data
 * @param n_entries          Number of entries in array
 */
template <class API>
void AtomicUsageTest<API>::execute(typename TestCaseBase<API>::TestShaderType tested_shader_type, glw::GLuint binding,
                                   glw::GLuint offset, glw::GLuint n_entries)
{
    static const char *indent_step         = "    ";
    static const char *layout_binding      = "layout(binding = ";
    static const char *layout_offset       = ", offset = ";
    static const char *uniform_atomic_uint = ") uniform atomic_uint";

    const glw::Functions &gl = this->context_id.getRenderContext().getFunctions();

    std::string comment;
    std::vector<size_t> dimensions;
    std::string indent;
    std::string indexing;
    std::string loop_end;
    std::string result;
    std::string valid_shader_source;
    std::string valid_definition = layout_binding;
    std::string valid_iteration;
    std::string varying_definition;

    dimensions.resize(API::MAX_ARRAY_DIMENSIONS);
    prepareDimensions<API>(n_entries, dimensions);

    /* Prepare parts of shader */

    /* Append binding */
    {
        char buffer[16];
        sprintf(buffer, "%u", static_cast<unsigned int>(binding));
        valid_definition += buffer;
        valid_definition += layout_offset;
        sprintf(buffer, "%u", static_cast<unsigned int>(offset));
        valid_definition += buffer;
        valid_definition += uniform_atomic_uint;
    }

    for (size_t i = API::MAX_ARRAY_DIMENSIONS; i != 0; --i)
    {
        char it[16];
        char max[16];

        indent += indent_step;

        loop_end.insert(0, "}\n");
        loop_end.insert(0, indent);

        sprintf(it, "i%u", (unsigned int)(API::MAX_ARRAY_DIMENSIONS - i));

        indexing += "[";
        indexing += it;
        indexing += "]";

        sprintf(max, "%u", (unsigned int)(dimensions[i - 1]));
        valid_definition += "[";
        valid_definition += max;
        valid_definition += "]";

        valid_iteration += indent;
        valid_iteration += "for (uint ";
        valid_iteration += it;
        valid_iteration += " = 0; ";
        valid_iteration += it;
        valid_iteration += " < ";
        valid_iteration += max;
        valid_iteration += "; ++";
        valid_iteration += it;
        valid_iteration += ")\n";
        valid_iteration += indent;
        valid_iteration += "{\n";
    }

    {
        char max[16];

        sprintf(max, "%u", (unsigned int)(n_entries));
        comment += "/* Number of atomic counters = ";
        comment += max;
        comment += " */\n";
    }

    /* Select varyings and result */
    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        result             = "    imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), vec4(result, 0, 0, 0));\n";
        varying_definition = "writeonly uniform image2D uni_image;\n"
                             "\n";
        break;

    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        result             = "    color = vec4(result);\n";
        varying_definition = "out vec4 color;\n"
                             "\n";
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        result             = "    gl_Position  = vec4(-1, -1, 0, 1);\n"
                             "    fs_result = result;\n"
                             "    EmitVertex();\n"
                             "    gl_Position  = vec4(-1, 1, 0, 1);\n"
                             "    fs_result = result;\n"
                             "    EmitVertex();\n"
                             "    gl_Position  = vec4(1, -1, 0, 1);\n"
                             "    fs_result = result;\n"
                             "    EmitVertex();\n"
                             "    gl_Position  = vec4(1, 1, 0, 1);\n"
                             "    fs_result = result;\n"
                             "    EmitVertex();\n";
        varying_definition = "out float fs_result;\n"
                             "\n";
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        result             = "    tcs_result[gl_InvocationID] = result;\n"
                             "\n"
                             "    gl_TessLevelOuter[0] = 1.0;\n"
                             "    gl_TessLevelOuter[1] = 1.0;\n"
                             "    gl_TessLevelOuter[2] = 1.0;\n"
                             "    gl_TessLevelOuter[3] = 1.0;\n"
                             "    gl_TessLevelInner[0] = 1.0;\n"
                             "    gl_TessLevelInner[1] = 1.0;\n";
        varying_definition = "out float tcs_result[];\n"
                             "\n";
        break;

    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        result             = "    fs_result = result;\n";
        varying_definition = "out float fs_result;\n"
                             "\n";
        break;

    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        result             = "    fs_result = result;\n";
        varying_definition = "out float fs_result;\n"
                             "\n";
        break;

    default:
        TCU_FAIL("Invalid enum");
        break;
    }

    /* Prepare valid source */
    valid_shader_source += varying_definition;
    valid_shader_source += comment;
    valid_shader_source += valid_definition;
    valid_shader_source += " a;\n\nvoid main()\n{\n    uint sum = 0u;\n";
    valid_shader_source += valid_iteration;
    valid_shader_source += indent;
    valid_shader_source += indent_step;
    valid_shader_source += "sum += atomicCounterIncrement( a";
    valid_shader_source += indexing;
    valid_shader_source += " );\n";
    valid_shader_source += loop_end;
    valid_shader_source += "\n"
                           "    float result = 0.0;\n"
                           "\n"
                           "    if (16u < sum)\n"
                           "    {\n"
                           "         result = 1.0;\n"
                           "    }\n";
    valid_shader_source += result;
    valid_shader_source += shader_end;

    /* Build program */
    {
        const std::string *cs  = &empty_string;
        const std::string *vs  = &default_vertex_shader_source;
        const std::string *tcs = &empty_string;
        const std::string *tes = &empty_string;
        const std::string *gs  = &empty_string;
        const std::string *fs  = &pass_fragment_shader_source;

        switch (tested_shader_type)
        {
        case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
            cs = &valid_shader_source;
            vs = &empty_string;
            fs = &empty_string;
            break;

        case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
            fs = &valid_shader_source;
            break;

        case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
            gs = &valid_shader_source;
            break;

        case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
            tcs = &valid_shader_source;
            tes = &pass_te_shader_source;
            break;

        case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
            tcs = &default_tc_shader_source;
            tes = &valid_shader_source;
            break;

        case TestCaseBase<API>::VERTEX_SHADER_TYPE:
            vs = &valid_shader_source;
            break;

        default:
            TCU_FAIL("Invalid enum");
            break;
        }

        if (API::USE_ALL_SHADER_STAGES)
        {
            this->execute_positive_test(*vs, *tcs, *tes, *gs, *fs, *cs, false, false);
        }
        else
        {
            this->execute_positive_test(*vs, *fs, false, false);
        }
    }

    gl.useProgram(this->program_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed.");

    /* Prepare buffer */
    glw::GLuint buffer_object_id = 0;
    std::vector<glw::GLuint> buffer_data;
    const size_t start_pos        = offset / 4;
    const size_t last_pos         = start_pos + n_entries;
    const size_t buffer_data_size = last_pos * sizeof(glw::GLuint);

    gl.genBuffers(1, &buffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() failed.");

    gl.bindBuffer(GL_ATOMIC_COUNTER_BUFFER, buffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() failed.");

    buffer_data.resize(start_pos + n_entries);
    for (size_t i = 0; i < n_entries; ++i)
    {
        buffer_data[start_pos + i] = (glw::GLuint)i;
    }

    gl.bufferData(GL_ATOMIC_COUNTER_BUFFER, buffer_data_size, &buffer_data[0], GL_STATIC_DRAW);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed.");

    gl.bindBufferBase(GL_ATOMIC_COUNTER_BUFFER, binding, buffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() failed.");

    /* Run program */
    if (TestCaseBase<API>::COMPUTE_SHADER_TYPE != tested_shader_type)
    {
        glw::GLuint framebuffer_object_id = 0;
        glw::GLuint texture_object_id     = 0;
        glw::GLuint vao_id                = 0;

        gl.genTextures(1, &texture_object_id);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed.");

        gl.bindTexture(GL_TEXTURE_2D, texture_object_id);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() failed.");

        gl.texStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() failed.");

        gl.genFramebuffers(1, &framebuffer_object_id);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() failed.");

        gl.bindFramebuffer(GL_FRAMEBUFFER, framebuffer_object_id);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() failed.");

        gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_object_id, 0);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() failed.");

        gl.viewport(0, 0, 1, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() failed.");

        gl.genVertexArrays(1, &vao_id);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() failed.");

        gl.bindVertexArray(vao_id);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() failed.");

        switch (tested_shader_type)
        {
        case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */
        case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
            gl.drawArrays(GL_POINTS, 0, 1);
            GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");
            break;

        case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */
        case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
            /* Tesselation patch set up */
            gl.patchParameteri(GL_PATCH_VERTICES, 1);
            GLU_EXPECT_NO_ERROR(gl.getError(), "PatchParameteri");

            gl.drawArrays(GL_PATCHES, 0, 1);
            GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");
            break;

        default:
            TCU_FAIL("Invalid enum");
            break;
        }

        gl.memoryBarrier(GL_ALL_BARRIER_BITS);
        GLU_EXPECT_NO_ERROR(gl.getError(), "MemoryBarrier.");

        gl.bindTexture(GL_TEXTURE_2D, 0);
        gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
        gl.bindVertexArray(0);
        gl.deleteTextures(1, &texture_object_id);
        gl.deleteFramebuffers(1, &framebuffer_object_id);
        gl.deleteVertexArrays(1, &vao_id);
        GLU_EXPECT_NO_ERROR(gl.getError(), "An error ocurred while deleting generated objects.");
    }
    else
    {
        gl.dispatchCompute(1, 1, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");

        gl.memoryBarrier(GL_ALL_BARRIER_BITS);
        GLU_EXPECT_NO_ERROR(gl.getError(), "MemoryBarrier.");
    }

    /* Verify results */
    bool test_result = true;

    const glw::GLuint *results =
        (glw::GLuint *)gl.mapBufferRange(GL_ATOMIC_COUNTER_BUFFER, 0 /* offset */, buffer_data_size, GL_MAP_READ_BIT);
    GLU_EXPECT_NO_ERROR(gl.getError(), "MapBufferRange");

    /* Anything before start position should be 0 */
    for (size_t i = 0; i < start_pos; ++i)
    {
        if (0 != results[i])
        {
            test_result = false;
            break;
        }
    }

    /* Anything from start_pos should be incremented by 1 */
    int diff = 0;
    for (size_t i = 0; i < n_entries; ++i)
    {
        /* Tesselation evaluation can be called several times
         In here, check the increment is consistent over all results.
         */
        if (tested_shader_type == TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE)
        {
            if (i == 0)
            {
                diff = static_cast<int>(results[i + start_pos]) - static_cast<int>(i);
                if (diff <= 0)
                {
                    test_result = false;
                    break;
                }
            }
            else if ((static_cast<int>(results[i + start_pos]) - static_cast<int>(i)) != diff)
            {
                test_result = false;
                break;
            }
        }
        else
        {
            if (i + 1 != results[i + start_pos])
            {
                test_result = false;
                break;
            }
        }
    }

    gl.unmapBuffer(GL_ATOMIC_COUNTER_BUFFER);
    GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer");

    /* Deallocate any resources used. */
    gl.deleteBuffers(1, &buffer_object_id);
    this->delete_objects();

    if (false == test_result)
    {
        TCU_FAIL("Invalid results.");
    }
}

/* Generates the shader source code for the SubroutineFunctionCalls1
 * array tests, attempts to build and execute test program
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 */
template <class API>
void SubroutineFunctionCalls1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {
        VAR_TYPE_INT,  VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2,
        VAR_TYPE_VEC3, VAR_TYPE_VEC4,  VAR_TYPE_MAT2,  VAR_TYPE_MAT3,  VAR_TYPE_MAT4};
    static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {
        VAR_TYPE_INT,  VAR_TYPE_FLOAT,  VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, VAR_TYPE_IVEC4,
        VAR_TYPE_VEC2, VAR_TYPE_VEC3,   VAR_TYPE_VEC4,  VAR_TYPE_MAT2,  VAR_TYPE_MAT3,
        VAR_TYPE_MAT4, VAR_TYPE_DOUBLE, VAR_TYPE_DMAT2, VAR_TYPE_DMAT3, VAR_TYPE_DMAT4};
    static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const std::string iteration_loop_end      = "                }\n"
                                                "            }\n"
                                                "        }\n"
                                                "    }\n";
    const std::string iteration_loop_start    = "    for (uint a = 0u; a < 2u; a++)\n"
                                                "    {\n"
                                                "        for (uint b = 0u; b < 2u; b++)\n"
                                                "        {\n"
                                                "            for (uint c = 0u; c < 2u; c++)\n"
                                                "            {\n"
                                                "                for (uint d = 0u; d < 2u; d++)\n"
                                                "                {\n";
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;
    const bool test_compute                   = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type);

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string iterator_declaration = "    " + var_iterator->second.iterator_type +
                                               " iterator = " + var_iterator->second.iterator_initialization + ";\n";

            std::string function_definition;
            std::string function_use;
            std::string verification;

            function_definition += "// Subroutine types\n"
                                   "subroutine void out_routine_type(out ";
            function_definition += var_iterator->second.type;
            function_definition += " output_array[2][2][2][2]);\n\n"
                                   "// Subroutine definitions\n"
                                   "subroutine(out_routine_type) void original_routine(out ";
            function_definition += var_iterator->second.type;
            function_definition += " output_array[2][2][2][2]) {\n";
            function_definition += iterator_declaration;
            function_definition += iteration_loop_start;
            function_definition += "                                   output_array[a][b][c][d] = " +
                                   var_iterator->second.variable_type_initializer1 + ";\n";
            function_definition +=
                "                                   iterator += " + var_iterator->second.iterator_type + "(1);\n";
            function_definition += iteration_loop_end;
            function_definition += "}\n\n";
            function_definition += "subroutine(out_routine_type) void new_routine(out ";
            function_definition += var_iterator->second.type;
            function_definition += " output_array[2][2][2][2]) {\n";
            function_definition += iterator_declaration;
            function_definition += iteration_loop_start;
            function_definition += "                                   output_array[a][b][c][d] = " +
                                   var_iterator->second.variable_type_initializer1 + ";\n";
            function_definition +=
                "                                   iterator -= " + var_iterator->second.iterator_type + "(1);\n";
            function_definition += iteration_loop_end;
            function_definition += "}\n\n"
                                   "// Subroutine uniform\n"
                                   "subroutine uniform out_routine_type routine;\n";

            function_use = "    " + var_iterator->second.type + " my_array[2][2][2][2];\n";
            function_use += "    routine(my_array);";

            verification = iterator_declaration;
            verification += "    float result = 1.0;\n";
            verification += iteration_loop_start;
            verification += "                                   if (my_array[a][b][c][d] " +
                            var_iterator->second.specific_element +
                            " != iterator)\n"
                            "                                   {\n"
                            "                                       result = 0.0;\n"
                            "                                   }\n"
                            "                                   iterator += " +
                            var_iterator->second.iterator_type + "(1);\n";
            verification += iteration_loop_end;

            if (false == test_compute)
            {
                execute_draw_test(tested_shader_type, function_definition, function_use, verification, false, true);
                execute_draw_test(tested_shader_type, function_definition, function_use, verification, true, false);
            }
            else
            {
                execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, false, true);
                execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, true, false);
            }

            /* Deallocate any resources used. */
            this->delete_objects();
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/** Executes test for compute program
 *
 * @tparam API                  Tested API descriptor
 *
 * @param tested_shader_type    The type of shader that is being tested
 * @param function_definition   Definition used to prepare shader
 * @param function_use          Use of definition
 * @param verification          Result verification
 * @param use_original          Selects if "original_routine" - true or "new_routine" is choosen
 * @param expect_invalid_result Does test expects invalid results
 **/
template <class API>
void SubroutineFunctionCalls1<API>::execute_dispatch_test(typename TestCaseBase<API>::TestShaderType tested_shader_type,
                                                          const std::string &function_definition,
                                                          const std::string &function_use,
                                                          const std::string &verification, bool use_original,
                                                          bool expect_invalid_result)
{
    const std::string &compute_shader_source =
        prepare_compute_shader(tested_shader_type, function_definition, function_use, verification);
    const glw::Functions &gl = this->context_id.getRenderContext().getFunctions();

    this->execute_positive_test(empty_string, empty_string, empty_string, empty_string, empty_string,
                                compute_shader_source, false, false);

    /* We are now ready to verify whether the returned size is correct. */
    unsigned char buffer[4]           = {0};
    glw::GLuint framebuffer_object_id = 0;
    glw::GLint location               = -1;
    glw::GLuint routine_index         = -1;
    glw::GLuint routine_location      = -1;
    const glw::GLchar *routine_name   = "original_routine";
    const glw::GLenum shader_type     = GL_COMPUTE_SHADER;
    glw::GLuint texture_object_id     = 0;

    if (false == use_original)
    {
        routine_name = "new_routine";
    }

    gl.useProgram(this->program_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed.");

    /* Select subroutine */
    routine_index = gl.getSubroutineIndex(this->program_object_id, shader_type, routine_name);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() failed.");

    routine_location = gl.getSubroutineUniformLocation(this->program_object_id, shader_type, "routine");
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineUniformLocation() failed.");

    if (0 != routine_location)
    {
        TCU_FAIL("Subroutine location is invalid");
    }

    gl.uniformSubroutinesuiv(shader_type, 1, &routine_index);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformSubroutinesuiv() failed.");

    /* Prepare texture */
    gl.genTextures(1, &texture_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed.");

    gl.bindTexture(GL_TEXTURE_2D, texture_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() failed.");

    gl.texStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 1);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() failed.");

    gl.bindImageTexture(0 /* image unit */, texture_object_id, 0 /* level */, GL_FALSE /* layered */, 0 /* layer */,
                        GL_WRITE_ONLY, GL_RGBA8);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture() failed.");

    location = gl.getUniformLocation(this->program_object_id, "uni_image");
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation() failed.");

    if (-1 == location)
    {
        TCU_FAIL("Uniform is inactive");
    }

    gl.uniform1i(location, 0 /* image unit */);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i() failed.");

    /* Execute */
    gl.dispatchCompute(1, 1, 1);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");

    /* Verify */
    gl.genFramebuffers(1, &framebuffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() failed.");

    gl.bindFramebuffer(GL_FRAMEBUFFER, framebuffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() failed.");

    gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_object_id, 0);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() failed.");

    gl.viewport(0, 0, 1, 1);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() failed.");

    gl.readBuffer(GL_COLOR_ATTACHMENT0);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glReadBuffer() failed.");

    gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() failed.");

    if ((buffer[0] != 255) != expect_invalid_result)
    {
        TCU_FAIL("Invalid result was returned.");
    }

    /* Delete generated objects. */
    gl.useProgram(0);
    gl.bindTexture(GL_TEXTURE_2D, 0);
    gl.bindFramebuffer(GL_FRAMEBUFFER, 0);

    gl.deleteProgram(this->program_object_id);
    this->program_object_id = 0;

    gl.deleteTextures(1, &texture_object_id);
    gl.deleteFramebuffers(1, &framebuffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "An error ocurred while deleting generated objects.");
}

/** Executes test for draw program
 *
 * @tparam API                  Tested API descriptor
 *
 * @param tested_shader_type    The type of shader that is being tested
 * @param function_definition   Definition used to prepare shader
 * @param function_use          Use of definition
 * @param verification          Result verification
 * @param use_original          Selects if "original_routine" - true or "new_routine" is choosen
 * @param expect_invalid_result Does test expects invalid results
 **/
template <class API>
void SubroutineFunctionCalls1<API>::execute_draw_test(typename TestCaseBase<API>::TestShaderType tested_shader_type,
                                                      const std::string &function_definition,
                                                      const std::string &function_use, const std::string &verification,
                                                      bool use_original, bool expect_invalid_result)
{
    const glw::Functions &gl = this->context_id.getRenderContext().getFunctions();

    if (API::USE_ALL_SHADER_STAGES)
    {
        const std::string &compute_shader_source = empty_string;
        const std::string &fragment_shader_source =
            this->prepare_fragment_shader(tested_shader_type, function_definition, function_use, verification);
        const std::string &geometry_shader_source =
            this->prepare_geometry_shader(tested_shader_type, function_definition, function_use, verification);
        const std::string &tess_ctrl_shader_source =
            this->prepare_tess_ctrl_shader(tested_shader_type, function_definition, function_use, verification);
        const std::string &tess_eval_shader_source =
            this->prepare_tess_eval_shader(tested_shader_type, function_definition, function_use, verification);
        const std::string &vertex_shader_source =
            this->prepare_vertex_shader(tested_shader_type, function_definition, function_use, verification);

        switch (tested_shader_type)
        {
        case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */
        case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
            this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false);
            break;

        case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */
        case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
            this->execute_positive_test(vertex_shader_source, tess_ctrl_shader_source, tess_eval_shader_source,
                                        geometry_shader_source, fragment_shader_source, compute_shader_source, false,
                                        false);
            break;

        default:
            TCU_FAIL("Invalid enum");
            break;
        }
    }
    else
    {
        const std::string &fragment_shader_source =
            this->prepare_fragment_shader(tested_shader_type, function_definition, function_use, verification);
        const std::string &vertex_shader_source =
            this->prepare_vertex_shader(tested_shader_type, function_definition, function_use, verification);

        this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false);
    }

    /* We are now ready to verify whether the returned size is correct. */
    unsigned char buffer[4]           = {0};
    glw::GLuint framebuffer_object_id = 0;
    glw::GLuint routine_index         = -1;
    glw::GLuint routine_location      = -1;
    const glw::GLchar *routine_name   = "original_routine";
    glw::GLenum shader_type           = 0;
    glw::GLuint texture_object_id     = 0;
    glw::GLuint vao_id                = 0;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        shader_type = GL_FRAGMENT_SHADER;
        break;
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        shader_type = GL_VERTEX_SHADER;
        break;
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        shader_type = GL_COMPUTE_SHADER;
        break;
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        shader_type = GL_GEOMETRY_SHADER;
        break;
    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        shader_type = GL_TESS_CONTROL_SHADER;
        break;
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        shader_type = GL_TESS_EVALUATION_SHADER;
        break;
    default:
        TCU_FAIL("Invalid shader type");
        break;
    }

    if (false == use_original)
    {
        routine_name = "new_routine";
    }

    gl.useProgram(this->program_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed.");

    /* Select subroutine */
    routine_index = gl.getSubroutineIndex(this->program_object_id, shader_type, routine_name);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() failed.");

    routine_location = gl.getSubroutineUniformLocation(this->program_object_id, shader_type, "routine");
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineUniformLocation() failed.");

    if (0 != routine_location)
    {
        TCU_FAIL("Subroutine location is invalid");
    }

    gl.uniformSubroutinesuiv(shader_type, 1, &routine_index);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformSubroutinesuiv() failed.");

    /* Prepre texture */
    assert(0 == texture_object_id);
    gl.genTextures(1, &texture_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed.");

    gl.bindTexture(GL_TEXTURE_2D, texture_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() failed.");

    gl.texStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 1);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() failed.");

    /* Prepare framebuffer */
    assert(0 == framebuffer_object_id);
    gl.genFramebuffers(1, &framebuffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() failed.");

    gl.bindFramebuffer(GL_FRAMEBUFFER, framebuffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() failed.");

    gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_object_id, 0);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() failed.");

    gl.viewport(0, 0, 1, 1);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() failed.");

    /* Set VAO */
    assert(0 == vao_id);
    gl.genVertexArrays(1, &vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() failed.");

    gl.bindVertexArray(vao_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() failed.");

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: /* Fall through */
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        gl.drawArrays(GL_TRIANGLE_FAN, 0, 4);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        /* Tesselation patch set up */
        gl.patchParameteri(GL_PATCH_VERTICES, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "PatchParameteri");

        gl.drawArrays(GL_PATCHES, 0, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        gl.drawArrays(GL_POINTS, 0, 1);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed.");
        break;

    default:
        TCU_FAIL("Invalid enum");
        break;
    }

    /* Verify */
    gl.readBuffer(GL_COLOR_ATTACHMENT0);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glReadBuffer() failed.");

    gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() failed.");

    const bool result = ((buffer[0] != 255) == expect_invalid_result);

    /* Delete generated objects. */
    gl.useProgram(0);
    gl.bindTexture(GL_TEXTURE_2D, 0);
    gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
    gl.bindVertexArray(0);

    gl.deleteProgram(this->program_object_id);
    this->program_object_id = 0;

    gl.deleteTextures(1, &texture_object_id);
    texture_object_id = 0;

    gl.deleteFramebuffers(1, &framebuffer_object_id);
    framebuffer_object_id = 0;

    gl.deleteVertexArrays(1, &vao_id);
    vao_id = 0;

    GLU_EXPECT_NO_ERROR(gl.getError(), "An error ocurred while deleting generated objects.");

    if (!result)
    {
        TCU_FAIL("Invalid result was returned.");
    }
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type    The type of shader that is being tested
 * @param function_definition   Definition used to prepare shader
 * @param function_use          Use of definition
 * @param verification          Result verification
 **/
template <class API>
std::string SubroutineFunctionCalls1<API>::prepare_compute_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &function_definition,
    const std::string &function_use, const std::string &verification)
{
    std::string compute_shader_source;

    if (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type)
    {
        compute_shader_source = "writeonly uniform image2D uni_image;\n"
                                "\n";

        /* User-defined function definition. */
        compute_shader_source += function_definition;
        compute_shader_source += "\n\n";

        /* Main function definition. */
        compute_shader_source += shader_start;
        compute_shader_source += function_use;
        compute_shader_source += "\n\n";
        compute_shader_source += verification;
        compute_shader_source += "\n\n";
        compute_shader_source += "\n"
                                 "    imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), vec4(result, 0, 0, 0));\n"
                                 "}\n"
                                 "\n";
    }

    return compute_shader_source;
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type    The type of shader that is being tested
 * @param function_definition   Definition used to prepare shader
 * @param function_use          Use of definition
 * @param verification          Result verification
 **/
template <class API>
std::string SubroutineFunctionCalls1<API>::prepare_fragment_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &function_definition,
    const std::string &function_use, const std::string &verification)
{
    std::string fragment_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        break;

    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        fragment_shader_source = "out vec4 colour;\n\n";

        /* User-defined function definition. */
        fragment_shader_source += function_definition;
        fragment_shader_source += "\n\n";

        /* Main function definition. */
        fragment_shader_source += shader_start;
        fragment_shader_source += function_use;
        fragment_shader_source += "\n\n";
        fragment_shader_source += verification;
        fragment_shader_source += "\n\n";
        fragment_shader_source += "    colour = vec4(result);\n";
        fragment_shader_source += shader_end;
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: /* Fall through */
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        fragment_shader_source = "in float fs_result;\n\n"
                                 "out vec4 colour;\n\n"
                                 "void main()\n"
                                 "{\n"
                                 "    colour =  vec4(fs_result);\n"
                                 "}\n"
                                 "\n";
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return fragment_shader_source;
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type    The type of shader that is being tested
 * @param function_definition   Definition used to prepare shader
 * @param function_use          Use of definition
 * @param verification          Result verification
 **/
template <class API>
std::string SubroutineFunctionCalls1<API>::prepare_geometry_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &function_definition,
    const std::string &function_use, const std::string &verification)
{
    std::string geometry_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: /* Fall through */
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        geometry_shader_source = "layout(points)                           in;\n"
                                 "layout(triangle_strip, max_vertices = 4) out;\n"
                                 "\n"
                                 "in  float tes_result[];\n"
                                 "out float fs_result;\n"
                                 "\n"
                                 "void main()\n"
                                 "{\n"
                                 "    gl_Position  = vec4(-1, -1, 0, 1);\n"
                                 "    fs_result    = tes_result[0];\n"
                                 "    EmitVertex();\n"
                                 "    gl_Position  = vec4(-1, 1, 0, 1);\n"
                                 "    fs_result    = tes_result[0];\n"
                                 "    EmitVertex();\n"
                                 "    gl_Position  = vec4(1, -1, 0, 1);\n"
                                 "    fs_result    = tes_result[0];\n"
                                 "    EmitVertex();\n"
                                 "    gl_Position  = vec4(1, 1, 0, 1);\n"
                                 "    fs_result    = tes_result[0];\n"
                                 "    EmitVertex();\n"
                                 "}\n";
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
        geometry_shader_source = "layout(points)                           in;\n"
                                 "layout(triangle_strip, max_vertices = 4) out;\n"
                                 "\n"
                                 "out float fs_result;\n"
                                 "\n";

        /* User-defined function definition. */
        geometry_shader_source += function_definition;
        geometry_shader_source += "\n\n";

        /* Main function definition. */
        geometry_shader_source += shader_start;
        geometry_shader_source += function_use;
        geometry_shader_source += "\n\n";
        geometry_shader_source += verification;
        geometry_shader_source += "\n\n";
        geometry_shader_source += "\n    gl_Position  = vec4(-1, -1, 0, 1);\n"
                                  "    fs_result    = result;\n"
                                  "    EmitVertex();\n"
                                  "    gl_Position  = vec4(-1, 1, 0, 1);\n"
                                  "    fs_result    = result;\n"
                                  "    EmitVertex();\n"
                                  "    gl_Position  = vec4(1, -1, 0, 1);\n"
                                  "    fs_result    = result;\n"
                                  "    EmitVertex();\n"
                                  "    gl_Position  = vec4(1, 1, 0, 1);\n"
                                  "    fs_result    = result;\n"
                                  "    EmitVertex();\n"
                                  "}\n";
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return geometry_shader_source;
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type    The type of shader that is being tested
 * @param function_definition   Definition used to prepare shader
 * @param function_use          Use of definition
 * @param verification          Result verification
 **/
template <class API>
std::string SubroutineFunctionCalls1<API>::prepare_tess_ctrl_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &function_definition,
    const std::string &function_use, const std::string &verification)
{
    std::string tess_ctrl_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        tess_ctrl_shader_source = "layout(vertices = 1) out;\n"
                                  "\n"
                                  "out float tcs_result[];\n"
                                  "\n";

        /* User-defined function definition. */
        tess_ctrl_shader_source += function_definition;
        tess_ctrl_shader_source += "\n\n";

        /* Main function definition. */
        tess_ctrl_shader_source += shader_start;
        tess_ctrl_shader_source += function_use;
        tess_ctrl_shader_source += "\n\n";
        tess_ctrl_shader_source += verification;
        tess_ctrl_shader_source += "\n\n";
        tess_ctrl_shader_source += "    tcs_result[gl_InvocationID] = result;\n"
                                   "\n"
                                   "    gl_TessLevelOuter[0] = 1.0;\n"
                                   "    gl_TessLevelOuter[1] = 1.0;\n"
                                   "    gl_TessLevelOuter[2] = 1.0;\n"
                                   "    gl_TessLevelOuter[3] = 1.0;\n"
                                   "    gl_TessLevelInner[0] = 1.0;\n"
                                   "    gl_TessLevelInner[1] = 1.0;\n"
                                   "}\n";
        break;

    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        tess_ctrl_shader_source = default_tc_shader_source;
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return tess_ctrl_shader_source;
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type    The type of shader that is being tested
 * @param function_definition   Definition used to prepare shader
 * @param function_use          Use of definition
 * @param verification          Result verification
 **/
template <class API>
std::string SubroutineFunctionCalls1<API>::prepare_tess_eval_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &function_definition,
    const std::string &function_use, const std::string &verification)
{
    std::string tess_eval_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        break;

    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
        tess_eval_shader_source = "layout(isolines, point_mode) in;\n"
                                  "\n"
                                  "in  float tcs_result[];\n"
                                  "out float tes_result;\n"
                                  "\n"
                                  "void main()\n"
                                  "{\n"
                                  "    tes_result = tcs_result[0];\n"
                                  "}\n";
        break;

    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        tess_eval_shader_source = "layout(isolines, point_mode) in;\n"
                                  "\n"
                                  "out float tes_result;\n"
                                  "\n";

        /* User-defined function definition. */
        tess_eval_shader_source += function_definition;
        tess_eval_shader_source += "\n\n";

        /* Main function definition. */
        tess_eval_shader_source += shader_start;
        tess_eval_shader_source += function_use;
        tess_eval_shader_source += "\n\n";
        tess_eval_shader_source += verification;
        tess_eval_shader_source += "\n\n";
        tess_eval_shader_source += "    tes_result = result;\n"
                                   "}\n";
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return tess_eval_shader_source;
}

/** Prepare shader
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type    The type of shader that is being tested
 * @param function_definition   Definition used to prepare shader
 * @param function_use          Use of definition
 * @param verification          Result verification
 **/
template <class API>
std::string SubroutineFunctionCalls1<API>::prepare_vertex_shader(
    typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string &function_definition,
    const std::string &function_use, const std::string &verification)
{
    std::string vertex_shader_source;

    switch (tested_shader_type)
    {
    case TestCaseBase<API>::COMPUTE_SHADER_TYPE:
        break;

    case TestCaseBase<API>::FRAGMENT_SHADER_TYPE:
        vertex_shader_source = "/** GL_TRIANGLE_FAN-type quad vertex data. */\n"
                               "const vec4 vertex_positions[4] = vec4[4](vec4( 1.0, -1.0, 0.0, 1.0),\n"
                               "                                         vec4(-1.0, -1.0, 0.0, 1.0),\n"
                               "                                         vec4(-1.0,  1.0, 0.0, 1.0),\n"
                               "                                         vec4( 1.0,  1.0, 0.0, 1.0) );\n"
                               "\n"
                               "void main()\n"
                               "{\n"
                               "    gl_Position = vertex_positions[gl_VertexID];"
                               "}\n\n";
        break;

    case TestCaseBase<API>::GEOMETRY_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE:
    case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE:
        vertex_shader_source = default_vertex_shader_source;
        break;

    case TestCaseBase<API>::VERTEX_SHADER_TYPE:
        /* Vertex shader source. */
        vertex_shader_source = "out float fs_result;\n\n";
        vertex_shader_source += "/** GL_TRIANGLE_FAN-type quad vertex data. */\n"
                                "const vec4 vertex_positions[4] = vec4[4](vec4( 1.0, -1.0, 0.0, 1.0),\n"
                                "                                         vec4(-1.0, -1.0, 0.0, 1.0),\n"
                                "                                         vec4(-1.0,  1.0, 0.0, 1.0),\n"
                                "                                         vec4( 1.0,  1.0, 0.0, 1.0) );\n\n";

        /* User-defined function definition. */
        vertex_shader_source += function_definition;
        vertex_shader_source += "\n\n";

        /* Main function definition. */
        vertex_shader_source += shader_start;
        vertex_shader_source += function_use;
        vertex_shader_source += "\n\n";
        vertex_shader_source += verification;
        vertex_shader_source += "\n\n";
        vertex_shader_source += "    fs_result   = result;\n"
                                "    gl_Position = vertex_positions[gl_VertexID];\n";
        vertex_shader_source += shader_end;
        break;

    default:
        TCU_FAIL("Unrecognized shader object type.");
        break;
    }

    return vertex_shader_source;
}

/* Generates the shader source code for the InteractionFunctionCalls2
 * array tests, and attempts to build and execute test program.
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 */
template <class API>
void SubroutineFunctionCalls2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {
        VAR_TYPE_INT,  VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2,
        VAR_TYPE_VEC3, VAR_TYPE_VEC4,  VAR_TYPE_MAT2,  VAR_TYPE_MAT3,  VAR_TYPE_MAT4};
    static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {
        VAR_TYPE_INT,  VAR_TYPE_FLOAT,  VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, VAR_TYPE_IVEC4,
        VAR_TYPE_VEC2, VAR_TYPE_VEC3,   VAR_TYPE_VEC4,  VAR_TYPE_MAT2,  VAR_TYPE_MAT3,
        VAR_TYPE_MAT4, VAR_TYPE_DOUBLE, VAR_TYPE_DMAT2, VAR_TYPE_DMAT3, VAR_TYPE_DMAT4};
    static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const std::string iteration_loop_end      = "                }\n"
                                                "            }\n"
                                                "        }\n"
                                                "    }\n";
    const std::string iteration_loop_start    = "    for (uint a = 0u; a < 2u; a++)\n"
                                                "    {\n"
                                                "        for (uint b = 0u; b < 2u; b++)\n"
                                                "        {\n"
                                                "            for (uint c = 0u; c < 2u; c++)\n"
                                                "            {\n"
                                                "                for (uint d = 0u; d < 2u; d++)\n"
                                                "                {\n";
    const std::string multiplier_array        = "const int[] multiplier_array = int[]( 1,  2,  3,  4,  5,  6,  7,  8,\n"
                                                "                                     11, 12, 13, 14, 15, 16, 17, 18,\n"
                                                "                                     21, 22, 23, 24, 25, 26, 27, 28,\n"
                                                "                                     31, 32, 33, 34, 35, 36, 37, 38,\n"
                                                "                                     41, 42, 43, 44, 45, 46, 47, 48,\n"
                                                "                                     51, 52, 53, 54, 55, 56, 57, 58,\n"
                                                "                                     61, 62, 63, 64, 65, 66, 67, 68,\n"
                                                "                                     71, 72, 73, 74, 75, 76, 77, 78,\n"
                                                "                                     81, 82, 83, 84, 85, 86, 87, 88);\n";
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;
    const bool test_compute                   = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type);

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string function_definition;
            std::string function_use;
            std::string verification;

            function_definition += multiplier_array;

            function_definition += "// Subroutine types\n"
                                   "subroutine void inout_routine_type(inout ";
            function_definition += var_iterator->second.type;
            function_definition += " inout_array[2][2][2][2]);\n\n"
                                   "// Subroutine definitions\n"
                                   "subroutine(inout_routine_type) void original_routine(inout ";
            function_definition += var_iterator->second.type;
            function_definition += " inout_array[2][2][2][2]) {\n"
                                   "    uint i = 0u;\n";
            function_definition += iteration_loop_start;
            function_definition +=
                "                                   inout_array[a][b][c][d] *= " + var_iterator->second.iterator_type +
                "(multiplier_array[i % 64u]);\n";
            function_definition += "                                   i+= 1u;\n";
            function_definition += iteration_loop_end;
            function_definition += "}\n\n"
                                   "subroutine(inout_routine_type) void new_routine(inout ";
            function_definition += var_iterator->second.type;
            function_definition += " inout_array[2][2][2][2]) {\n"
                                   "    uint i = 0u;\n";
            function_definition += iteration_loop_start;
            function_definition +=
                "                                   inout_array[a][b][c][d] /= " + var_iterator->second.iterator_type +
                "(multiplier_array[i % 64u]);\n";
            function_definition += "                                   i+= 1u;\n";
            function_definition += iteration_loop_end;
            function_definition += "}\n\n"
                                   "// Subroutine uniform\n"
                                   "subroutine uniform inout_routine_type routine;\n";

            function_use += "    float result = 1.0;\n";
            function_use += "    uint iterator = 0u;\n";
            function_use += "    " + var_iterator->second.type + " my_array[2][2][2][2];\n";
            function_use += iteration_loop_start;
            function_use += "                                   my_array[a][b][c][d] = " +
                            var_iterator->second.variable_type_initializer2 + ";\n";
            function_use += iteration_loop_end;
            function_use += "    routine(my_array);";

            verification += iteration_loop_start;
            verification += "                                   if (my_array[a][b][c][d] " +
                            var_iterator->second.specific_element + "!= " + var_iterator->second.iterator_type +
                            "(multiplier_array[iterator % 64u]))\n"
                            "                                   {\n"
                            "                                       result = 0.0;\n"
                            "                                   }\n"
                            "                                   iterator += 1u;\n";
            verification += iteration_loop_end;

            if (false == test_compute)
            {
                this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, false,
                                        true);
                this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, true,
                                        false);
            }
            else
            {
                this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, false,
                                            true);
                this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, true,
                                            false);
            }

            /* Deallocate any resources used. */
            this->delete_objects();
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/* Generates the shader source code for the SubroutineArgumentAliasing1
 * array tests, attempts to build and execute test program
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 */
template <class API>
void SubroutineArgumentAliasing1<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {
        VAR_TYPE_INT,  VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2,
        VAR_TYPE_VEC3, VAR_TYPE_VEC4,  VAR_TYPE_MAT2,  VAR_TYPE_MAT3,  VAR_TYPE_MAT4};
    static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {
        VAR_TYPE_INT,  VAR_TYPE_FLOAT,  VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, VAR_TYPE_IVEC4,
        VAR_TYPE_VEC2, VAR_TYPE_VEC3,   VAR_TYPE_VEC4,  VAR_TYPE_MAT2,  VAR_TYPE_MAT3,
        VAR_TYPE_MAT4, VAR_TYPE_DOUBLE, VAR_TYPE_DMAT2, VAR_TYPE_DMAT3, VAR_TYPE_DMAT4};
    static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const std::string iteration_loop_end      = "                }\n"
                                                "            }\n"
                                                "        }\n"
                                                "    }\n";
    const std::string iteration_loop_start    = "    for (uint a = 0u; a < 2u; a++)\n"
                                                "    {\n"
                                                "        for (uint b = 0u; b < 2u; b++)\n"
                                                "        {\n"
                                                "            for (uint c = 0u; c < 2u; c++)\n"
                                                "            {\n"
                                                "                for (uint d = 0u; d < 2u; d++)\n"
                                                "                {\n";
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;
    const bool test_compute                   = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type);

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string function_definition;
            std::string function_use;
            std::string verification;

            function_definition += "// Subroutine types\n"
                                   "subroutine bool in_routine_type(";
            function_definition += var_iterator->second.type;
            function_definition += " x[2][2][2][2], ";
            function_definition += var_iterator->second.type;
            function_definition += " y[2][2][2][2]);\n\n"
                                   "// Subroutine definitions\n"
                                   "subroutine(in_routine_type) bool original_routine(";
            function_definition += var_iterator->second.type;
            function_definition += " x[2][2][2][2], ";
            function_definition += var_iterator->second.type;
            function_definition += " y[2][2][2][2])\n{\n";
            function_definition += iteration_loop_start;
            function_definition +=
                "                                   x[a][b][c][d] = " + var_iterator->second.type + "(123);\n";
            function_definition += iteration_loop_end;
            function_definition += "\n";
            function_definition += iteration_loop_start;
            function_definition += "                                   if(y[a][b][c][d]";
            if (var_iterator->second.type == "mat4") // mat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != float";
            }
            else if (var_iterator->second.type == "dmat4") // dmat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != double";
            }
            else
            {
                function_definition += " != ";
                function_definition += var_iterator->second.type;
            }
            function_definition += "(((a*8u)+(b*4u)+(c*2u)+d))) {return false;}\n";
            function_definition += iteration_loop_end;
            function_definition += "\n    return true;\n";
            function_definition += "}\n\n"
                                   "subroutine(in_routine_type) bool new_routine(";
            function_definition += var_iterator->second.type;
            function_definition += " x[2][2][2][2], ";
            function_definition += var_iterator->second.type;
            function_definition += " y[2][2][2][2])\n{\n";
            function_definition += iteration_loop_start;
            function_definition +=
                "                                   y[a][b][c][d] = " + var_iterator->second.type + "(123);\n";
            function_definition += iteration_loop_end;
            function_definition += "\n";
            function_definition += iteration_loop_start;
            function_definition += "                                   if(x[a][b][c][d]";
            if (var_iterator->second.type == "mat4") // mat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != float";
            }
            else if (var_iterator->second.type == "dmat4") // dmat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != double";
            }
            else
            {
                function_definition += " != ";
                function_definition += var_iterator->second.type;
            }
            function_definition += "(((a*8u)+(b*4u)+(c*2u)+d))) {return false;}\n";
            function_definition += iteration_loop_end;
            function_definition += "\n    return true;\n";
            function_definition += "}\n\n"
                                   "// Subroutine uniform\n"
                                   "subroutine uniform in_routine_type routine;\n";

            function_use += "    " + var_iterator->second.type + " z[2][2][2][2];\n";
            function_use += iteration_loop_start;
            function_use += "                                   z[a][b][c][d] = ";
            function_use += var_iterator->second.type;
            function_use += "(((a*8u)+(b*4u)+(c*2u)+d));\n";
            function_use += iteration_loop_end;

            verification = "    float result = 0.0;\n"
                           "    if(routine(z, z) == true)\n"
                           "    {\n"
                           "        result = 1.0;\n"
                           "    }\n"
                           "    else\n"
                           "    {\n"
                           "        result = 0.5;\n"
                           "    }\n";

            if (false == test_compute)
            {
                this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, false,
                                        false);
                this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, true,
                                        false);
            }
            else
            {
                this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, false,
                                            false);
                this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, true,
                                            false);
            }

            /* Deallocate any resources used. */
            this->delete_objects();
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/* Generates the shader source code for the SubroutineArgumentAliasing1
 * array tests, attempts to build and execute test program
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 */
template <class API>
void SubroutineArgumentAliasing2<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {
        VAR_TYPE_INT,  VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2,
        VAR_TYPE_VEC3, VAR_TYPE_VEC4,  VAR_TYPE_MAT2,  VAR_TYPE_MAT3,  VAR_TYPE_MAT4};
    static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {
        VAR_TYPE_INT,  VAR_TYPE_FLOAT,  VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, VAR_TYPE_IVEC4,
        VAR_TYPE_VEC2, VAR_TYPE_VEC3,   VAR_TYPE_VEC4,  VAR_TYPE_MAT2,  VAR_TYPE_MAT3,
        VAR_TYPE_MAT4, VAR_TYPE_DOUBLE, VAR_TYPE_DMAT2, VAR_TYPE_DMAT3, VAR_TYPE_DMAT4};
    static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const std::string iteration_loop_end      = "                }\n"
                                                "            }\n"
                                                "        }\n"
                                                "    }\n";
    const std::string iteration_loop_start    = "    for (uint a = 0u; a < 2u; a++)\n"
                                                "    {\n"
                                                "        for (uint b = 0u; b < 2u; b++)\n"
                                                "        {\n"
                                                "            for (uint c = 0u; c < 2u; c++)\n"
                                                "            {\n"
                                                "                for (uint d = 0u; d < 2u; d++)\n"
                                                "                {\n";
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;
    const bool test_compute                   = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type);

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string function_definition;
            std::string function_use;
            std::string verification;

            function_definition += "// Subroutine types\n"
                                   "subroutine bool inout_routine_type(inout ";
            function_definition += var_iterator->second.type;
            function_definition += " x[2][2][2][2], inout ";
            function_definition += var_iterator->second.type;
            function_definition += " y[2][2][2][2]);\n\n"
                                   "// Subroutine definitions\n"
                                   "subroutine(inout_routine_type) bool original_routine(inout ";
            function_definition += var_iterator->second.type;
            function_definition += " x[2][2][2][2], inout ";
            function_definition += var_iterator->second.type;
            function_definition += " y[2][2][2][2])\n{\n";
            function_definition += iteration_loop_start;
            function_definition +=
                "                                   x[a][b][c][d] = " + var_iterator->second.type + "(123);\n";
            function_definition += iteration_loop_end;
            function_definition += "\n";
            function_definition += iteration_loop_start;
            function_definition += "                                   if(y[a][b][c][d]";
            if (var_iterator->second.type == "mat4") // mat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != float";
            }
            else if (var_iterator->second.type == "dmat4") // dmat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != double";
            }
            else
            {
                function_definition += " != ";
                function_definition += var_iterator->second.type;
            }
            function_definition += "(((a*8u)+(b*4u)+(c*2u)+d))) {return false;}\n";
            function_definition += iteration_loop_end;
            function_definition += "\n    return true;\n";
            function_definition += "}\n\n"
                                   "subroutine(inout_routine_type) bool new_routine(inout ";
            function_definition += var_iterator->second.type;
            function_definition += " x[2][2][2][2], inout ";
            function_definition += var_iterator->second.type;
            function_definition += " y[2][2][2][2])\n{\n";
            function_definition += iteration_loop_start;
            function_definition +=
                "                                   y[a][b][c][d] = " + var_iterator->second.type + "(123);\n";
            function_definition += iteration_loop_end;
            function_definition += "\n";
            function_definition += iteration_loop_start;
            function_definition += "                                   if(x[a][b][c][d]";
            if (var_iterator->second.type == "mat4") // mat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != float";
            }
            else if (var_iterator->second.type == "dmat4") // dmat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != double";
            }
            else
            {
                function_definition += " != ";
                function_definition += var_iterator->second.type;
            }
            function_definition += "(((a*8u)+(b*4u)+(c*2u)+d))) {return false;}\n";
            function_definition += iteration_loop_end;
            function_definition += "\n    return true;\n";
            function_definition += "}\n\n"
                                   "// Subroutine uniform\n"
                                   "subroutine uniform inout_routine_type routine;\n";

            function_use += "    " + var_iterator->second.type + " z[2][2][2][2];\n";
            function_use += iteration_loop_start;
            function_use += "                                   z[a][b][c][d] = ";
            function_use += var_iterator->second.type;
            function_use += "(((a*8u)+(b*4u)+(c*2u)+d));\n";
            function_use += iteration_loop_end;

            verification = "    float result = 0.0;\n"
                           "    if(routine(z, z) == true)\n"
                           "    {\n"
                           "        result = 1.0;\n"
                           "    }\n"
                           "    else\n"
                           "    {\n"
                           "        result = 0.5;\n"
                           "    }\n";

            if (false == test_compute)
            {
                this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, false,
                                        false);
                this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, true,
                                        false);
            }
            else
            {
                this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, false,
                                            false);
                this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, true,
                                            false);
            }

            /* Deallocate any resources used. */
            this->delete_objects();
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/* Generates the shader source code for the SubroutineArgumentAliasing1
 * array tests, attempts to build and execute test program
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 */
template <class API>
void SubroutineArgumentAliasing3<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {
        VAR_TYPE_INT,  VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2,
        VAR_TYPE_VEC3, VAR_TYPE_VEC4,  VAR_TYPE_MAT2,  VAR_TYPE_MAT3,  VAR_TYPE_MAT4};
    static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {
        VAR_TYPE_INT,  VAR_TYPE_FLOAT,  VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, VAR_TYPE_IVEC4,
        VAR_TYPE_VEC2, VAR_TYPE_VEC3,   VAR_TYPE_VEC4,  VAR_TYPE_MAT2,  VAR_TYPE_MAT3,
        VAR_TYPE_MAT4, VAR_TYPE_DOUBLE, VAR_TYPE_DMAT2, VAR_TYPE_DMAT3, VAR_TYPE_DMAT4};
    static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const std::string iteration_loop_end      = "                }\n"
                                                "            }\n"
                                                "        }\n"
                                                "    }\n";
    const std::string iteration_loop_start    = "    for (uint a = 0u; a < 2u; a++)\n"
                                                "    {\n"
                                                "        for (uint b = 0u; b < 2u; b++)\n"
                                                "        {\n"
                                                "            for (uint c = 0u; c < 2u; c++)\n"
                                                "            {\n"
                                                "                for (uint d = 0u; d < 2u; d++)\n"
                                                "                {\n";
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;
    const bool test_compute                   = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type);

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string function_definition;
            std::string function_use;
            std::string verification;

            function_definition += "// Subroutine types\n"
                                   "subroutine bool out_routine_type(out ";
            function_definition += var_iterator->second.type;
            function_definition += " x[2][2][2][2], ";
            function_definition += var_iterator->second.type;
            function_definition += " y[2][2][2][2]);\n\n"
                                   "// Subroutine definitions\n"
                                   "subroutine(out_routine_type) bool original_routine(out ";
            function_definition += var_iterator->second.type;
            function_definition += " x[2][2][2][2], ";
            function_definition += var_iterator->second.type;
            function_definition += " y[2][2][2][2])\n{\n";
            function_definition += iteration_loop_start;
            function_definition +=
                "                                   x[a][b][c][d] = " + var_iterator->second.type + "(123);\n";
            function_definition += iteration_loop_end;
            function_definition += "\n";
            function_definition += iteration_loop_start;
            function_definition += "                                   if(y[a][b][c][d]";
            if (var_iterator->second.type == "mat4") // mat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != float";
            }
            else if (var_iterator->second.type == "dmat4") // dmat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != double";
            }
            else
            {
                function_definition += " != ";
                function_definition += var_iterator->second.type;
            }
            function_definition += "(((a*8u)+(b*4u)+(c*2u)+d))) {return false;}\n";
            function_definition += iteration_loop_end;
            function_definition += "\n    return true;\n";
            function_definition += "}\n\n"
                                   "subroutine(out_routine_type) bool new_routine(out ";
            function_definition += var_iterator->second.type;
            function_definition += " x[2][2][2][2], ";
            function_definition += var_iterator->second.type;
            function_definition += " y[2][2][2][2])\n{\n";
            function_definition += iteration_loop_start;
            function_definition +=
                "                                   x[a][b][c][d] = " + var_iterator->second.type + "(321);\n";
            function_definition += iteration_loop_end;
            function_definition += "\n";
            function_definition += iteration_loop_start;
            function_definition += "                                   if(y[a][b][c][d]";
            if (var_iterator->second.type == "mat4") // mat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != float";
            }
            else if (var_iterator->second.type == "dmat4") // dmat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != double";
            }
            else
            {
                function_definition += " != ";
                function_definition += var_iterator->second.type;
            }
            function_definition += "(((a*8u)+(b*4u)+(c*2u)+d))) {return false;}\n";
            function_definition += iteration_loop_end;
            function_definition += "\n    return true;\n";
            function_definition += "}\n\n"
                                   "// Subroutine uniform\n"
                                   "subroutine uniform out_routine_type routine;\n";

            function_use += "    " + var_iterator->second.type + " z[2][2][2][2];\n";
            function_use += iteration_loop_start;
            function_use += "                                   z[a][b][c][d] = ";
            function_use += var_iterator->second.type;
            function_use += "(((a*8u)+(b*4u)+(c*2u)+d));\n";
            function_use += iteration_loop_end;

            verification = "    float result = 0.0;\n"
                           "    if(routine(z, z) == true)\n"
                           "    {\n"
                           "        result = 1.0;\n"
                           "    }\n"
                           "    else\n"
                           "    {\n"
                           "        result = 0.5;\n"
                           "    }\n";

            if (false == test_compute)
            {
                this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, false,
                                        false);
                this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, true,
                                        false);
            }
            else
            {
                this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, false,
                                            false);
                this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, true,
                                            false);
            }

            /* Deallocate any resources used. */
            this->delete_objects();
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/* Generates the shader source code for the SubroutineArgumentAliasing1
 * array tests, attempts to build and execute test program
 *
 * @tparam API               Tested API descriptor
 *
 * @param tested_shader_type The type of shader that is being tested
 */
template <class API>
void SubroutineArgumentAliasing4<API>::test_shader_compilation(
    typename TestCaseBase<API>::TestShaderType tested_shader_type)
{
    static const glcts::test_var_type var_types_set_es[] = {
        VAR_TYPE_INT,  VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2,
        VAR_TYPE_VEC3, VAR_TYPE_VEC4,  VAR_TYPE_MAT2,  VAR_TYPE_MAT3,  VAR_TYPE_MAT4};
    static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]);

    static const glcts::test_var_type var_types_set_gl[] = {
        VAR_TYPE_INT,  VAR_TYPE_FLOAT,  VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, VAR_TYPE_IVEC4,
        VAR_TYPE_VEC2, VAR_TYPE_VEC3,   VAR_TYPE_VEC4,  VAR_TYPE_MAT2,  VAR_TYPE_MAT3,
        VAR_TYPE_MAT4, VAR_TYPE_DOUBLE, VAR_TYPE_DMAT2, VAR_TYPE_DMAT3, VAR_TYPE_DMAT4};
    static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]);

    const std::string iteration_loop_end      = "                }\n"
                                                "            }\n"
                                                "        }\n"
                                                "    }\n";
    const std::string iteration_loop_start    = "    for (uint a = 0u; a < 2u; a++)\n"
                                                "    {\n"
                                                "        for (uint b = 0u; b < 2u; b++)\n"
                                                "        {\n"
                                                "            for (uint c = 0u; c < 2u; c++)\n"
                                                "            {\n"
                                                "                for (uint d = 0u; d < 2u; d++)\n"
                                                "                {\n";
    const glcts::test_var_type *var_types_set = var_types_set_es;
    size_t num_var_types                      = num_var_types_es;
    const bool test_compute                   = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type);

    if (API::USE_DOUBLE)
    {
        var_types_set = var_types_set_gl;
        num_var_types = num_var_types_gl;
    }

    for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++)
    {
        _supported_variable_types_map_const_iterator var_iterator =
            supported_variable_types_map.find(var_types_set[var_type_index]);

        if (var_iterator != supported_variable_types_map.end())
        {
            std::string function_definition;
            std::string function_use;
            std::string verification;

            function_definition += "// Subroutine types\n"
                                   "subroutine bool out_routine_type(";
            function_definition += var_iterator->second.type;
            function_definition += " x[2][2][2][2], out ";
            function_definition += var_iterator->second.type;
            function_definition += " y[2][2][2][2]);\n\n"
                                   "// Subroutine definitions\n"
                                   "subroutine(out_routine_type) bool original_routine(";
            function_definition += var_iterator->second.type;
            function_definition += " x[2][2][2][2], out ";
            function_definition += var_iterator->second.type;
            function_definition += " y[2][2][2][2])\n{\n";
            function_definition += iteration_loop_start;
            function_definition +=
                "                                   y[a][b][c][d] = " + var_iterator->second.type + "(123);\n";
            function_definition += iteration_loop_end;
            function_definition += "\n";
            function_definition += iteration_loop_start;
            function_definition += "                                   if(x[a][b][c][d]";
            if (var_iterator->second.type == "mat4") // mat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != float";
            }
            else if (var_iterator->second.type == "dmat4") // dmat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != double";
            }
            else
            {
                function_definition += " != ";
                function_definition += var_iterator->second.type;
            }
            function_definition += "(((a*8u)+(b*4u)+(c*2u)+d))) {return false;}\n";
            function_definition += iteration_loop_end;
            function_definition += "\n    return true;\n";
            function_definition += "}\n\n"
                                   "subroutine(out_routine_type) bool new_routine(";
            function_definition += var_iterator->second.type;
            function_definition += " x[2][2][2][2], out ";
            function_definition += var_iterator->second.type;
            function_definition += " y[2][2][2][2])\n{\n";
            function_definition += iteration_loop_start;
            function_definition +=
                "                                   y[a][b][c][d] = " + var_iterator->second.type + "(321);\n";
            function_definition += iteration_loop_end;
            function_definition += "\n";
            function_definition += iteration_loop_start;
            function_definition += "                                   if(x[a][b][c][d]";
            if (var_iterator->second.type == "mat4") // mat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != float";
            }
            else if (var_iterator->second.type == "dmat4") // dmat4 comparison
            {
                function_definition += "[0][0]";
                function_definition += " != double";
            }
            else
            {
                function_definition += " != ";
                function_definition += var_iterator->second.type;
            }
            function_definition += "(((a*8u)+(b*4u)+(c*2u)+d))) {return false;}\n";
            function_definition += iteration_loop_end;
            function_definition += "\n    return true;\n";
            function_definition += "}\n\n"
                                   "// Subroutine uniform\n"
                                   "subroutine uniform out_routine_type routine;\n";

            function_use += "    " + var_iterator->second.type + " z[2][2][2][2];\n";
            function_use += iteration_loop_start;
            function_use += "                                   z[a][b][c][d] = ";
            function_use += var_iterator->second.type;
            function_use += "(((a*8u)+(b*4u)+(c*2u)+d));\n";
            function_use += iteration_loop_end;

            verification = "    float result = 0.0;\n"
                           "    if(routine(z, z) == true)\n"
                           "    {\n"
                           "        result = 1.0;\n"
                           "    }\n"
                           "    else\n"
                           "    {\n"
                           "        result = 0.5;\n"
                           "    }\n";

            if (false == test_compute)
            {
                this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, false,
                                        false);
                this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, true,
                                        false);
            }
            else
            {
                this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, false,
                                            false);
                this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, true,
                                            false);
            }

            /* Deallocate any resources used. */
            this->delete_objects();
        } /* if var_type iterator found */
        else
        {
            TCU_FAIL("Type not found.");
        }
    } /* for (int var_type_index = 0; ...) */
}

/** Instantiates all tests and adds them as children to the node
 *
 * @tparam API    Tested API descriptor
 *
 * @param context CTS context
 **/
template <class API>
void initTests(TestCaseGroup &group, glcts::Context &context)
{
    // Set up the map
    ArraysOfArrays::initializeMap<API>();

    group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsPrimitive<API>(context));
    group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsStructTypes1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsStructTypes2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsStructTypes3<API>(context));
    group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsStructTypes4<API>(context));
    group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsTypenameStyle1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsTypenameStyle2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsTypenameStyle3<API>(context));
    group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsTypenameStyle4<API>(context));
    group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsTypenameStyle5<API>(context));
    group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsFunctionParams<API>(context));
    group.addChild(new glcts::ArraysOfArrays::sized_declarations_invalid_sizes1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::sized_declarations_invalid_sizes2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::sized_declarations_invalid_sizes3<API>(context));
    group.addChild(new glcts::ArraysOfArrays::sized_declarations_invalid_sizes4<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclConstructors1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclConstructors2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclUnsizedConstructors<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclConst<API>(context));

    group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclInvalidConstructors1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclInvalidConstructors2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclInvalidConstructors3<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclInvalidConstructors4<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclConstructorSizing1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclConstructorSizing2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclStructConstructors<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclUnsizedArrays1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclUnsizedArrays2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclUnsizedArrays3<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclUnsizedArrays4<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsAssignment1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsAssignment2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsAssignment3<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsTypeRestrictions1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsTypeRestrictions2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsIndexingScalar1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsIndexingScalar2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsIndexingScalar3<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsIndexingScalar4<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsIndexingArray1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsIndexingArray2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsIndexingArray3<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsDynamicIndexing1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsDynamicIndexing2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsEquality1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsEquality2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsLength1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsLength2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsLength3<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsInvalid1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::ExpressionsInvalid2<API>(context));

    group.addChild(new glcts::ArraysOfArrays::InteractionFunctionCalls1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::InteractionFunctionCalls2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::InteractionArgumentAliasing1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::InteractionArgumentAliasing2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::InteractionArgumentAliasing3<API>(context));
    group.addChild(new glcts::ArraysOfArrays::InteractionArgumentAliasing4<API>(context));
    group.addChild(new glcts::ArraysOfArrays::InteractionArgumentAliasing5<API>(context));
    group.addChild(new glcts::ArraysOfArrays::InteractionArgumentAliasing6<API>(context));

    group.addChild(new glcts::ArraysOfArrays::InteractionUniforms1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::InteractionUniforms2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::InteractionUniformBuffers1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::InteractionUniformBuffers2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::InteractionUniformBuffers3<API>(context));
    group.addChild(new glcts::ArraysOfArrays::InteractionInterfaceArrays1<API>(context));
    group.addChild(new glcts::ArraysOfArrays::InteractionInterfaceArrays2<API>(context));
    group.addChild(new glcts::ArraysOfArrays::InteractionInterfaceArrays3<API>(context));
    group.addChild(new glcts::ArraysOfArrays::InteractionInterfaceArrays4<API>(context));

    if (API::USE_STORAGE_BLOCK)
    {
        group.addChild(new glcts::ArraysOfArrays::InteractionStorageBuffers1<API>(context));
        group.addChild(new glcts::ArraysOfArrays::InteractionStorageBuffers2<API>(context));
        group.addChild(new glcts::ArraysOfArrays::InteractionStorageBuffers3<API>(context));
    }

    if (API::USE_ATOMIC)
    {
        group.addChild(new glcts::ArraysOfArrays::AtomicDeclarationTest<API>(context));
        group.addChild(new glcts::ArraysOfArrays::AtomicUsageTest<API>(context));
    }

    if (API::USE_SUBROUTINE)
    {
        group.addChild(new glcts::ArraysOfArrays::SubroutineFunctionCalls1<API>(context));
        group.addChild(new glcts::ArraysOfArrays::SubroutineFunctionCalls2<API>(context));
        group.addChild(new glcts::ArraysOfArrays::SubroutineArgumentAliasing1<API>(context));
        group.addChild(new glcts::ArraysOfArrays::SubroutineArgumentAliasing2<API>(context));
        group.addChild(new glcts::ArraysOfArrays::SubroutineArgumentAliasing3<API>(context));
        group.addChild(new glcts::ArraysOfArrays::SubroutineArgumentAliasing4<API>(context));
    }
}
} /* namespace ArraysOfArrays */

/** Constructor
 *
 * @param context CTS context
 **/
ArrayOfArraysTestGroup::ArrayOfArraysTestGroup(Context &context)
    : TestCaseGroup(context, "arrays_of_arrays", "Groups all tests that verify 'arrays of arrays' functionality.")
{
    /* Left blank on purpose */
}

/* Instantiates all tests and adds them as children to the node */
void ArrayOfArraysTestGroup::init(void)
{
    ArraysOfArrays::initTests<ArraysOfArrays::Interface::ES>(*this, m_context);
}

/** Constructor
 *
 * @param context CTS context
 **/
ArrayOfArraysTestGroupGL::ArrayOfArraysTestGroupGL(Context &context)
    : TestCaseGroup(context, "arrays_of_arrays_gl", "Groups all tests that verify 'arrays of arrays' functionality.")
{
    /* Left blank on purpose */
}

/* Instantiates all tests and adds them as children to the node */
void ArrayOfArraysTestGroupGL::init(void)
{
    ArraysOfArrays::initTests<ArraysOfArrays::Interface::GL>(*this, m_context);
}
} /* namespace glcts */