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

#include <map>

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

namespace glcts
{
typedef enum {
	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,
	/** List of all supported interface resource types. */
	VAR_TYPE_IMAGEBUFFER,
	VAR_TYPE_IIMAGEBUFFER,
	VAR_TYPE_UIMAGEBUFFER,
	VAR_TYPE_SAMPLERBUFFER,
	VAR_TYPE_ISAMPLERBUFFER,
	VAR_TYPE_USAMPLERBUFFER,
	/** List of all supported opaque 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,
	/* Double types */
	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,
} test_var_type;

struct var_descriptor
{
	std::string type;
	std::string precision;
	std::string initializer_with_ones;
	std::string initializer_with_zeroes;
	std::string iterator_initialization;
	std::string iterator_type;
	std::string specific_element;
	std::string variable_type_initializer1;
	std::string variable_type_initializer2;
	std::string coord_param_for_texture_function;
	std::string type_of_result_of_texture_function;
};

// This iterator and map are used to simplify the lookup of type names, initialisation
//  values, etc., associated with each of the types used within the array tests
typedef std::map<glcts::test_var_type, var_descriptor> _supported_variable_types_map;
typedef _supported_variable_types_map::const_iterator _supported_variable_types_map_const_iterator;

/* Groups all tests that verify "arrays of arrays" functionality */
class ArrayOfArraysTestGroup : public glcts::TestCaseGroup
{
public:
	/* Public methods */
	ArrayOfArraysTestGroup(Context& context);

	virtual void init(void);
};

/* Groups all tests that verify "arrays of arrays" functionality */
class ArrayOfArraysTestGroupGL : public glcts::TestCaseGroup
{
public:
	/* Public methods */
	ArrayOfArraysTestGroupGL(Context& context);

	virtual void init(void);
};

namespace ArraysOfArrays
{
namespace Interface
{
/** Represents ES 3.1 core capabilities **/
struct ES
{
	enum
	{
		ALLOW_UNSIZED_DECLARATION = 0
	};
	enum
	{
		ALLOW_A_OF_A_ON_INTERFACE_BLOCKS = 0
	};
	enum
	{
		ALLOW_IN_OUT_INTERFACE_BLOCKS = 0
	};
	enum
	{
		USE_ALL_SHADER_STAGES = 0
	};
	enum
	{
		USE_ATOMIC = 0
	};
	enum
	{
		USE_DOUBLE = 0
	};
	enum
	{
		USE_SUBROUTINE = 0
	};
	enum
	{
		USE_STORAGE_BLOCK = 0
	};

	static const size_t			MAX_ARRAY_DIMENSIONS;
	static const test_var_type* var_types;
	static const size_t			n_var_types;

	static const char* shader_version_gpu5;
	static const char* shader_version;

	static const char* test_group_name;
};

/** Represents GL 4.3 core capabilities **/
struct GL
{
	enum
	{
		ALLOW_UNSIZED_DECLARATION = 1
	};
	enum
	{
		ALLOW_A_OF_A_ON_INTERFACE_BLOCKS = 1
	};
	enum
	{
		ALLOW_IN_OUT_INTERFACE_BLOCKS = 1
	};
	enum
	{
		USE_ALL_SHADER_STAGES = 1
	};
	enum
	{
		USE_ATOMIC = 1
	};
	enum
	{
		USE_DOUBLE = 1
	};
	enum
	{
		USE_SUBROUTINE = 1
	};
	enum
	{
		USE_STORAGE_BLOCK = 1
	};

	static const size_t			MAX_ARRAY_DIMENSIONS;
	static const test_var_type* var_types;
	static const size_t			n_var_types;

	static const char* shader_version_gpu5;
	static const char* shader_version;
};
} /* Interface */

/** Base test class for all arrays_of_arrays tests
 **/
template <class API>
class TestCaseBase : public tcu::TestCase
{
public:
	TestCaseBase(Context& context, const char* name, const char* description);

	virtual ~TestCaseBase(void)
	{
	}

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

protected:
	/* Protected declarations */
	enum TestShaderType
	{
		FRAGMENT_SHADER_TYPE,
		VERTEX_SHADER_TYPE,
		COMPUTE_SHADER_TYPE,
		GEOMETRY_SHADER_TYPE,
		TESSELATION_CONTROL_SHADER_TYPE,
		TESSELATION_EVALUATION_SHADER_TYPE,

		/* */
		SHADER_TYPE_LAST
	};

	/* Protected methods */
	virtual std::string extend_string(std::string base_string, std::string sub_script, size_t number_of_elements);

	virtual glw::GLint compile_shader_and_get_compilation_result(
		const std::string& tested_snippet, typename TestCaseBase<API>::TestShaderType tested_shader_type,
		bool require_gpu_shader5 = false);

	virtual tcu::TestNode::IterateResult execute_negative_test(
		typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& shader_source);

	virtual tcu::TestNode::IterateResult execute_positive_test(const std::string& vertex_shader_source,
															   const std::string& fragment_shader_source,
															   bool delete_generated_objects, bool require_gpu_shader5);

	virtual tcu::TestNode::IterateResult 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);

	virtual void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type) = 0;

	/* Protected fields */
	Context&   context_id;
	glw::GLint program_object_id;

private:
	/* Private fields */
	glw::GLint compute_shader_object_id;
	glw::GLint fragment_shader_object_id;
	glw::GLint geometry_shader_object_id;
	glw::GLint tess_ctrl_shader_object_id;
	glw::GLint tess_eval_shader_object_id;
	glw::GLint vertex_shader_object_id;
};

template <class API>
class SizedDeclarationsPrimitive : public TestCaseBase<API>
{
public:
	/* Public methods */
	SizedDeclarationsPrimitive(Context& context)
		: TestCaseBase<API>(context, "SizedDeclarationsPrimitive",
							" Verify that declarations of variables containing between 2 and 8\n"
							" sized dimensions of each primitive type are permitted.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~SizedDeclarationsPrimitive()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class SizedDeclarationsStructTypes1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	SizedDeclarationsStructTypes1(Context& context)
		: TestCaseBase<API>(context, "SizedDeclarationsStructTypes1",
							" Declare a structure type containing both ints and floats, and verify\n"
							" that variables having between 2 and 8 sized dimensions of this type\n"
							" can be declared.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~SizedDeclarationsStructTypes1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class SizedDeclarationsStructTypes2 : public TestCaseBase<API>
{
public:
	/* Public methods */
	SizedDeclarationsStructTypes2(Context& context)
		: TestCaseBase<API>(context, "SizedDeclarationsStructTypes2",
							" Verify that a single declaration containing multiple\n"
							" variables with different numbers of array dimensions is accepted,\n"
							" e.g.  float [2][2] x2, x3[2], x4[2][2], etc) with each variable\n"
							" having between two and eight dimensions when there are\n"
							" declarations within the structure body.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~SizedDeclarationsStructTypes2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class SizedDeclarationsStructTypes3 : public TestCaseBase<API>
{
public:
	/* Public methods */
	SizedDeclarationsStructTypes3(Context& context)
		: TestCaseBase<API>(context, "SizedDeclarationsStructTypes3",
							" Declare a structure type containing both ints and floats, and verify\n"
							" that variables having between 2 and 8 sized dimensions of this type\n"
							" can be declared, with a structure containing an array.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~SizedDeclarationsStructTypes3()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class SizedDeclarationsStructTypes4 : public TestCaseBase<API>
{
public:
	/* Public methods */
	SizedDeclarationsStructTypes4(Context& context)
		: TestCaseBase<API>(context, "SizedDeclarationsStructTypes4",
							" Declare a structure type containing an array, and verify\n"
							" that variables having between 2 and 8 sized dimensions of this type\n"
							" can be declared when the structure  definition is included in the \n"
							" variable definition.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~SizedDeclarationsStructTypes4()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class SizedDeclarationsTypenameStyle1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	SizedDeclarationsTypenameStyle1(Context& context)
		: TestCaseBase<API>(context, "SizedDeclarationsTypenameStyle1",
							" Verify that an 8-dimensional array of floats can be declared with\n"
							" any placement of the brackets (e.g. float[2]\n"
							" x[2][2][2][2][2][2][2], float [2][2] x [2][2][2][2][2][2], etc) (9\n"
							" cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~SizedDeclarationsTypenameStyle1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class SizedDeclarationsTypenameStyle2 : public TestCaseBase<API>
{
public:
	/* Public methods */
	SizedDeclarationsTypenameStyle2(Context& context)
		: TestCaseBase<API>(context, "SizedDeclarationsTypenameStyle2",
							" Verify that a single declaration containing multiple\n"
							" variables with different numbers of array dimensions is accepted,\n"
							" e.g.  float [2][2] x2, x3[2], x4[2][2], etc) with each variable\n"
							" having between two and eight dimensions. Repeat these tests for\n"
							" declarations within a structure body.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~SizedDeclarationsTypenameStyle2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class SizedDeclarationsTypenameStyle3 : public TestCaseBase<API>
{
public:
	/* Public methods */
	SizedDeclarationsTypenameStyle3(Context& context)
		: TestCaseBase<API>(context, "SizedDeclarationsTypenameStyle3",
							" Verify that a single declaration, within a structure body,\n"
							" is accepted when it contains multiple variables with different\n"
							" numbers of array dimensions, \n"
							" e.g.  float [2][2] x2, x3[2], x4[2][2], etc), with each variable\n"
							" having between two and eight dimensions.\n"
							" The variables should be declared within a structure body.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~SizedDeclarationsTypenameStyle3()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class SizedDeclarationsTypenameStyle4 : public TestCaseBase<API>
{
public:
	/* Public methods */
	SizedDeclarationsTypenameStyle4(Context& context)
		: TestCaseBase<API>(context, "SizedDeclarationsTypenameStyle4",
							" Verify that an 8-dimensional array of floats can be declared with\n"
							" any placement of the brackets (e.g. float[2]\n"
							" x[2][2][2][2][2][2][2], float [2][2] x [2][2][2][2][2][2], etc) (9\n"
							" cases) within a structure body.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~SizedDeclarationsTypenameStyle4()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class SizedDeclarationsTypenameStyle5 : public TestCaseBase<API>
{
public:
	/* Public methods */
	SizedDeclarationsTypenameStyle5(Context& context)
		: TestCaseBase<API>(context, "SizedDeclarationsTypenameStyle5",
							" Verify that a single declaration containing multiple\n"
							" variables with different numbers of array dimensions is accepted,\n"
							" within a structure body\n"
							" e.g.  float [2][2] x2, x3[2], x4[2][2], etc) with each variable\n"
							" having between two and eight dimensions.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~SizedDeclarationsTypenameStyle5()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class SizedDeclarationsFunctionParams : public TestCaseBase<API>
{
public:
	/* Public methods */
	SizedDeclarationsFunctionParams(Context& context)
		: TestCaseBase<API>(context, "SizedDeclarationsFunctionParams",
							" Declare a function having eight parameters, each a float array\n"
							" with a different number of dimensions between 1 and 8, and verify\n"
							" that the compiler accepts this. Declare a variable with matching\n"
							" shape for each parameter, and verify that the function can be\n"
							" called with these variables as arguments. Interchange each pair\n"
							" of arguments and verify that the shader is correctly rejected due\n"
							" to mismatched arguments (28 total cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~SizedDeclarationsFunctionParams()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class sized_declarations_invalid_sizes1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	sized_declarations_invalid_sizes1(Context& context)
		: TestCaseBase<API>(context, "sized_declarations_invalid_sizes1",
							" Correctly reject variable declarations, having 4 dimensions, for\n"
							" which any combination of dimensions are declared with zero-size\n"
							" (16 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~sized_declarations_invalid_sizes1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class sized_declarations_invalid_sizes2 : public TestCaseBase<API>
{
public:
	/* Public methods */
	sized_declarations_invalid_sizes2(Context& context)
		: TestCaseBase<API>(context, "sized_declarations_invalid_sizes2",
							" Correctly reject variable declarations, having 4 dimensions, for\n"
							" which any combination of dimensions are declared with size -1\n"
							" (16 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~sized_declarations_invalid_sizes2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class sized_declarations_invalid_sizes3 : public TestCaseBase<API>
{
public:
	/* Public methods */
	sized_declarations_invalid_sizes3(Context& context)
		: TestCaseBase<API>(context, "sized_declarations_invalid_sizes3",
							" Correctly reject variable declarations, having 4 dimensions, for\n"
							" which any combination of dimensions are declared with a\n"
							" non-constant (16 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~sized_declarations_invalid_sizes3()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class sized_declarations_invalid_sizes4 : public TestCaseBase<API>
{
public:
	/* Public methods */
	sized_declarations_invalid_sizes4(Context& context)
		: TestCaseBase<API>(context, "sized_declarations_invalid_sizes4",
							" Correctly reject modifications of a variable declaration of\n"
							" 4 dimensions (e.g. float x[2][2][2][2]), in which\n"
							" each adjacent pair '][' is replaced by the sequence operator\n"
							" (e.g. float x[2,2][2][2]) (6 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~sized_declarations_invalid_sizes4()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ConstructorsAndUnsizedDeclConstructors1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ConstructorsAndUnsizedDeclConstructors1(Context& context)
		: TestCaseBase<API>(context, "ConstructorsAndUnsizedDeclConstructors1",
							" Verifies that constructors for arrays of between 2 and 8 dimensions\n"
							" are accepted as isolated expressions for each non-opaque primitive\n"
							" type (7 cases per primitive type).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ConstructorsAndUnsizedDeclConstructors1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
	std::string recursively_initialise(std::string var_type, size_t dimension_index, std::string init_string);
};

template <class API>
class ConstructorsAndUnsizedDeclConstructors2 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ConstructorsAndUnsizedDeclConstructors2(Context& context)
		: TestCaseBase<API>(context, "ConstructorsAndUnsizedDeclConstructors2",
							" Correctly reject any attempt to pass arguments to a\n"
							" 2 dimensional float array constructor which has matching scalar\n"
							" count, but different array shape or dimensionality to the array's\n"
							" indexed type e.g. float[2][2](float[4](1,2,3,4)),\n"
							" float[2][2](float[1][4](float[4](1,2,3,4))) (2 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ConstructorsAndUnsizedDeclConstructors2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ConstructorsAndUnsizedDeclUnsizedConstructors : public TestCaseBase<API>
{
public:
	/* Public methods */
	ConstructorsAndUnsizedDeclUnsizedConstructors(Context& context)
		: TestCaseBase<API>(context, "ConstructorsAndUnsizedDeclUnsizedConstructors",
							" Verifies that any of the array dimensions, or any combination of\n"
							" dimensions, may be omitted for a 4-dimensional float array\n"
							" constructor (the sizes on its nested constructors may be\n"
							" consistently omitted or present, and need not be manipulated\n"
							" between cases) (e.g. float[][][2][](float[][][](float[][] etc))\n"
							" (16 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ConstructorsAndUnsizedDeclUnsizedConstructors()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ConstructorsAndUnsizedDeclConst : public TestCaseBase<API>
{
public:
	/* Public methods */
	ConstructorsAndUnsizedDeclConst(Context& context)
		: TestCaseBase<API>(context, "ConstructorsAndUnsizedDeclConst",
							" Verifies that multi-dimensional arrays can be declared as const\n"
							" using nested constructors to initialize inner dimensions\n"
							" e.g. const float[2][2] x = float[2][2](float[2](1,2),float[2](3,4)).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ConstructorsAndUnsizedDeclConst()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ConstructorsAndUnsizedDeclInvalidConstructors1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ConstructorsAndUnsizedDeclInvalidConstructors1(Context& context)
		: TestCaseBase<API>(context, "ConstructorsAndUnsizedDeclInvalidConstructors1",
							" Correctly reject any attempt to call array constructors for\n"
							" 2-dimensional arrays of any opaque type.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ConstructorsAndUnsizedDeclInvalidConstructors1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ConstructorsAndUnsizedDeclInvalidConstructors2 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ConstructorsAndUnsizedDeclInvalidConstructors2(Context& context)
		: TestCaseBase<API>(context, "ConstructorsAndUnsizedDeclInvalidConstructors2",
							" Correctly reject 3-dimensional int array constructor calls\n"
							" for which any dimension or combination of dimensions is\n"
							" given as zero (see sec(i) - 8 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ConstructorsAndUnsizedDeclInvalidConstructors2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ConstructorsAndUnsizedDeclInvalidConstructors3 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ConstructorsAndUnsizedDeclInvalidConstructors3(Context& context)
		: TestCaseBase<API>(context, "ConstructorsAndUnsizedDeclInvalidConstructors3",
							" Correctly reject 3-dimensional int array constructor calls\n"
							" for which any dimension or combination of dimensions is\n"
							" given as -1 (see sec(i) - 8 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ConstructorsAndUnsizedDeclInvalidConstructors3()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ConstructorsAndUnsizedDeclInvalidConstructors4 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ConstructorsAndUnsizedDeclInvalidConstructors4(Context& context)
		: TestCaseBase<API>(context, "ConstructorsAndUnsizedDeclInvalidConstructors4",
							" Correctly reject 3-dimensional int array constructor calls\n"
							" for which any dimension or combination of dimensions is\n"
							" given by a non-constant variable (8 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ConstructorsAndUnsizedDeclInvalidConstructors4()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ConstructorsAndUnsizedDeclConstructorSizing1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ConstructorsAndUnsizedDeclConstructorSizing1(Context& context)
		: TestCaseBase<API>(context, "ConstructorsAndUnsizedDeclConstructorSizing1",
							" Verifies that arrays of 4 dimensions can be declared with any\n"
							" combination of dimension sizes omitted, provided a valid\n"
							" constructor is used as an initializer (15 cases per non-opaque\n"
							" primitive type).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ConstructorsAndUnsizedDeclConstructorSizing1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ConstructorsAndUnsizedDeclConstructorSizing2 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ConstructorsAndUnsizedDeclConstructorSizing2(Context& context)
		: TestCaseBase<API>(context, "ConstructorsAndUnsizedDeclConstructorSizing2",
							" Verifies that a sequence of arrays from 2 to 8 dimensions can\n"
							" be declared in a single statement\n"
							" (e.g. float[] x=float[](4,5), y[]=float[][](float[](4)), z[][]...).\n"
							" The size of the dimensions should vary between the cases\n"
							" of this test (e.g. in the previous case, we have\n"
							" float x[2] and float y[1][1]).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ConstructorsAndUnsizedDeclConstructorSizing2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ConstructorsAndUnsizedDeclStructConstructors : public TestCaseBase<API>
{
public:
	/* Public methods */
	ConstructorsAndUnsizedDeclStructConstructors(Context& context)
		: TestCaseBase<API>(context, "ConstructorsAndUnsizedDeclStructConstructors",
							" Declare a user type (struct) and verify that arrays of between 2\n"
							" and 8 dimensions can be declared without explicit sizes, and\n"
							" initialized from constructors (7 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ConstructorsAndUnsizedDeclStructConstructors()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
	std::string recursively_initialise(std::string var_type, size_t dimension_index, std::string init_string);
};

template <class API>
class ConstructorsAndUnsizedDeclUnsizedArrays1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ConstructorsAndUnsizedDeclUnsizedArrays1(Context& context)
		: TestCaseBase<API>(context, "ConstructorsAndUnsizedDeclUnsizedArrays1",
							" Correctly reject unsized declarations of variables between 2 and 8\n"
							" dimensions for which an initializer is not present.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ConstructorsAndUnsizedDeclUnsizedArrays1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ConstructorsAndUnsizedDeclUnsizedArrays2 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ConstructorsAndUnsizedDeclUnsizedArrays2(Context& context)
		: TestCaseBase<API>(context, "ConstructorsAndUnsizedDeclUnsizedArrays2",
							" Correctly reject unsized declarations where some elements are\n"
							" lacking initializers (e.g. float[] x=float[](1), y).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ConstructorsAndUnsizedDeclUnsizedArrays2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ConstructorsAndUnsizedDeclUnsizedArrays3 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ConstructorsAndUnsizedDeclUnsizedArrays3(Context& context)
		: TestCaseBase<API>(context, "ConstructorsAndUnsizedDeclUnsizedArrays3",
							" Correctly reject a declaration which initializes a\n"
							" multi-dimensional array from a matrix type,\n"
							" e.g. (float[][] x = mat4(0)).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ConstructorsAndUnsizedDeclUnsizedArrays3()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ConstructorsAndUnsizedDeclUnsizedArrays4 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ConstructorsAndUnsizedDeclUnsizedArrays4(Context& context)
		: TestCaseBase<API>(context, "ConstructorsAndUnsizedDeclUnsizedArrays4",
							" Declare a user type containing an unsized array\n"
							" (e.g. struct foo { float[][] x; }) and verify that the shader is\n"
							" correctly rejected.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ConstructorsAndUnsizedDeclUnsizedArrays4()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsAssignment1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsAssignment1(Context& context)
		: TestCaseBase<API>(context, "ExpressionsAssignment1",
							" Declare two variables of matching array size, having between 2 and\n"
							" 8 dimensions, and verify that the value of one can be assigned to\n"
							" the other without error (7 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsAssignment1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
	std::string recursively_initialise(std::string var_type, size_t dimension_index, std::string init_string);
};

template <class API>
class ExpressionsAssignment2 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsAssignment2(Context& context)
		: TestCaseBase<API>(context, "ExpressionsAssignment2",
							" Correctly reject assignment of variables of differing numbers of array\n"
							" dimensions (between 1 and 4) to one another (6 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsAssignment2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsAssignment3 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsAssignment3(Context& context)
		: TestCaseBase<API>(context, "ExpressionsAssignment3",
							" Correctly reject assignment of variables of 4 dimensions and differing\n"
							" array size to one another, where all combinations of each dimension\n"
							" matching or not matching are tested (15 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsAssignment3()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsTypeRestrictions1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsTypeRestrictions1(Context& context)
		: TestCaseBase<API>(context, "ExpressionsTypeRestrictions1",
							" Declare two 2-dimensional arrays of a sampler type and verify that\n"
							" one cannot be assigned to the other.\n"
							" Repeat the test for each opaque type.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsTypeRestrictions1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsTypeRestrictions2 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsTypeRestrictions2(Context& context)
		: TestCaseBase<API>(context, "ExpressionsTypeRestrictions2",
							" For each opaque type, verify that structures containing \n"
							" two 2-dimensional arrays of that sampler type\n"
							" cannot be assigned to each other.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsTypeRestrictions2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsIndexingScalar1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsIndexingScalar1(Context& context)
		: TestCaseBase<API>(context, "ExpressionsIndexingScalar1",
							" Assign to each scalar element of a 4 dimensional array\n"
							" float x[1][2][3][4] (24 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsIndexingScalar1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsIndexingScalar2 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsIndexingScalar2(Context& context)
		: TestCaseBase<API>(context, "ExpressionsIndexingScalar2",
							" Correctly reject indexing the array with any combination\n"
							" of indices given as -1 (15 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsIndexingScalar2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsIndexingScalar3 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsIndexingScalar3(Context& context)
		: TestCaseBase<API>(context, "ExpressionsIndexingScalar3",
							" Correctly reject indexing the array with any combination\n"
							" of indices given as 4 (15 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsIndexingScalar3()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsIndexingScalar4 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsIndexingScalar4(Context& context)
		: TestCaseBase<API>(context, "ExpressionsIndexingScalar4",
							" Correctly reject any attempt to index a 4-dimensional array with\n"
							" any combination of missing array index expressions\n"
							" (e.g. x[][0][0][]) - (15 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsIndexingScalar4()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsIndexingArray1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsIndexingArray1(Context& context)
		: TestCaseBase<API>(context, "ExpressionsIndexingArray1",
							" Assign to each dimension of an 8 dimensional, single-element array\n"
							" with an appropriate constructor (e.g. float\n"
							" x[1][1][1][1][1][1][1][1];\n"
							" x[0] = float[1][1][1][1][1][1][1](1);\n"
							" x[0][0] = etc) - (8 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsIndexingArray1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsIndexingArray2 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsIndexingArray2(Context& context)
		: TestCaseBase<API>(context, "ExpressionsIndexingArray2",
							" Declare two 8 dimensional, single-element arrays, and assign to\n"
							" each dimension of one from the matching sub_scripting of the other\n"
							" (e.g. x[0] = y[0]; x[0][0] = y[0][0]; etc.) (8 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsIndexingArray2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
	std::string recursively_initialise(std::string var_type, size_t dimension_index, std::string init_string);
};

template <class API>
class ExpressionsIndexingArray3 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsIndexingArray3(Context& context)
		: TestCaseBase<API>(context, "ExpressionsIndexingArray3",
							" Correctly reject use of ivecn to index an n-dimensional array -\n"
							" e.g. float x[2][2][2][2]; x[ivec4(0)] = 1; (3 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsIndexingArray3()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsDynamicIndexing1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsDynamicIndexing1(Context& context)
		: TestCaseBase<API>(context, "ExpressionsDynamicIndexing1",
							" Verifies that any mixture of constant, uniform and dynamic expressions\n"
							" can be used as the array index expression, in any combination, for\n"
							" each dimension of a 2 dimensional array (16 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsDynamicIndexing1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsDynamicIndexing2 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsDynamicIndexing2(Context& context)
		: TestCaseBase<API>(context, "ExpressionsDynamicIndexing2",
							" Correctly reject any attempt to index 4-dimensional arrays of opaque\n"
							" types with any combination of non-constant expressions\n"
							" (e.g. x[0][y][0][y] etc for non-const y) - (15 cases per type).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsDynamicIndexing2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsEquality1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsEquality1(Context& context)
		: TestCaseBase<API>(context, "ExpressionsEquality1",
							" Verifies that two 4-dimensional arrays of matching primitive\n"
							" type can be correctly compared for equality and inequality, when\n"
							" they differ independently in each component or combination of\n"
							" components (e.g. x = float[][](float[](1,1), float[](1,1)); y =\n"
							" float[][](float[](2,1), float[](1,1)); return x == y;) - (16\n"
							" cases per primitive type).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsEquality1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsEquality2 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsEquality2(Context& context)
		: TestCaseBase<API>(context, "ExpressionsEquality2",
							" Verifies that two 4-dimensional arrays of matching user (struct)\n"
							" types can be correctly compared for equality and inequality, when\n"
							" they differ independently in each component or combination of\n"
							" components - (16 cases per primitive type).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsEquality2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsLength1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsLength1(Context& context, const glw::GLchar* name, const glw::GLchar* description)
		: TestCaseBase<API>(context, name, description)
	{
		/* Left empty on purpose */
	}

	ExpressionsLength1(Context& context)
		: TestCaseBase<API>(context, "ExpressionsLength1",
							" For a 4-dimensional array declared as int x[4][3][2][1], verify that\n"
							" x.length returns the integer 4, x[0].length the integer 3, and so\n"
							" forth (4 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsLength1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void execute_dispatch_test(typename TestCaseBase<API>::TestShaderType tested_shader_type,
							   const std::string& tested_declaration, const std::string& tested_snippet);

	void execute_draw_test(typename TestCaseBase<API>::TestShaderType tested_shader_type,
						   const std::string& tested_declaration, const std::string& tested_snippet);

	std::string prepare_compute_shader(typename TestCaseBase<API>::TestShaderType tested_shader_type,
									   const std::string& tested_declaration, const std::string& tested_snippet);

	std::string prepare_fragment_shader(typename TestCaseBase<API>::TestShaderType tested_shader_type,
										const std::string& tested_declaration, const std::string& tested_snippet);

	std::string prepare_geometry_shader(typename TestCaseBase<API>::TestShaderType tested_shader_type,
										const std::string& tested_declaration, const std::string& tested_snippet);

	std::string prepare_tess_ctrl_shader(typename TestCaseBase<API>::TestShaderType tested_shader_type,
										 const std::string& tested_declaration, const std::string& tested_snippet);

	std::string prepare_tess_eval_shader(typename TestCaseBase<API>::TestShaderType tested_shader_type,
										 const std::string& tested_declaration, const std::string& tested_snippet);

	std::string prepare_vertex_shader(typename TestCaseBase<API>::TestShaderType tested_shader_type,
									  const std::string& tested_declaration, const std::string& tested_snippet);

	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsLength2 : public ExpressionsLength1<API>
{
public:
	/* Public methods */
	ExpressionsLength2(Context& context)
		: ExpressionsLength1<API>(context, "ExpressionsLength2",
								  " For a 4-dimensional array declared as int x[1][2][3][4], verify that\n"
								  " x.length returns the integer 1, x[0].length the integer 2, and so\n"
								  " forth (4 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsLength2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsLength3 : public ExpressionsLength1<API>
{
public:
	/* Public methods */
	ExpressionsLength3(Context& context)
		: ExpressionsLength1<API>(context, "ExpressionsLength3",
								  " Correctly reject any use of the length method on elements of a\n"
								  " 4-dimensional array x[1][1][1][1] for which the index\n"
								  " expression is omitted, e.g. x[].length, x[][].length etc (3 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsLength3()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsInvalid1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsInvalid1(Context& context)
		: TestCaseBase<API>(context, "ExpressionsInvalid1", " Correctly reject an assignment of a 2 dimensional\n"
															" array x[2][2] to a variable y of type mat2.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsInvalid1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class ExpressionsInvalid2 : public TestCaseBase<API>
{
public:
	/* Public methods */
	ExpressionsInvalid2(Context& context)
		: TestCaseBase<API>(context, "ExpressionsInvalid2",
							" For 8-dimensional arrays x,y, correctly reject any attempt\n"
							" to apply the relational operators other than equality and\n"
							" inequality (4 cases per non-opaque primitive type).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~ExpressionsInvalid2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionFunctionCalls1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	InteractionFunctionCalls1(Context& context, const glw::GLchar* name, const glw::GLchar* description)
		: TestCaseBase<API>(context, name, description)
	{
		/* Left empty on purpose */
	}

	InteractionFunctionCalls1(Context& context)
		: TestCaseBase<API>(context, "InteractionFunctionCalls1",
							" Declare a function returning an 8-dimensional 64-element array as\n"
							" an out parameter, which places a unique integer in each\n"
							" element.\n"
							" Verifies that the values are returned as expected when this function\n"
							" is called.\n"
							" Repeat for the following primitive types: int, float,\n"
							" ivec2, ivec3, ivec4, vec2, vec3, vec4, mat2, mat3, mat4.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionFunctionCalls1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void execute_dispatch_test(typename TestCaseBase<API>::TestShaderType tested_shader_type,
							   const std::string& function_definition, const std::string& function_use,
							   const std::string& verification);

	void execute_draw_test(typename TestCaseBase<API>::TestShaderType tested_shader_type,
						   const std::string& function_definition, const std::string& function_use,
						   const std::string& verification);

	std::string 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 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 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 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 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 prepare_vertex_shader(typename TestCaseBase<API>::TestShaderType tested_shader_type,
									  const std::string& function_definition, const std::string& function_use,
									  const std::string& verification);

	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionFunctionCalls2 : public InteractionFunctionCalls1<API>
{
public:
	/* Public methods */
	InteractionFunctionCalls2(Context& context)
		: InteractionFunctionCalls1<API>(context, "InteractionFunctionCalls2",
										 " Declare a function taking an inout parameter,\n"
										 " which multiplies each element by a different prime.\n"
										 " Verifies that the results after returning are again as expected.\n"
										 " Repeat for the following primitive types: int, float,\n"
										 " ivec2, ivec3, ivec4, vec2, vec3, vec4, mat2, mat3, mat4.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionFunctionCalls2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionArgumentAliasing1 : public InteractionFunctionCalls1<API>
{
public:
	/* Public methods */
	InteractionArgumentAliasing1(Context& context)
		: InteractionFunctionCalls1<API>(context, "InteractionArgumentAliasing1",
										 " Declare a function taking two 8-dimensional, 64-element parameters\n"
										 " (e.g. void g(int x[2][2][2][2][2][2][2][2], int\n"
										 " y[2][2][2][2][2][2][2][2]) and verify that after calling g(z,z),\n"
										 " and overwriting x with a constant value, the original values of z\n"
										 " are accessible through y.\n"
										 " Repeat for float and mat4 types.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionArgumentAliasing1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionArgumentAliasing2 : public InteractionFunctionCalls1<API>
{
public:
	/* Public methods */
	InteractionArgumentAliasing2(Context& context)
		: InteractionFunctionCalls1<API>(context, "InteractionArgumentAliasing2",
										 " Declare a function taking two 8-dimensional, 64-element parameters\n"
										 " (e.g. void g(int x[2][2][2][2][2][2][2][2], int\n"
										 " y[2][2][2][2][2][2][2][2]) and verify that after calling g(z,z),\n"
										 " and overwriting y with a constant value, the original values of z\n"
										 " are accessible through x.\n"
										 " Repeat for float and mat4 types.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionArgumentAliasing2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionArgumentAliasing3 : public InteractionFunctionCalls1<API>
{
public:
	/* Public methods */
	InteractionArgumentAliasing3(Context& context)
		: InteractionFunctionCalls1<API>(context, "InteractionArgumentAliasing3",
										 " Declare a function taking two 8-dimensional, 64-element parameters\n"
										 " (e.g. void g(int x[2][2][2][2][2][2][2][2], int\n"
										 " y[2][2][2][2][2][2][2][2]) and verify that after calling g(z,z),\n"
										 " and overwriting y with a constant value, the original values of z\n"
										 " are accessible through x, where x is an out parameter.\n"
										 " Repeat for float and mat4 types.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionArgumentAliasing3()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionArgumentAliasing4 : public InteractionFunctionCalls1<API>
{
public:
	/* Public methods */
	InteractionArgumentAliasing4(Context& context)
		: InteractionFunctionCalls1<API>(context, "InteractionArgumentAliasing4",
										 " Declare a function taking two 8-dimensional, 64-element parameters\n"
										 " (e.g. void g(int x[2][2][2][2][2][2][2][2], int\n"
										 " y[2][2][2][2][2][2][2][2]) and verify that after calling g(z,z),\n"
										 " and overwriting x with a constant value, the original values of z\n"
										 " are accessible through y, where y is an out parameter.\n"
										 " Repeat for float and mat4 types.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionArgumentAliasing4()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionArgumentAliasing5 : public InteractionFunctionCalls1<API>
{
public:
	/* Public methods */
	InteractionArgumentAliasing5(Context& context)
		: InteractionFunctionCalls1<API>(context, "InteractionArgumentAliasing5",
										 " Declare a function taking two 8-dimensional, 64-element parameters\n"
										 " (e.g. void g(int x[2][2][2][2][2][2][2][2], int\n"
										 " y[2][2][2][2][2][2][2][2]) and verify that after calling g(z,z),\n"
										 " and overwriting y with a constant value, the original values of z\n"
										 " are accessible through x, where x is an inout parameter.\n"
										 " Repeat for float and mat4 types.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionArgumentAliasing5()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionArgumentAliasing6 : public InteractionFunctionCalls1<API>
{
public:
	/* Public methods */
	InteractionArgumentAliasing6(Context& context)
		: InteractionFunctionCalls1<API>(context, "InteractionArgumentAliasing6",
										 " Declare a function taking two 8-dimensional, 64-element parameters\n"
										 " (e.g. void g(int x[2][2][2][2][2][2][2][2], int\n"
										 " y[2][2][2][2][2][2][2][2]) and verify that after calling g(z,z),\n"
										 " and overwriting x with a constant value, the original values of z\n"
										 " are accessible through y, where y is an inout parameter.\n"
										 " Repeat for float and mat4 types.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionArgumentAliasing6()
	{
		/* Left empty on purpose */
	}

public:
	//AL protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionUniforms1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	InteractionUniforms1(Context& context, const glw::GLchar* name, const glw::GLchar* description)
		: TestCaseBase<API>(context, name, description)
	{
		/* Left empty on purpose */
	}

	InteractionUniforms1(Context& context)
		: TestCaseBase<API>(context, "InteractionUniforms1",
							" Declare a 4-dimensional uniform array and verify that it can be\n"
							" initialized with user data correctly using the API.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionUniforms1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	std::string prepare_compute_shader(typename TestCaseBase<API>::TestShaderType tested_shader_type,
									   const std::string& uniform_definition, const std::string& uniform_use);

	std::string prepare_fragment_shader(typename TestCaseBase<API>::TestShaderType tested_shader_type,
										const std::string& uniform_definition, const std::string& uniform_use);

	std::string prepare_geometry_shader(typename TestCaseBase<API>::TestShaderType tested_shader_type,
										const std::string& uniform_definition, const std::string& uniform_use);

	std::string prepare_tess_ctrl_shader(typename TestCaseBase<API>::TestShaderType tested_shader_type,
										 const std::string& uniform_definition, const std::string& uniform_use);

	std::string prepare_tess_eval_shader(typename TestCaseBase<API>::TestShaderType tested_shader_type,
										 const std::string& uniform_definition, const std::string& uniform_use);

	std::string prepare_vertex_shader(typename TestCaseBase<API>::TestShaderType tested_shader_type,
									  const std::string& uniform_definition, const std::string& uniform_use);

	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionUniforms2 : public TestCaseBase<API>
{
public:
	/* Public methods */
	InteractionUniforms2(Context& context)
		: TestCaseBase<API>(context, "InteractionUniforms2",
							" Correctly reject 4-dimensional uniform arrays with any unsized\n"
							" dimension, with or without an initializer (30 cases).\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionUniforms2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionUniformBuffers1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	InteractionUniformBuffers1(Context& context)
		: TestCaseBase<API>(context, "InteractionUniformBuffers1",
							" Declare a uniform block containing a 6-dimensional array and verify\n"
							" that the resulting shader compiles.\n"
							" Repeat for ints and uints.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionUniformBuffers1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionUniformBuffers2 : public InteractionUniforms1<API>
{
public:
	/* Public methods */
	InteractionUniformBuffers2(Context& context)
		: InteractionUniforms1<API>(context, "InteractionUniformBuffers2",
									" Declare a 4-dimensional uniform float array x[2][2][2][2] within a\n"
									" uniform block, and verify that it can be initialized correctly with user\n"
									" data via the API.\n"
									" Repeat for ints and uints.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionUniformBuffers2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void execute_dispatch_test();

	void execute_draw_test(typename TestCaseBase<API>::TestShaderType tested_shader_type);

	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionUniformBuffers3 : public TestCaseBase<API>
{
public:
	/* Public methods */
	InteractionUniformBuffers3(Context& context)
		: TestCaseBase<API>(context, "InteractionUniformBuffers3",
							" Correctly reject 4-dimensional uniform arrays with a uniform block\n"
							" with any dimension unsized, with or without an initializer (30 cases).\n"
							" Repeat for ints and uints.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionUniformBuffers3()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionStorageBuffers1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	InteractionStorageBuffers1(Context& context)
		: TestCaseBase<API>(context, "InteractionStorageBuffers1",
							" Declare a storage block containing a 6-dimensional array and verify\n"
							" that the resulting shader compiles.\n"
							" Repeat for ints and uints.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionStorageBuffers1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionStorageBuffers2 : public InteractionUniforms1<API>
{
public:
	/* Public methods */
	InteractionStorageBuffers2(Context& context)
		: InteractionUniforms1<API>(context, "InteractionStorageBuffers2",
									" Declare a 4-dimensional float array x[2][2][2][2] within a\n"
									" storage block, and verify that it can be initialized correctly with user\n"
									" data via the API.\n"
									" Repeat for ints and uints.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionStorageBuffers2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void execute_dispatch_test();

	void execute_draw_test(typename TestCaseBase<API>::TestShaderType tested_shader_type);

	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionStorageBuffers3 : public TestCaseBase<API>
{
public:
	/* Public methods */
	InteractionStorageBuffers3(Context& context)
		: TestCaseBase<API>(context, "InteractionStorageBuffers3",
							" Correctly reject 4-dimensional uniform arrays with a uniform block\n"
							" with any dimension unsized, with or without an initializer (30 cases).\n"
							" Repeat for ints and uints.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionStorageBuffers3()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionInterfaceArrays1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	InteractionInterfaceArrays1(Context& context)
		: TestCaseBase<API>(context, "InteractionInterfaceArrays1", " Verifies that 2-dimensional arrays of shader\n"
																	" storage buffer objects are correctly rejected.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionInterfaceArrays1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionInterfaceArrays2 : public TestCaseBase<API>
{
public:
	/* Public methods */
	InteractionInterfaceArrays2(Context& context, const glw::GLchar* name, const glw::GLchar* description)
		: TestCaseBase<API>(context, name, description)
	{
		/* Left empty on purpose */
	}

	InteractionInterfaceArrays2(Context& context)
		: TestCaseBase<API>(context, "InteractionInterfaceArrays2",
							" Verifies that 2-dimensional arrays of input and output variables\n"
							" are correctly rejected.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionInterfaceArrays2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	const typename TestCaseBase<API>::TestShaderType get_output_shader_type(
		const typename TestCaseBase<API>::TestShaderType& input_shader_type);
	const std::string prepare_fragment_shader(const typename TestCaseBase<API>::TestShaderType& input_shader_type,
											  const std::string& input_source, const std::string& output_source);
	const std::string prepare_geometry_shader(const typename TestCaseBase<API>::TestShaderType& input_shader_type,
											  const std::string& input_source, const std::string& output_source);
	const std::string prepare_tess_ctrl_shader_source(
		const typename TestCaseBase<API>::TestShaderType& input_shader_type, const std::string& input_source,
		const std::string& output_source);
	const std::string prepare_tess_eval_shader_source(
		const typename TestCaseBase<API>::TestShaderType& input_shader_type, const std::string& input_source,
		const std::string& output_source);
	const std::string prepare_vertex_shader(const typename TestCaseBase<API>::TestShaderType& input_shader_type,
											const std::string& input_source, const std::string& output_source);
	void 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);
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType input_shader_type);
};

template <class API>
class InteractionInterfaceArrays3 : public TestCaseBase<API>
{
public:
	/* Public methods */
	InteractionInterfaceArrays3(Context& context)
		: TestCaseBase<API>(context, "InteractionInterfaceArrays3",
							" Verifies that 2-dimensional arrays of uniform interface blocks\n"
							" are correctly rejected.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionInterfaceArrays3()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class InteractionInterfaceArrays4 : public InteractionInterfaceArrays2<API>
{
public:
	/* Public methods */
	InteractionInterfaceArrays4(Context& context)
		: InteractionInterfaceArrays2<API>(context, "InteractionInterfaceArrays4",
										   " Verifies that 2-dimensional arrays of input and output interface blocks\n"
										   " are correctly rejected.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~InteractionInterfaceArrays4()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType input_shader_type);
};

/** Implements test AtomicDeclaration, desription follows:
 *
 * Prepare a shader that declares "bar", a multidimensional array of atomic
 * counters. Shader should increment all entries of "bar". It is expected that
 * building of program will:
 * - pass when number of entries in "bar" is equal to a value of the
 * corresponding MAX_*_ATOMIC_COUNTERS constant,
 * - fail when number of entries in "bar" exceeds limit.
 * Test all supported shader stages separately.
 **/
template <class API>
class AtomicDeclarationTest : public TestCaseBase<API>
{
public:
	/* Public methods */
	AtomicDeclarationTest(Context& context)
		: TestCaseBase<API>(context, "AtomicDeclaration",
							" Verifies that atomic counters can be grouped in multidimensional arrays\n")
	{
		/* Left empty on purpose */
	}

	virtual ~AtomicDeclarationTest()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

/** Implements test AtomicUsage, desription follows:
 *
 * Prepare a program like in "valid" case of AtomicDeclaration test, but use
 * layout qualifier with last binding and specific offset. Bind a buffer so all
 * entries in "bar" have unique values assigned. Select offset and size of
 * "bar" as follows:
 * - offset is 0, "bar" fills entire allowed space;
 * - offset is not 0, "bar" does not exceed any limit.
 * Test pass if buffer contents are correctly modified by execution of the
 * program.
 * Test all supported shader stages separately.
 **/
template <class API>
class AtomicUsageTest : public TestCaseBase<API>
{
public:
	/* Public methods */
	AtomicUsageTest(Context& context)
		: TestCaseBase<API>(context, "AtomicUsage",
							" Verifies that atomic counters grouped in multidimensional arrays can be used\n")
	{
		/* Left empty on purpose */
	}

	virtual ~AtomicUsageTest()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);

private:
	void execute(typename TestCaseBase<API>::TestShaderType tested_shader_type, glw::GLuint binding, glw::GLuint offset,
				 glw::GLuint n_entries);
};

/** Implements "out" case of SubRoutineCalls test, description follows:
 *
 * Modify "function-calls" test in the following aspects:
 * - provide two subroutines instead of each function;
 * - "new" "out" subroutine should use different pattern of values;
 * - "new" "inout" subroutine should use division instead of multiplication;
 * - it is expected that "original" set will pass, while "new" set will fail.
 **/
template <class API>
class SubroutineFunctionCalls1 : public TestCaseBase<API>
{
public:
	/* Public methods */
	SubroutineFunctionCalls1(Context& context, const glw::GLchar* name, const glw::GLchar* description)
		: TestCaseBase<API>(context, name, description)
	{
		/* Left empty on purpose */
	}

	SubroutineFunctionCalls1(Context& context)
		: TestCaseBase<API>(context, "SubroutineFunctionCalls1",
							" Declare two subroutines returning an 8-dimensional 64-element array as\n"
							" an out parameter, filled with unique values.\n"
							" Verifies that the values are returned as expected when this function\n"
							" is called.\n"
							" Repeat for the following primitive types: int, float,\n"
							" ivec2, ivec3, ivec4, vec2, vec3, vec4, mat2, mat3, mat4.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~SubroutineFunctionCalls1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void 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);

	void 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);

	std::string 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 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 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 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 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 prepare_vertex_shader(typename TestCaseBase<API>::TestShaderType tested_shader_type,
									  const std::string& function_definition, const std::string& function_use,
									  const std::string& verification);

	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

/** Implements "inout" case of SubRoutineCalls test, description follows:
 *
 * Modify "function-calls" test in the following aspects:
 * - provide two subroutines instead of each function;
 * - "new" "out" subroutine should use different pattern of values;
 * - "new" "inout" subroutine should use division instead of multiplication;
 * - it is expected that "original" set will pass, while "new" set will fail.
 **/
template <class API>
class SubroutineFunctionCalls2 : public SubroutineFunctionCalls1<API>
{
public:
	/* Public methods */
	SubroutineFunctionCalls2(Context& context)
		: SubroutineFunctionCalls1<API>(context, "SubroutineFunctionCalls2",
										" Declare two subroutines taking an inout parameter,\n"
										" which modifies each element in a unique way.\n"
										" Verifies that the results after returning are as expected.\n"
										" Repeat for the following primitive types: int, float,\n"
										" ivec2, ivec3, ivec4, vec2, vec3, vec4, mat2, mat3, mat4.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~SubroutineFunctionCalls2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class SubroutineArgumentAliasing1 : public SubroutineFunctionCalls1<API>
{
public:
	/* Public methods */
	SubroutineArgumentAliasing1(Context& context)
		: SubroutineFunctionCalls1<API>(
			  context, "SubroutineArgumentAliasing1",
			  " Declare a function taking two 8-dimensional, 64-element parameters\n"
			  " (e.g. void g(int x[2][2][2][2][2][2][2][2], int\n"
			  " y[2][2][2][2][2][2][2][2]) and verify that after calling g(z,z),\n"
			  " and overwriting one parameter with a constant value, the original values of z\n"
			  " are accessible through the second parameter.\n"
			  " Repeat for float and mat4 types.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~SubroutineArgumentAliasing1()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class SubroutineArgumentAliasing2 : public SubroutineFunctionCalls1<API>
{
public:
	/* Public methods */
	SubroutineArgumentAliasing2(Context& context)
		: SubroutineFunctionCalls1<API>(
			  context, "SubroutineArgumentAliasing2",
			  " Declare two subroutines taking two 8-dimensional, 64-element parameters\n"
			  " (e.g. void g(int x[2][2][2][2][2][2][2][2], int\n"
			  " y[2][2][2][2][2][2][2][2]) and verify that after calling g(z,z),\n"
			  " and overwriting one parameter with a constant value, the original values of z\n"
			  " are accessible through the second inout parameter.\n"
			  " Repeat for float and mat4 types.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~SubroutineArgumentAliasing2()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class SubroutineArgumentAliasing3 : public SubroutineFunctionCalls1<API>
{
public:
	/* Public methods */
	SubroutineArgumentAliasing3(Context& context)
		: SubroutineFunctionCalls1<API>(
			  context, "SubroutineArgumentAliasing3",
			  " Declare two subroutines taking two 8-dimensional, 64-element parameters\n"
			  " (e.g. void g(int x[2][2][2][2][2][2][2][2], int\n"
			  " y[2][2][2][2][2][2][2][2]) and verify that after calling g(z,z),\n"
			  " and overwriting x, out, parameter with a constant value, the original values of z\n"
			  " are accessible through the y parameter.\n"
			  " Repeat for float and mat4 types.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~SubroutineArgumentAliasing3()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

template <class API>
class SubroutineArgumentAliasing4 : public SubroutineFunctionCalls1<API>
{
public:
	/* Public methods */
	SubroutineArgumentAliasing4(Context& context)
		: SubroutineFunctionCalls1<API>(
			  context, "SubroutineArgumentAliasing4",
			  " Declare two subroutines taking two 8-dimensional, 64-element parameters\n"
			  " (e.g. void g(int x[2][2][2][2][2][2][2][2], int\n"
			  " y[2][2][2][2][2][2][2][2]) and verify that after calling g(z,z),\n"
			  " and overwriting y, out, parameter with a constant value, the original values of z\n"
			  " are accessible through the x parameter.\n"
			  " Repeat for float and mat4 types.\n")
	{
		/* Left empty on purpose */
	}

	virtual ~SubroutineArgumentAliasing4()
	{
		/* Left empty on purpose */
	}

protected:
	/* Protected methods */
	void test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type);
};

} /* ArraysOfArrays */
} /* glcts */

#endif // _ES31CARRAYOFARRAYSTESTS_HPP