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

/**
 * \file  gl4cShaderSubroutineTests.hpp
 * \brief Declares test classes for "Shader Subroutine" functionality.
 */ /*-------------------------------------------------------------------*/

#include "glcTestCase.hpp"
#include "glwDefs.hpp"
#include <queue>

#include "tcuTestLog.hpp"

namespace gl4cts
{
namespace ShaderSubroutine
{
class Utils
{
public:
	/* Public type definitions */

	struct buffer
	{
		buffer(deqp::Context& context);
		~buffer();

		void bindRange(glw::GLenum target, glw::GLuint index, glw::GLintptr offset, glw::GLsizeiptr size);

		void generate();

		void update(glw::GLenum target, glw::GLsizeiptr size, glw::GLvoid* data, glw::GLenum usage);

		glw::GLuint m_id;

	private:
		deqp::Context& m_context;
	};

	struct framebuffer
	{
		framebuffer(deqp::Context& context);
		~framebuffer();

		void attachTexture(glw::GLenum attachment, glw::GLuint texture_id, glw::GLuint width, glw::GLuint height);

		void bind();
		void clear(glw::GLenum mask);

		void clearColor(glw::GLfloat red, glw::GLfloat green, glw::GLfloat blue, glw::GLfloat alpha);
		void generate();

		glw::GLuint m_id;

	private:
		deqp::Context& m_context;
	};

	/** Store information about program object
	 *
	 **/
	struct program
	{
		program(deqp::Context& context);
		~program();

		void build(const glw::GLchar* compute_shader_code, const glw::GLchar* fragment_shader_code,
				   const glw::GLchar* geometry_shader_code, const glw::GLchar* tesselation_control_shader_code,
				   const glw::GLchar* tesselation_evaluation_shader_code, const glw::GLchar* vertex_shader_code,
				   const glw::GLchar* const* varying_names, glw::GLuint n_varying_names, bool is_separable = false);

		void compile(glw::GLuint shader_id, const glw::GLchar* shader_code) const;

		bool isProgramBinarySupported() const;

		void createFromBinary(const std::vector<glw::GLubyte>& binary, glw::GLenum binary_format);

		void getBinary(std::vector<glw::GLubyte>& binary, glw::GLenum& binary_format) const;

		glw::GLuint getSubroutineIndex(const glw::GLchar* subroutine_name, glw::GLenum shader_stage) const;

		glw::GLint getSubroutineUniformLocation(const glw::GLchar* uniform_name, glw::GLenum shader_stage) const;

		glw::GLint getUniformLocation(const glw::GLchar* uniform_name) const;
		void link() const;
		void remove();
		void use() const;

		static const glw::GLenum ARB_COMPUTE_SHADER;

		glw::GLuint m_compute_shader_id;
		glw::GLuint m_fragment_shader_id;
		glw::GLuint m_geometry_shader_id;
		glw::GLuint m_program_object_id;
		glw::GLuint m_tesselation_control_shader_id;
		glw::GLuint m_tesselation_evaluation_shader_id;
		glw::GLuint m_vertex_shader_id;

	private:
		deqp::Context& m_context;
	};

	struct texture
	{
		texture(deqp::Context& context);
		~texture();

		void bind();

		void create(glw::GLuint width, glw::GLuint height, glw::GLenum internal_format);

		void get(glw::GLenum format, glw::GLenum type, glw::GLvoid* out_data);

		void update(glw::GLuint width, glw::GLuint height, glw::GLenum format, glw::GLenum type, glw::GLvoid* data);

		glw::GLuint m_id;

	private:
		deqp::Context& m_context;
	};

	struct vertexArray
	{
		vertexArray(deqp::Context& Context);
		~vertexArray();

		void generate();
		void bind();

		glw::GLuint m_id;

	private:
		deqp::Context& m_context;
	};

	/** Storage for 4 element vector of T
	 *
	 **/
	template <typename T>
	struct vec4
	{
		vec4()
		{
		}

		vec4(T x, T y, T z, T w) : m_x(x), m_y(y), m_z(z), m_w(w)
		{
		}

		bool operator==(const vec4& val) const
		{
			bool result = true;

			result = result && compare(m_x, val.m_x);
			result = result && compare(m_y, val.m_y);
			result = result && compare(m_z, val.m_z);
			result = result && compare(m_w, val.m_w);

			return result;
		}

		void log(tcu::MessageBuilder& message) const
		{
			message << "[ " << m_x << ", " << m_y << ", " << m_z << ", " << m_w << " ]";
		}

		T m_x;
		T m_y;
		T m_z;
		T m_w;
	};

	enum _shader_stage
	{
		SHADER_STAGE_FIRST,

		SHADER_STAGE_VERTEX = SHADER_STAGE_FIRST,
		SHADER_STAGE_TESSELLATION_CONTROL,
		SHADER_STAGE_TESSELLATION_EVALUATION,
		SHADER_STAGE_GEOMETRY,
		SHADER_STAGE_FRAGMENT,

		SHADER_STAGE_COUNT
	};

	enum _variable_type
	{
		VARIABLE_TYPE_BOOL,
		VARIABLE_TYPE_BVEC2,
		VARIABLE_TYPE_BVEC3,
		VARIABLE_TYPE_BVEC4,
		VARIABLE_TYPE_DOUBLE,
		VARIABLE_TYPE_DVEC2,
		VARIABLE_TYPE_DVEC3,
		VARIABLE_TYPE_DVEC4,
		VARIABLE_TYPE_FLOAT,
		VARIABLE_TYPE_INT,
		VARIABLE_TYPE_IVEC2,
		VARIABLE_TYPE_IVEC3,
		VARIABLE_TYPE_IVEC4,
		VARIABLE_TYPE_MAT2,
		VARIABLE_TYPE_MAT2X3,
		VARIABLE_TYPE_MAT2X4,
		VARIABLE_TYPE_MAT3,
		VARIABLE_TYPE_MAT3X2,
		VARIABLE_TYPE_MAT3X4,
		VARIABLE_TYPE_MAT4,
		VARIABLE_TYPE_MAT4X2,
		VARIABLE_TYPE_MAT4X3,
		VARIABLE_TYPE_UINT,
		VARIABLE_TYPE_UVEC2,
		VARIABLE_TYPE_UVEC3,
		VARIABLE_TYPE_UVEC4,
		VARIABLE_TYPE_VEC2,
		VARIABLE_TYPE_VEC3,
		VARIABLE_TYPE_VEC4,

		/* Always last */
		VARIABLE_TYPE_UNKNOWN
	};

	/* Public methods */
	static bool buildProgram(const glw::Functions& gl, const std::string& vs_body, const std::string& tc_body,
							 const std::string& te_body, const std::string& gs_body, const std::string& fs_body,
							 const glw::GLchar** xfb_varyings, const unsigned int& n_xfb_varyings,
							 glw::GLuint* out_vs_id, glw::GLuint* out_tc_id, glw::GLuint* out_te_id,
							 glw::GLuint* out_gs_id, glw::GLuint* out_fs_id, glw::GLuint* out_po_id);

	static _variable_type getBaseVariableType(const _variable_type& variable_type);

	static unsigned int getComponentSizeForVariableType(const _variable_type& variable_type);

	static glw::GLenum getGLenumForShaderStage(const _shader_stage& shader_stage);

	static unsigned int getNumberOfComponentsForVariableType(const _variable_type& variable_type);

	static std::string getShaderStageString(const _shader_stage& shader_stage);

	static std::string getShaderStageStringFromGLEnum(const glw::GLenum shader_stage_glenum);

	static _variable_type getVariableTypeFromProperties(const _variable_type& base_variable_type,
														const unsigned int&   n_components);

	static std::string getVariableTypeGLSLString(const _variable_type& variable_type);

	static const glw::GLchar* programInterfaceToStr(glw::GLenum program_interface);
	static const glw::GLchar* pnameToStr(glw::GLenum pname);

private:
	/* Private methods */
	template <typename T>
	static bool compare(const T& left, const T& right)
	{
		return left == right;
	}

	static bool compare(const glw::GLfloat& left, const glw::GLfloat& right);
};

/** Verify that Get* commands accept MAX_SUBROUTINES and
 *  MAX_SUBROUTINE_UNIFORM_LOCATIONS tokens and that the returned values
 *  are not lower than required by the specification.
 **/
class APITest1 : public deqp::TestCase
{
public:
	/* Public methods */
	APITest1(deqp::Context& context);

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

private:
	/* Private type definitions */
	/* Private methods */

	/* Private fields */
	bool m_has_test_passed;
};

/** Check if <bufsize> and <length> parameters behave correctly in
 *  GetActiveSubroutineName and GetActiveSubroutineUniformName functions.
 **/
class APITest2 : public deqp::TestCase
{
public:
	/* Public methods */
	APITest2(deqp::Context& context);

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

private:
	/* Private type definitions */

	/* Private methods */
	std::string getVertexShaderBody();
	void		initTest();
	void		verifyGLGetActiveSubroutineNameFunctionality();
	void		verifyGLGetActiveSubroutineUniformNameFunctionality();

	/* Private fields */
	glw::GLchar* m_buffer;
	bool		 m_has_test_passed;
	glw::GLuint  m_po_id;
	const char*  m_subroutine_name1;
	const char*  m_subroutine_name2;
	const char*  m_subroutine_uniform_name;
	glw::GLuint  m_vs_id;
};

/** * Create program with 2 subroutines taking one parameter and 1 subroutine
 *    uniform. Select the first subroutine and make a draw. Verify the result
 *    and draw again with second subroutine selected then verify result again.
 *    Repeat for following subroutines return and argument types: bool, float,
 *    int, uint, double, *vec*, *mat*.
 *
 *  * Same as above, but with return and argument types as arrays.
 *
 ***/
class FunctionalTest1_2 : public deqp::TestCase
{
public:
	/* Public methods */
	FunctionalTest1_2(deqp::Context& context);

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

private:
	/* Private type definitions */
	struct _test_case
	{
		unsigned int		  array_size;
		Utils::_variable_type variable_type;
	};

	typedef std::vector<_test_case>		_test_cases;
	typedef _test_cases::const_iterator _test_cases_const_iterator;

	/* Private methods */
	void deinitTestIteration();
	bool executeTestIteration(const _test_case& test_case);

	std::string getVertexShaderBody(const Utils::_variable_type& variable_type, unsigned int array_size);

	void initTest();

	bool verifyXFBData(const void* xfb_data, const Utils::_variable_type& variable_type);

	/* Private fields */
	bool		m_has_test_passed;
	glw::GLuint m_po_id;
	glw::GLuint m_po_getter0_subroutine_index;
	glw::GLuint m_po_getter1_subroutine_index;
	glw::GLint  m_po_subroutine_uniform_index;
	_test_cases m_test_cases;
	glw::GLuint m_xfb_bo_id;
	glw::GLuint m_vao_id;
	glw::GLuint m_vs_id;
};

/** * Create a program with 4 subroutines and 2 subroutine uniforms and query
 *    it using: GetProgramStageiv, GetActiveSubroutineUniformiv,
 *    GetActiveSubroutineUniformName, GetActiveSubroutineName,
 *    GetUniformSubroutineuiv, GetSubroutineIndex and
 *    GetSubroutineUniformLocation. Verify the results and use them to select
 *    subroutines, then make a draw and select different set of subroutines.
 *    Draw again and verify the results.
 *
 *  OpenGL 4.3 or ARB_program_interface_query support required
 *  * Same as above, but query the program using calls introduced in
 *    ARB_program_interface_query extension.
 **/
class FunctionalTest3_4 : public deqp::TestCase
{
public:
	/* Public methods */
	FunctionalTest3_4(deqp::Context& context);

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

private:
	/* Private types */
	/** Connect pname with expected value. Used to check Get* API.
	 *
	 **/
	struct inspectionDetails
	{
		glw::GLenum pname;
		glw::GLint  expected_value;
	};

	/* Private types */
	/** Connect program_interface, pname and expected value. Used to check GetProgramInterface.
	 *
	 **/
	struct inspectionDetailsForProgramInterface
	{
		glw::GLenum program_interface;
		glw::GLenum pname;
		glw::GLint  expected_value;
	};

	/* Private methods */
	bool checkProgramStageiv(glw::GLuint program_id, glw::GLenum pname, glw::GLint expected) const;

	bool checkProgramResourceiv(glw::GLuint program_id, glw::GLenum program_interface, glw::GLenum prop,
								const glw::GLchar* resource_name, glw::GLint expected) const;

	bool checkProgramInterfaceiv(glw::GLuint program_id, glw::GLenum program_interface, glw::GLenum pname,
								 glw::GLint expected) const;

	bool checkActiveSubroutineUniformiv(glw::GLuint program_id, glw::GLuint index, glw::GLenum pname,
										glw::GLint expected) const;

	glw::GLuint getProgramResourceIndex(glw::GLuint program_id, glw::GLenum program_interface,
										const glw::GLchar* resource_name) const;

	glw::GLuint getSubroutineIndex(glw::GLuint program_id, const glw::GLchar* subroutine_name,
								   bool use_program_query) const;

	glw::GLint getSubroutineUniformLocation(glw::GLuint program_id, const glw::GLchar* uniform_name,
											bool use_program_query) const;

	bool inspectProgramStageiv(glw::GLuint program_id) const;
	bool inspectProgramInterfaceiv(glw::GLuint program_id) const;

	bool inspectProgramResourceiv(glw::GLuint program_id, const glw::GLchar** subroutine_names,
								  const glw::GLchar** uniform_names) const;

	bool inspectActiveSubroutineUniformiv(glw::GLuint program_id, const glw::GLchar** uniform_names) const;

	bool inspectActiveSubroutineUniformName(glw::GLuint program_id, const glw::GLchar** uniform_names) const;

	bool inspectActiveSubroutineName(glw::GLuint program_id, const glw::GLchar** subroutine_names) const;

	bool inspectSubroutineBinding(glw::GLuint program_id, const glw::GLchar** subroutine_names,
								  const glw::GLchar** uniform_names, bool use_program_query) const;

	bool testDraw(glw::GLuint program_id, const glw::GLchar* first_routine_name, const glw::GLchar* second_routine_name,
				  const glw::GLchar** uniform_names, const Utils::vec4<glw::GLfloat> data[5],
				  bool use_program_query) const;

	/* Private fields */
	glw::GLint m_n_active_subroutine_uniforms;
	glw::GLint m_n_active_subroutine_uniform_locations;
	glw::GLint m_n_active_subroutines;
	glw::GLint m_n_active_subroutine_uniform_name_length;
	glw::GLint m_n_active_subroutine_name_length;
	glw::GLint m_n_active_subroutine_uniform_size;
};

/**
 * * Create a program with 8 subroutines and 4 subroutine uniforms. Each
 *   subroutine uniform should have different signature that should match 2
 *   subroutines. Go through all possible combinations of subroutine uniforms
 *   values and for each combination verify that it works as expected.
 **/
class FunctionalTest5 : public deqp::TestCase
{
public:
	/* Public methods */
	FunctionalTest5(deqp::Context& context);

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

private:
	/* Private methods */
	void logError(const glw::GLchar* subroutine_names[4][2], const glw::GLuint subroutine_combination[4],
				  const Utils::vec4<glw::GLfloat> input_data[3], const Utils::vec4<glw::GLfloat>& first_routine_result,
				  const Utils::vec4<glw::GLfloat>& second_routine_result,
				  const Utils::vec4<glw::GLfloat>& third_routine_result,
				  const Utils::vec4<glw::GLuint>&  fourth_routine_result,
				  const Utils::vec4<glw::GLfloat>& first_routine_expected_result,
				  const Utils::vec4<glw::GLfloat>& second_routine_expected_result,
				  const Utils::vec4<glw::GLfloat>& third_routine_expected_result,
				  const Utils::vec4<glw::GLuint>&  fourth_routine_expected_result) const;

	void testDraw(const glw::GLuint subroutine_combination[4], const Utils::vec4<glw::GLfloat> input_data[3],
				  Utils::vec4<glw::GLfloat>& out_first_routine_result,
				  Utils::vec4<glw::GLfloat>& out_second_routine_result,
				  Utils::vec4<glw::GLfloat>& out_third_routine_result,
				  Utils::vec4<glw::GLuint>&  out_fourth_routine_result) const;

	bool verify(const Utils::vec4<glw::GLfloat>& first_routine_result,
				const Utils::vec4<glw::GLfloat>& second_routine_result,
				const Utils::vec4<glw::GLfloat>& third_routine_result,
				const Utils::vec4<glw::GLuint>&  fourth_routine_result,
				const Utils::vec4<glw::GLfloat>& first_routine_expected_result,
				const Utils::vec4<glw::GLfloat>& second_routine_expected_result,
				const Utils::vec4<glw::GLfloat>& third_routine_expected_result,
				const Utils::vec4<glw::GLuint>&  fourth_routine_expected_result) const;

	/* Private fields */
	glw::GLuint m_subroutine_uniform_locations[4][1];
	glw::GLuint m_subroutine_indices[4][2];
	glw::GLuint m_uniform_locations[3];
};

/**
 * * Create a program with a subroutine and a subroutine uniform. Verify that
 *   subroutine can be called directly with a static use of subroutine's
 *   function name, as is done with non-subroutine function declarations and
 *   calls.
 **/
class FunctionalTest6 : public deqp::TestCase
{
public:
	/* Public methods */
	FunctionalTest6(deqp::Context& context);

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

/**
 * * Create a program with 2 subroutines and an array of 4 subroutine
 *   uniforms. Go through all possible combinations of subroutine uniforms
 *   values and for each combination verify that it works as expected by
 *   performing draw or dispatch call. Also verify that length() function
 *   works correctly when used on array of subroutine uniforms.
 *
 * * Verify that program which uses uniforms, constant expressions and
 *   dynamically uniform loop index to access subroutine uniform array
 *   compiles and works as expected.
 **/
class FunctionalTest7_8 : public deqp::TestCase
{
public:
	/* Public methods */
	FunctionalTest7_8(deqp::Context& context);

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

private:
	/* Private methods */
	void calculate(glw::GLuint function, const Utils::vec4<glw::GLfloat>& left, const Utils::vec4<glw::GLfloat>& right,
				   Utils::vec4<glw::GLfloat>& out) const;

	void calculate(const glw::GLuint combination[4], const Utils::vec4<glw::GLfloat>& left,
				   const Utils::vec4<glw::GLfloat>& right, const Utils::vec4<glw::GLuint>& indices,
				   Utils::vec4<glw::GLfloat>& out_combined, Utils::vec4<glw::GLfloat>& out_combined_inversed,
				   Utils::vec4<glw::GLfloat>& out_constant, Utils::vec4<glw::GLfloat>& out_constant_inversed,
				   Utils::vec4<glw::GLfloat>& out_dynamic, Utils::vec4<glw::GLfloat>& out_dynamic_inversed,
				   Utils::vec4<glw::GLfloat>& out_loop) const;

	void logError(const glw::GLuint combination[4], const Utils::vec4<glw::GLfloat>& left,
				  const Utils::vec4<glw::GLfloat>& right, const Utils::vec4<glw::GLuint>& indices,
				  const Utils::vec4<glw::GLfloat> vec4_expected[7], const Utils::vec4<glw::GLfloat> vec4_result[7],
				  glw::GLuint array_length, bool result[7]) const;

	bool testDraw(const glw::GLuint combination[4], const Utils::vec4<glw::GLfloat>& left,
				  const Utils::vec4<glw::GLfloat>& right, const Utils::vec4<glw::GLuint>& indices) const;

	/* Private fields */
	glw::GLuint m_subroutine_uniform_locations[4];
	glw::GLuint m_subroutine_indices[2];
	glw::GLuint m_uniform_locations[3];
};

/**
 *  Make sure that program with one function associated with 3 different
 *  subroutine types and 3 subroutine uniforms using that function compiles
 *  and works as expected.
 *
 **/
class FunctionalTest9 : public deqp::TestCase
{
public:
	/* Public methods */
	FunctionalTest9(deqp::Context& context);

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

private:
	/* Private methods */
	std::string getVertexShaderBody() const;
	void		initTest();
	void verifyXFBData(const glw::GLvoid* data_ptr);

	/* Private fields */
	bool			   m_has_test_passed;
	const unsigned int m_n_points_to_draw;
	glw::GLuint		   m_po_id;
	glw::GLuint		   m_vao_id;
	glw::GLuint		   m_vs_id;
	glw::GLuint		   m_xfb_bo_id;
};

/**
 * OpenGL 4.3 or ARB_arrays_of_arrays support required
 * * Create a program that uses array of arrays for subroutine uniform type
 *   and verify that it works as expected.
 **/
class FunctionalTest10 : public deqp::TestCase
{
public:
	FunctionalTest10(deqp::Context& context);

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

private:
	/* Private methods */
	glw::GLint testDraw(const glw::GLuint routine_indices[16]) const;

	/* Private fields */
	glw::GLuint m_subroutine_uniform_locations[16];
	glw::GLuint m_subroutine_indices[2];
};

/**
 * * Verify that following operations work correctly when performed inside
 *   subroutine body: setting global variable, texture sampling, writing
 *   to fragment shader outputs, using discard function (fragment shader
 *   only), calling other functions and subroutines.
 **/
class FunctionalTest11 : public deqp::TestCase
{
public:
	/* Public methods */
	FunctionalTest11(deqp::Context& context);

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

private:
	/* Private types */
	struct testConfiguration
	{
		testConfiguration(const glw::GLchar* description, const glw::GLubyte expected_color[4],
						  glw::GLuint discard_fragment, glw::GLuint set_global_colors, glw::GLuint sample_texture,
						  glw::GLuint compare, glw::GLuint test, glw::GLuint first_sampler, glw::GLuint second_sampler)
		{
			m_description = description;

			m_expected_color[0] = expected_color[0];
			m_expected_color[1] = expected_color[1];
			m_expected_color[2] = expected_color[2];
			m_expected_color[3] = expected_color[3];

			m_routines[0] = discard_fragment;
			m_routines[1] = set_global_colors;
			m_routines[2] = sample_texture;
			m_routines[3] = compare;
			m_routines[4] = test;

			m_samplers[0] = first_sampler;
			m_samplers[1] = second_sampler;
		}

		const glw::GLchar* m_description;
		glw::GLubyte	   m_expected_color[4];
		glw::GLuint		   m_routines[5];
		glw::GLuint		   m_samplers[2];
	};

	/* Private methods */
	void fillTexture(Utils::texture& texture, const glw::GLubyte color[4]) const;

	bool testDraw(const glw::GLuint routine_configuration[5], const glw::GLuint sampler_configuration[2],
				  const glw::GLubyte expected_color[4], Utils::texture& color_texture) const;

	/* Private fields */
	/* Constants */
	static const glw::GLuint m_texture_height;
	static const glw::GLuint m_texture_width;

	/* Locations and indices */
	glw::GLuint m_subroutine_uniform_locations[5];
	glw::GLuint m_subroutine_indices[5][2];
	glw::GLuint m_uniform_locations[2];
	glw::GLuint m_source_textures[2];
};

/**
 * OpenGL 4.3 or ARB_shader_storage_buffer_object, ARB_atomic_counters
 * and ARB_shader_image_load_store support required
 * * Same as above, but check writing/reading from storage buffer, performing
 *   operations on atomic counters and writing/reading from an image. This
 *   should be tested in a program stage which supports operations of these
 *   kind.
 **/
class FunctionalTest12 : public deqp::TestCase
{
public:
	FunctionalTest12(deqp::Context& context);

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

private:
	/* Private methods */
	void fillTexture(Utils::texture& texture, const glw::GLuint color[4]) const;

	bool verifyTexture(Utils::texture& texture, const glw::GLuint color[4]) const;

	bool testAtomic();

	bool testAtomicDraw(glw::GLuint subourinte_index, const glw::GLuint expected_results[3]) const;

	bool testImage();

	bool testImageDraw(glw::GLuint subroutine_index, Utils::texture& left, Utils::texture& right,
					   const glw::GLuint expected_left_color[4], const glw::GLuint expected_right_color[4]) const;

	bool testSSBO();

	bool testSSBODraw(glw::GLuint subourinte_index, const glw::GLuint expected_results[4]) const;

	/* Private fields */
	/* Constatnts */
	static const glw::GLuint m_texture_height;
	static const glw::GLuint m_texture_width;

	/* Locations */
	glw::GLuint m_left_image;
	glw::GLuint m_right_image;
};

/**
 *  Verify that subroutines work correctly when used in separate shader
 *  objects.
 *
 **/
class FunctionalTest13 : public deqp::TestCase
{
public:
	/* Public methods */
	FunctionalTest13(deqp::Context& context);

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

private:
	/* Private methods */
	std::string getFragmentShaderBody(unsigned int n_id);
	std::string getGeometryShaderBody(unsigned int n_id);
	std::string getTessellationControlShaderBody(unsigned int n_id);
	std::string getTessellationEvaluationShaderBody(unsigned int n_id);
	std::string getVertexShaderBody(unsigned int n_id);
	void initTest();

	void verifyReadBuffer(unsigned int n_fs_id, unsigned int n_fs_subroutine, unsigned int n_gs_id,
						  unsigned int n_gs_subroutine, unsigned int n_tc_id, unsigned int n_tc_subroutine,
						  unsigned int n_te_id, unsigned int n_te_subroutine, unsigned int n_vs_id,
						  unsigned int n_vs_subroutine);

	/* Private fields */
	glw::GLuint		   m_fbo_id;
	glw::GLuint		   m_fs_po_ids[2];
	glw::GLuint		   m_gs_po_ids[2];
	glw::GLuint		   m_pipeline_id;
	unsigned char*	 m_read_buffer;
	glw::GLuint		   m_tc_po_ids[2];
	glw::GLuint		   m_te_po_ids[2];
	const unsigned int m_to_height;
	glw::GLuint		   m_to_id;
	const unsigned int m_to_width;
	glw::GLuint		   m_vao_id;
	glw::GLuint		   m_vs_po_ids[2];

	bool m_has_test_passed;
};

/**
 * * Create program with subroutines that use structures as parameters and
 *   make sure it works correctly.
 *
 * OpenGL 4.1 or ARB_get_program_binary support required
 * * Create a program with 4 subroutines and 2 subroutine uniforms. Query
 *   names and indices of all active subroutines and query names and
 *   locations of all active subroutine uniforms. Call GetProgramBinary on
 *   this program and delete it. Create new program from the binary using
 *   ProgramBinary. Verify that all active subroutine names and indices in
 *   this program match ones from the original program. Also verify that
 *   all active subroutine uniform names and locations match ones from
 *   original program. Make a draw, expect random but valid set of selected
 *   subroutines, then select arbitrary set of subroutines, make a draw and
 *   verify the results.
 **/
class FunctionalTest14_15 : public deqp::TestCase
{
public:
	FunctionalTest14_15(deqp::Context& context);

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

private:
	/* Private methods */
	bool testDefaultSubroutineSet(const Utils::vec4<glw::GLuint>& uni_input,
								  const Utils::vec4<glw::GLuint>  expected_routine_1_result[2],
								  const Utils::vec4<glw::GLuint>  expected_routine_2_result[2]) const;

	bool testDraw(glw::GLuint routine_configuration, const Utils::vec4<glw::GLuint>& uni_input,
				  const Utils::vec4<glw::GLuint>& expected_routine_1_result,
				  const Utils::vec4<glw::GLuint>& expected_routine_2_result) const;

	bool testIndicesAndLocations() const;

	/* Private fields */
	/* Locations and indices */
	glw::GLuint m_subroutine_uniform_locations[2];
	glw::GLuint m_subroutine_indices[2][2];
	glw::GLuint m_uniform_location;
	glw::GLuint m_initial_subroutine_uniform_locations[2];
	glw::GLuint m_initial_subroutine_indices[2][2];
};

/**
 * Check that when the active program for a shader stage is re-linked or
 * changed by a call to UseProgram, BindProgramPipeline, or
 * UseProgramStages, subroutine uniforms for that stage are reset to
 * arbitrarily chosen default functions with compatible subroutine types.
 *
 **/
class FunctionalTest16 : public deqp::TestCase
{
public:
	/* Public methods */
	FunctionalTest16(deqp::Context& context);

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

private:
	/* Private type definitions */
	/* Defines a specific use case that should be checked during particular
	 * test iteration.
	 */
	enum _test_case
	{
		TEST_CASE_FIRST,

		TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT = TEST_CASE_FIRST,
		TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_PIPELINE_OBJECT,
		TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_FRAGMENT_STAGE,
		TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_GEOMETRY_STAGE,
		TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_TESS_CONTROL_STAGE,
		TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_TESS_EVALUATION_STAGE,
		TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_VERTEX_STAGE,

		/* Always last */
		TEST_CASE_COUNT
	};

	/** Defines a number of different subroutine-specific properties
	 *  for a single shader stage.
	 **/
	struct _shader_stage
	{
		glw::GLuint default_subroutine1_value;
		glw::GLuint default_subroutine2_value;
		glw::GLuint default_subroutine3_value;
		glw::GLuint default_subroutine4_value;
		glw::GLint  subroutine1_uniform_location;
		glw::GLint  subroutine2_uniform_location;
		glw::GLint  subroutine3_uniform_location;
		glw::GLint  subroutine4_uniform_location;
		glw::GLuint function1_index;
		glw::GLuint function2_index;
		glw::GLuint function3_index;
		glw::GLuint function4_index;

		glw::GLenum gl_stage;
	};

	/** Describes subroutine-specific properties for a program object */
	struct _program
	{
		_shader_stage fragment;
		_shader_stage geometry;
		_shader_stage tess_control;
		_shader_stage tess_evaluation;
		_shader_stage vertex;
	};

	/** Describes modes that verify*() functions can run in */
	enum _subroutine_uniform_value_verification
	{
		SUBROUTINE_UNIFORMS_SET_TO_DEFAULT_VALUES,
		SUBROUTINE_UNIFORMS_SET_TO_NONDEFAULT_VALUES,
		SUBROUTINE_UNIFORMS_SET_TO_VALID_VALUES,
	};

	/* Private methods */
	std::string getShaderBody(const Utils::_shader_stage& shader_stage, const unsigned int& n_id) const;

	void getShaderStages(bool retrieve_program_object_shader_ids, const unsigned int& n_id,
						 const _shader_stage** out_shader_stages) const;

	void initTest();

	void verifySubroutineUniformValues(const _test_case& test_case, const unsigned int& n_id,
									   const _subroutine_uniform_value_verification& verification);

	void verifySubroutineUniformValuesForShaderStage(const _shader_stage&						   shader_stage,
													 const _subroutine_uniform_value_verification& verification);

	/* Private fields */
	bool m_are_pipeline_objects_supported;
	bool m_has_test_passed;

	glw::GLuint m_fs_ids[2];
	glw::GLuint m_gs_ids[2];
	glw::GLuint m_po_ids[2];
	glw::GLuint m_tc_ids[2];
	glw::GLuint m_te_ids[2];
	glw::GLuint m_vs_ids[2];

	glw::GLuint m_fs_po_ids[2];
	glw::GLuint m_gs_po_ids[2];
	glw::GLuint m_pipeline_object_ids[2];
	glw::GLuint m_tc_po_ids[2];
	glw::GLuint m_te_po_ids[2];
	glw::GLuint m_vs_po_ids[2];

	_shader_stage m_fs_po_descriptors[2];
	_shader_stage m_gs_po_descriptors[2];
	_shader_stage m_tc_po_descriptors[2];
	_shader_stage m_te_po_descriptors[2];
	_shader_stage m_vs_po_descriptors[2];

	_program m_po_descriptors[2];
};

/**
 *  Create a program which uses the same subroutine and subroutine uniform
 *  names for every stage. Types of subroutines should be different in each
 *  stage. Make sure that such program compiles and works as expected.
 **/
class FunctionalTest17 : public deqp::TestCase
{
public:
	/* Public methods */
	FunctionalTest17(deqp::Context& context);

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

private:
	/* Private methods */
	std::string getFragmentShaderBody() const;
	std::string getGeometryShaderBody() const;
	std::string getTessellationControlShaderBody() const;
	std::string getTessellationEvaluationShaderBody() const;
	std::string getVertexShaderBody() const;
	void		initTest();
	void		verifyRenderedData();

	/* Private fields */
	glw::GLuint		   m_fbo_id;
	glw::GLuint		   m_fs_id;
	glw::GLuint		   m_gs_id;
	bool			   m_has_test_passed;
	glw::GLuint		   m_po_id;
	glw::GLuint		   m_tc_id;
	glw::GLuint		   m_te_id;
	float*			   m_to_data;
	const unsigned int m_to_height;
	glw::GLuint		   m_to_id;
	const unsigned int m_to_width;
	glw::GLuint		   m_vao_id;
	glw::GLuint		   m_vs_id;
};

/**
 *  Make sure that calling a subroutine with argument value returned by
 *  another subroutine works correctly.
 *
 *  Verify that subroutines and subroutine uniforms work as expected when
 *  they are used in connection with control flow functions
 *  (if/else/case/while/for/break/continue).
 *
 **/
class FunctionalTest18_19 : public deqp::TestCase
{
public:
	/* Public methods */
	FunctionalTest18_19(deqp::Context& context);

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

private:
	/* Private type definitions */
	typedef tcu::Vec4 (*PFNVEC4OPERATORPROC)(tcu::Vec4);

	/* Private methods */
	void executeTest(glw::GLuint bool_operator1_subroutine_location, glw::GLuint bool_operator2_subroutine_location,
					 glw::GLuint vec4_operator1_subroutine_location, glw::GLuint vec4_operator2_subroutine_location);

	std::string getVertexShaderBody() const;

	void initTest();
	void verifyXFBData(const glw::GLvoid* data, glw::GLuint bool_operator1_subroutine_location,
					   glw::GLuint bool_operator2_subroutine_location, glw::GLuint vec4_operator1_subroutine_location,
					   glw::GLuint vec4_operator2_subroutine_location);

	static tcu::Vec4 vec4operator_div2(tcu::Vec4 data);
	static tcu::Vec4 vec4operator_mul4(tcu::Vec4 data);

	/* Private fields */
	bool			   m_has_test_passed;
	const unsigned int m_n_points_to_draw;
	glw::GLuint		   m_po_id;
	glw::GLuint		   m_po_subroutine_divide_by_two_location;
	glw::GLuint		   m_po_subroutine_multiply_by_four_location;
	glw::GLuint		   m_po_subroutine_returns_false_location;
	glw::GLuint		   m_po_subroutine_returns_true_location;
	glw::GLint		   m_po_subroutine_uniform_bool_operator1;
	glw::GLint		   m_po_subroutine_uniform_bool_operator2;
	glw::GLint		   m_po_subroutine_uniform_vec4_processor1;
	glw::GLint		   m_po_subroutine_uniform_vec4_processor2;
	glw::GLuint		   m_xfb_bo_id;
	glw::GLuint		   m_vao_id;
	glw::GLuint		   m_vs_id;
};

/**
 *  Test whether all INVALID_OPERATION, INVALID_VALUE and INVALID_ENUM
 *  errors related to subroutines usage are properly generated.
 **/
class NegativeTest1 : public deqp::TestCase
{
public:
	/* Public methods */
	NegativeTest1(deqp::Context& context);

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

private:
	/* Private methods */
	void initTest();

	/* Private fields */
	bool		m_has_test_passed;
	glw::GLint  m_po_active_subroutine_uniform_locations;
	glw::GLint  m_po_active_subroutine_uniforms;
	glw::GLint  m_po_active_subroutines;
	glw::GLint  m_po_subroutine_uniform_function_index;
	glw::GLint  m_po_subroutine_uniform_function2_index;
	glw::GLuint m_po_subroutine_test1_index;
	glw::GLuint m_po_subroutine_test2_index;
	glw::GLuint m_po_subroutine_test3_index;
	glw::GLuint m_po_not_linked_id;
	glw::GLuint m_po_id;
	glw::GLuint m_vs_id;
};

/** Make sure that subroutine uniform variables are scoped to the shader
 *  execution stage the variable is declared in. Referencing subroutine
 *  uniform from different stage should cause compile or link error
 **/
class NegativeTest2 : public deqp::TestCase
{
public:
	/* Public methods */
	NegativeTest2(deqp::Context& context);

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

private:
	/* Private type definitions */

	/* Private methods */
	void deinitGLObjects();
	void executeTestCase(const Utils::_shader_stage& referencing_stage);
	std::string getFragmentShaderBody(const Utils::_shader_stage& referencing_stage) const;
	std::string getGeometryShaderBody(const Utils::_shader_stage& referencing_stage) const;
	std::string getSubroutineUniformName(const Utils::_shader_stage& stage) const;
	std::string getTessellationControlShaderBody(const Utils::_shader_stage& referencing_stage) const;
	std::string getTessellationEvaluationShaderBody(const Utils::_shader_stage& referencing_stage) const;
	std::string getVertexShaderBody(const Utils::_shader_stage& referencing_stage) const;

	/* Private fields */
	glw::GLuint m_fs_id;
	glw::GLuint m_gs_id;
	bool		m_has_test_passed;
	glw::GLuint m_po_id;
	glw::GLuint m_tc_id;
	glw::GLuint m_te_id;
	glw::GLuint m_vs_id;
};

/** Verify that "subroutine" keyword is necessary when declaring a
 *  subroutine uniform and a compilation error occurs without it.
 **/
class NegativeTest3 : public deqp::TestCase
{
public:
	/* Public methods */
	NegativeTest3(deqp::Context& context);

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

private:
	/* Private methods */
	void executeTest(const Utils::_shader_stage& shader_stage);
	std::string getFragmentShaderBody() const;
	std::string getGeometryShaderBody() const;
	std::string getTessellationControlShaderBody() const;
	std::string getTessellationEvaluationShaderBody() const;
	std::string getVertexShaderBody() const;

	/* Private fields */
	bool		m_has_test_passed;
	glw::GLuint m_so_id;
};

/**
 *  Verify that compile-time error is present when arguments and return type
 *  do not match between the function and each associated subroutine type.
 *  In particular make sure that applies when there are multiple associated
 *  subroutine types and only one of them does not match.
 *
 **/
class NegativeTest4 : public deqp::TestCase
{
public:
	/* Public methods */
	NegativeTest4(deqp::Context& context);

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

private:
	/* Private type declarations */
	enum _test_case
	{
		TEST_CASE_FIRST,

		TEST_CASE_INCOMPATIBLE_RETURN_TYPE = TEST_CASE_FIRST,
		TEST_CASE_INCOMPATIBLE_ARGUMENT_LIST,

		/* Always last */
		TEST_CASE_COUNT
	};

	/* Private methods */
	std::string getShaderBody(const Utils::_shader_stage& shader_stage, const unsigned int& n_subroutine_types,
							  const _test_case& test_case) const;

	/* Private fields */
	bool	   m_has_test_passed;
	glw::GLint m_so_id;
};

/** Verify that link or compile error occurs when trying to link a program
 *  with no subroutine for subroutine uniform variable.
 **/
class NegativeTest5 : public deqp::TestCase
{
public:
	/* Public methods */
	NegativeTest5(deqp::Context& context);

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

private:
	/* Private type definitions */
	/* Private methods */
	void deinitIteration();
	void executeIteration(const Utils::_shader_stage& shader_stage);
	std::string getFragmentShaderBody(bool include_invalid_subroutine_uniform_declaration) const;
	std::string getGeometryShaderBody(bool include_invalid_subroutine_uniform_declaration) const;
	std::string getTessellationControlShaderBody(bool include_invalid_subroutine_uniform_declaration) const;
	std::string getTessellationEvaluationShaderBody(bool include_invalid_subroutine_uniform_declaration) const;
	std::string getVertexShaderBody(bool include_invalid_subroutine_uniform_declaration) const;

	/* Private fields */
	glw::GLuint m_fs_id;
	glw::GLuint m_gs_id;
	bool		m_has_test_passed;
	glw::GLuint m_po_id;
	glw::GLuint m_tc_id;
	glw::GLuint m_te_id;
	glw::GLuint m_vs_id;
};

/** Check that link or compile error occurs if any shader in a program
 *  includes two or more functions with the same name and at least one of
 *  which is associated with a subroutine type.
 **/
class NegativeTest6 : public deqp::TestCase
{
public:
	/* Public methods */
	NegativeTest6(deqp::Context& context);

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

private:
	/* Private type definitions */
	/* Private methods */
	void deinitIteration();
	void executeIteration(const Utils::_shader_stage& shader_stage);
	std::string getFragmentShaderBody(bool include_invalid_declaration) const;
	std::string getGeometryShaderBody(bool include_invalid_declaration) const;
	std::string getTessellationControlShaderBody(bool include_invalid_declaration) const;
	std::string getTessellationEvaluationShaderBody(bool include_invalid_declaration) const;
	std::string getVertexShaderBody(bool include_invalid_declaration) const;

	/* Private fields */
	glw::GLuint m_fs_id;
	glw::GLuint m_gs_id;
	bool		m_has_test_passed;
	glw::GLuint m_po_id;
	glw::GLuint m_tc_id;
	glw::GLuint m_te_id;
	glw::GLuint m_vs_id;
};

/**
 * * Verify that program fails to link if there is any possible combination
 *   of subroutine uniform values that would result in recursion.
 **/
class NegativeTest7 : public deqp::TestCase
{
public:
	NegativeTest7(deqp::Context& contex);

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

private:
	/* Private methods */
	bool test(const glw::GLchar* vertex_shader_code, const glw::GLchar* name_of_recursive_routine);

	/* Private fields */
	glw::GLuint m_program_id;
	glw::GLuint m_vertex_shader_id;
};

/** Test that either compile or link error occurs when function declared
 *  with subroutine does not include a body.
 **/
class NegativeTest8 : public deqp::TestCase
{
public:
	/* Public methods */
	NegativeTest8(deqp::Context& context);

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

private:
	/* Private type definitions */
	/* Private methods */
	void deinitIteration();
	void executeIteration(const Utils::_shader_stage& shader_stage);
	std::string getFragmentShaderBody(bool include_invalid_declaration) const;
	std::string getGeometryShaderBody(bool include_invalid_declaration) const;
	std::string getTessellationControlShaderBody(bool include_invalid_declaration) const;
	std::string getTessellationEvaluationShaderBody(bool include_invalid_declaration) const;
	std::string getVertexShaderBody(bool include_invalid_declaration) const;

	/* Private fields */
	glw::GLuint m_fs_id;
	glw::GLuint m_gs_id;
	bool		m_has_test_passed;
	glw::GLuint m_po_id;
	glw::GLuint m_tc_id;
	glw::GLuint m_te_id;
	glw::GLuint m_vs_id;
};

/**
 *   Make sure that it is not possible to assign float/int to subroutine
 *   uniform and that subroutine uniform values cannot be compared.
 *
 **/
class NegativeTest9 : public deqp::TestCase
{
public:
	/* Public methods */
	NegativeTest9(deqp::Context& context);

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

private:
	/* Private type definitions */
	enum _test_case
	{
		TEST_CASE_FIRST,

		TEST_CASE_INVALID_FLOAT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT = TEST_CASE_FIRST,
		TEST_CASE_INVALID_INT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT,
		TEST_CASE_INVALID_SUBROUTINE_UNIFORM_VALUE_COMPARISON,

		/* Always last */
		TEST_CASE_COUNT
	};

	/* Private methods */
	std::string getTestCaseString(const _test_case& test_case);
	std::string getVertexShader(const _test_case& test_case);

	/* Private fields */
	bool		m_has_test_passed;
	glw::GLuint m_po_id;
	glw::GLuint m_vs_id;
};

/**
 * Check that an overloaded function cannot be declared with subroutine and
 * a program will fail to compile or link if any shader or stage contains
 * two or more  functions with the same name if the name is associated with
 * a subroutine type.
 *
 **/
class NegativeTest10 : public deqp::TestCase
{
public:
	/* Public methods */
	NegativeTest10(deqp::Context& context);

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

private:
	/* Private type definitions */
	struct _test_case
	{
		std::string name;

		std::string fs_body;
		std::string gs_body;
		std::string tc_body;
		std::string te_body;
		std::string vs_body;
	};

	typedef std::vector<_test_case>		_test_cases;
	typedef _test_cases::const_iterator _test_cases_const_iterator;

	/* Private methods */
	std::string getFragmentShader(bool include_duplicate_function);
	std::string getGeometryShader(bool include_duplicate_function);
	std::string getTessellationControlShader(bool include_duplicate_function);
	std::string getTessellationEvaluationShader(bool include_duplicate_function);
	std::string getVertexShader(bool include_duplicate_function);
	void initTestCases();

	/* Private fields */
	bool		m_has_test_passed;
	glw::GLuint m_fs_id;
	glw::GLuint m_gs_id;
	glw::GLuint m_po_id;
	glw::GLuint m_tc_id;
	glw::GLuint m_te_id;
	_test_cases m_test_cases;
	glw::GLuint m_vs_id;
};

/**
 *   Try to use subroutine uniform in invalid way in sampling, atomic and
 *   image functions. Verify that compile or link time error occurs.
 *
 **/
class NegativeTest11 : public deqp::TestCase
{
public:
	/* Public methods */
	NegativeTest11(deqp::Context& context);

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

private:
	/* Private type definitions */
	enum _test_case
	{
		TEST_CASE_FIRST,

		TEST_CASE_INVALID_TEXTURE_SAMPLING_ATTEMPT = TEST_CASE_FIRST,
		TEST_CASE_INVALID_ATOMIC_COUNTER_USAGE_ATTEMPT,
		TEST_CASE_INVALID_IMAGE_FUNCTION_USAGE_ATTEMPT,

		/* Always last */
		TEST_CASE_COUNT
	};

	/* Private methods */
	std::string getTestCaseString(const _test_case& test_case);
	std::string getVertexShader(const _test_case& test_case);

	/* Private fields */
	bool		m_has_test_passed;
	glw::GLuint m_po_id;
	glw::GLuint m_vs_id;
};

/**
 *  Verify that it is not allowed to use subroutine type for local/global
 *  variables, constructors or argument/return type.
 *
 **/
class NegativeTest12 : public deqp::TestCase
{
public:
	/* Public methods */
	NegativeTest12(deqp::Context& context);

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

private:
	/* Private type definitions */
	enum _test_case
	{
		TEST_CASE_FIRST,

		TEST_CASE_INVALID_LOCAL_SUBROUTINE_VARIABLE = TEST_CASE_FIRST,
		TEST_CASE_INVALID_GLOBAL_SUBROUTINE_VARIABLE,
		TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR,
		TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_ARGUMENT,
		TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_RETURN_TYPE,

		/* Always last */
		TEST_CASE_COUNT
	};

	/* Private methods */
	std::string getTestCaseString(const _test_case& test_case);
	std::string getVertexShader(const _test_case& test_case);

	/* Private fields */
	bool		m_has_test_passed;
	glw::GLuint m_po_id;
	glw::GLuint m_vs_id;
};
} /* ShaderSubroutine */

/** Group class for Shader Subroutine conformance tests */
class ShaderSubroutineTests : public deqp::TestCaseGroup
{
public:
	/* Public methods */
	ShaderSubroutineTests(deqp::Context& context);
	virtual ~ShaderSubroutineTests()
	{
	}

	virtual void init(void);

private:
	/* Private methods */
	ShaderSubroutineTests(const ShaderSubroutineTests&);
	ShaderSubroutineTests& operator=(const ShaderSubroutineTests&);
};

} /* gl4cts namespace */

#endif // _GL4CSHADERSUBROUTINETESTS_HPP