external/openglcts/modules/gl/gl4cShadingLanguage420PackTests.hpp

#ifndef _GL4CSHADINGLANGUAGE420PACKTESTS_HPP
#define _GL4CSHADINGLANGUAGE420PACKTESTS_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  gl4cShadingLanguage420PackTests.hpp
 * \brief Declares test classes for "Shading Language 420Pack" functionality.
 */ /*-------------------------------------------------------------------*/

#include "glcTestCase.hpp"
#include "glwDefs.hpp"

namespace tcu
{
class MessageBuilder;
} /* namespace tcu */

namespace gl4cts
{

namespace GLSL420Pack
{
class Utils
{
public:
	/* Public enums */
	enum TEXTURE_TYPES
	{
		TEX_BUFFER,
		TEX_2D,
		TEX_2D_RECT,
		TEX_2D_ARRAY,
		TEX_3D,
		TEX_CUBE,
		TEX_1D,
		TEX_1D_ARRAY,

		/* */
		TEXTURE_TYPES_MAX
	};

	enum SHADER_STAGES
	{
		COMPUTE_SHADER = 0,
		VERTEX_SHADER,
		TESS_CTRL_SHADER,
		TESS_EVAL_SHADER,
		GEOMETRY_SHADER,
		FRAGMENT_SHADER,

		/* */
		SHADER_STAGES_MAX
	};

	enum UTF8_CHARACTERS
	{
		TWO_BYTES,
		THREE_BYTES,
		FOUR_BYTES,
		FIVE_BYTES,
		SIX_BYTES,
		REDUNDANT_ASCII,

		/* */
		EMPTY
	};

	enum TYPES
	{
		FLOAT,
		DOUBLE,
		INT,
		UINT,

		/* */
		TYPES_MAX
	};

	enum QUALIFIER_CLASSES
	{
		QUAL_CLS_INVARIANCE = 0,
		QUAL_CLS_INTERPOLATION,
		QUAL_CLS_LAYOUT,
		QUAL_CLS_AUXILARY_STORAGE,
		QUAL_CLS_STORAGE,
		QUAL_CLS_PRECISION,

		/* */
		QUAL_CLS_MAX
	};

	enum QUALIFIERS
	{
		QUAL_NONE,

		/* CONSTNESS */
		QUAL_CONST,

		/* STORAGE */
		QUAL_IN,
		QUAL_OUT,
		QUAL_INOUT,
		QUAL_UNIFORM,

		/* AUXILARY */
		QUAL_PATCH,
		QUAL_CENTROID,
		QUAL_SAMPLE,

		/* INTERPOLATION */
		QUAL_FLAT,
		QUAL_NOPERSPECTIVE,
		QUAL_SMOOTH,

		/* LAYOUT */
		QUAL_LOCATION,

		/* PRECISION */
		QUAL_LOWP,
		QUAL_MEDIUMP,
		QUAL_HIGHP,
		QUAL_PRECISE,

		/* INVARIANCE */
		QUAL_INVARIANT,

		/* */
		QUAL_MAX
	};

	enum VARIABLE_STORAGE
	{
		INPUT,
		OUTPUT,
		UNIFORM,

		/* */
		STORAGE_MAX
	};

	enum VARIABLE_FLAVOUR
	{
		BASIC,
		ARRAY,
		INDEXED_BY_INVOCATION_ID
	};

	/* Public types */
	struct buffer
	{
		buffer(deqp::Context& context);
		~buffer();

		void bind() const;

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

		void generate(glw::GLenum target);
		void* map(glw::GLenum access) const;
		void unmap() const;

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

		void		release();
		glw::GLuint m_id;

	private:
		deqp::Context& m_context;
		glw::GLenum	m_target;
	};

	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;
	};

	struct shaderSource
	{
		shaderSource();
		shaderSource(const shaderSource& source);
		shaderSource(const glw::GLchar* source_code);

		struct shaderPart
		{
			std::string m_code;
			glw::GLint  m_length;
		};

		std::vector<shaderPart> m_parts;
		bool					m_use_lengths;
	};

	class shaderCompilationException : public std::exception
	{
	public:
		shaderCompilationException(const shaderSource& source, const glw::GLchar* message);

		virtual ~shaderCompilationException() throw()
		{
		}

		virtual const char* what() const throw();

		shaderSource m_shader_source;
		std::string  m_error_message;
	};

	class programLinkageException : public std::exception
	{
	public:
		programLinkageException(const glw::GLchar* error_message);

		virtual ~programLinkageException() throw()
		{
		}

		virtual const char* what() const throw();

		std::string m_error_message;
	};

	/** 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 build(const shaderSource& compute_shader, const shaderSource& fragment_shader,
				   const shaderSource& geometry_shader, const shaderSource& tesselation_control_shader,
				   const shaderSource& tesselation_evaluation_shader, const shaderSource& vertex_shader,
				   const glw::GLchar* const* varying_names, glw::GLuint n_varying_names, bool is_separable = false);

		void compile(glw::GLuint shader_id, const shaderSource& source) const;

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

		glw::GLint getAttribLocation(const glw::GLchar* name) const;

		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 getUniform1i(glw::GLuint location) const;
		glw::GLint getUniformLocation(const glw::GLchar* uniform_name) const;

		void link() const;
		void remove();

		void uniform(const glw::GLchar* uniform_name, TYPES type, glw::GLuint n_columns, glw::GLuint n_rows,
					 const void* data) const;

		void use() const;

		/* */
		static void printShaderSource(const shaderSource& source, tcu::MessageBuilder& log);

		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() const;

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

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

		void createBuffer(glw::GLenum internal_format, glw::GLuint buffer_id);

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

		void release();

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

		glw::GLuint m_id;

	private:
		glw::GLuint	m_buffer_id;
		deqp::Context& m_context;
		TEXTURE_TYPES  m_texture_type;
	};

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

		void generate();
		void bind();

		glw::GLuint m_id;

	private:
		deqp::Context& m_context;
	};

	/* Public typedefs */
	typedef std::vector<Utils::QUALIFIERS> qualifierSet;

	/* UniformN*v prototypes */
	typedef GLW_APICALL void(GLW_APIENTRY* uniformNdv)(glw::GLint, glw::GLsizei, const glw::GLdouble*);
	typedef GLW_APICALL void(GLW_APIENTRY* uniformNfv)(glw::GLint, glw::GLsizei, const glw::GLfloat*);
	typedef GLW_APICALL void(GLW_APIENTRY* uniformNiv)(glw::GLint, glw::GLsizei, const glw::GLint*);
	typedef GLW_APICALL void(GLW_APIENTRY* uniformNuiv)(glw::GLint, glw::GLsizei, const glw::GLuint*);
	typedef GLW_APICALL void(GLW_APIENTRY* uniformMatrixNdv)(glw::GLint, glw::GLsizei, glw::GLboolean,
															 const glw::GLdouble*);
	typedef GLW_APICALL void(GLW_APIENTRY* uniformMatrixNfv)(glw::GLint, glw::GLsizei, glw::GLboolean,
															 const glw::GLfloat*);

	/* Public static methods */
	/* UniformN*v routine getters */
	static uniformNdv getUniformNdv(const glw::Functions& gl, glw::GLuint n_rows);

	static uniformNfv getUniformNfv(const glw::Functions& gl, glw::GLuint n_rows);

	static uniformNiv getUniformNiv(const glw::Functions& gl, glw::GLuint n_rows);

	static uniformNuiv getUniformNuiv(const glw::Functions& gl, glw::GLuint n_rows);

	static uniformMatrixNdv getUniformMatrixNdv(const glw::Functions& gl, glw::GLuint n_columns, glw::GLuint n_rows);

	static uniformMatrixNfv getUniformMatrixNfv(const glw::Functions& gl, glw::GLuint n_columns, glw::GLuint n_rows);

	/* GLSL qualifiers */
	static bool doesContainQualifier(QUALIFIERS qualifier, const qualifierSet& qualifiers);

	static bool doesStageSupportQualifier(SHADER_STAGES stage, VARIABLE_STORAGE storage, QUALIFIERS qualifier);

	static const glw::GLchar* getQualifierString(QUALIFIERS qualifier);
	static std::string getQualifiersListString(const qualifierSet& qualifiers);

	static qualifierSet prepareQualifiersSet(const qualifierSet& in_qualifiers, SHADER_STAGES stage,
											 VARIABLE_STORAGE storage);

	/* Variable name */
	static std::string getBlockVariableDefinition(const Utils::qualifierSet& qualifiers, const glw::GLchar* type_name,
												  const glw::GLchar* variable_name);

	static std::string getBlockVariableReference(VARIABLE_FLAVOUR flavour, const glw::GLchar* variable_name,
												 const glw::GLchar* block_name);

	static std::string getVariableDefinition(VARIABLE_FLAVOUR flavour, const Utils::qualifierSet& qualifiers,
											 const glw::GLchar* type_name, const glw::GLchar* variable_name);

	static VARIABLE_FLAVOUR getVariableFlavour(Utils::SHADER_STAGES stage, Utils::VARIABLE_STORAGE storage,
											   const Utils::qualifierSet& qualifiers);

	static std::string getVariableName(Utils::SHADER_STAGES stage, Utils::VARIABLE_STORAGE storage,
									   const glw::GLchar* variable_name);

	static std::string getVariableReference(VARIABLE_FLAVOUR flavour, const glw::GLchar* variable_name);

	static void prepareBlockVariableStrings(Utils::SHADER_STAGES in_stage, Utils::VARIABLE_STORAGE in_storage,
											const Utils::qualifierSet& in_qualifiers, const glw::GLchar* in_type_name,
											const glw::GLchar* in_variable_name, const glw::GLchar* in_block_name,
											std::string& out_definition, std::string& out_reference);

	static void prepareVariableStrings(Utils::SHADER_STAGES in_stage, Utils::VARIABLE_STORAGE in_storage,
									   const Utils::qualifierSet& in_qualifiers, const glw::GLchar* in_type_name,
									   const glw::GLchar* in_variable_name, std::string& out_definition,
									   std::string& out_reference);

	/* Textures */
	static const glw::GLchar* getImageType(TEXTURE_TYPES type);
	static glw::GLuint getNumberOfCoordinates(TEXTURE_TYPES type);
	static const glw::GLchar* getSamplerType(TEXTURE_TYPES type);
	static glw::GLenum getTextureTartet(TEXTURE_TYPES type);
	static const glw::GLchar* getTextureTypeName(TEXTURE_TYPES type);

	/* Stuff */
	static bool checkUniformBinding(Utils::program& program, const glw::GLchar* name, glw::GLint expected_binding);
	static bool checkUniformArrayBinding(Utils::program& program, const glw::GLchar* name, glw::GLuint index,
										 glw::GLint expected_binding);
	static bool doesTypeSupportMatrix(TYPES type);
	static const glw::GLchar* getShaderStageName(SHADER_STAGES stage);
	static const glw::GLchar* getTypeName(TYPES type, glw::GLuint n_columns, glw::GLuint n_rows);
	static const glw::GLchar* getUtf8Character(UTF8_CHARACTERS character);
	static bool isExtensionSupported(deqp::Context& context, const glw::GLchar* extension_name);
	static bool isGLVersionAtLeast(const glw::Functions& gl, glw::GLint required_major, glw::GLint required_minor);
	static void replaceToken(const glw::GLchar* token, size_t& search_position, const glw::GLchar* text,
							 std::string& string);
	static void replaceAllTokens(const glw::GLchar* token, const glw::GLchar* text, std::string& string);
};

/** Base class for tests **/
class TestBase : public deqp::TestCase
{
public:
	/* Public methods */
	TestBase(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description);
	virtual ~TestBase()
	{
	}

	/* Public methods inherited from TestCase */
	virtual tcu::TestNode::IterateResult iterate(void);

protected:
	/* Methods to be implemented by child class */
	virtual void getShaderSourceConfig(glw::GLuint& out_n_parts, bool& out_use_lengths);
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source) = 0;
	virtual void prepareUniforms(Utils::program& program);
	virtual bool testInit();
	virtual bool testCompute()						 = 0;
	virtual bool testDrawArray(bool use_version_400) = 0;

	/* Methods available to child classes */
	const glw::GLchar* getStageSpecificLayout(Utils::SHADER_STAGES stage) const;
	const glw::GLchar* getVersionString(Utils::SHADER_STAGES stage, bool use_version_400) const;
	void initShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, Utils::shaderSource& out_source);
	int maxImageUniforms(Utils::SHADER_STAGES stage) const;

	/* Protected variables */
	bool m_is_compute_shader_supported;
	bool m_is_explicit_uniform_location;
	bool m_is_shader_language_420pack;

private:
	/* Private methods */
	bool test();
};

/** Base class for API tests */
class APITestBase : public TestBase
{
public:
	/* Public methods */
	APITestBase(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description);

	virtual ~APITestBase()
	{
	}

protected:
	/* Protected methods inherited from TestBase */
	virtual bool testCompute();
	virtual bool testDrawArray(bool use_version_400);

	/* Protected methods to be implemented by child class */
	virtual bool checkResults(Utils::program& program) = 0;

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source) = 0;
};

/** Base class for GLSL tests **/
class GLSLTestBase : public TestBase
{
public:
	/* Public methods */
	GLSLTestBase(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description);

	virtual ~GLSLTestBase()
	{
	}

protected:
	/* Protected methods inherited from TestBase */
	virtual bool testCompute();
	virtual bool testDrawArray(bool use_version_400);

	/* Protected methods to be implemented by child class */
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source) = 0;

	virtual const glw::GLchar* prepareSourceTexture(Utils::texture& texture);

	virtual void prepareVertexBuffer(const Utils::program& program, Utils::buffer& buffer, Utils::vertexArray& vao);

	virtual bool verifyAdditionalResults() const;
	virtual void releaseResource();

private:
	/* Private methods */
	void bindTextureToimage(Utils::program& program, Utils::texture& texture, const glw::GLchar* uniform_name) const;

	void bindTextureToSampler(Utils::program& program, Utils::texture& texture, const glw::GLchar* uniform_name) const;

	bool checkResults(Utils::texture& color_texture) const;

	void prepareFramebuffer(Utils::framebuffer& framebuffer, Utils::texture& color_texture) const;

	void prepareImage(Utils::program& program, Utils::texture& color_texture) const;

	/* Private constants */
	static const glw::GLenum m_color_texture_internal_format;
	static const glw::GLenum m_color_texture_format;
	static const glw::GLenum m_color_texture_type;
	static const glw::GLuint m_color_texture_width;
	static const glw::GLuint m_color_texture_height;
};

/** Base class for negative tests **/
class NegativeTestBase : public TestBase
{
public:
	/* Public methods */
	NegativeTestBase(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description);

	virtual ~NegativeTestBase()
	{
	}

protected:
	/* Protected methods inherited from TestBase */
	virtual bool testCompute();
	virtual bool testDrawArray(bool use_version_400);

	/* Protected methods to be implemented by child class */
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source) = 0;
};

/** Base class for "binding image" tests **/
class BindingImageTest : public GLSLTestBase
{
public:
	/* Public methods */
	BindingImageTest(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description);

	virtual ~BindingImageTest()
	{
	}

protected:
	/* Protected methods */
	void prepareBuffer(Utils::buffer& buffer, glw::GLuint color);

	void prepareTexture(Utils::texture& texture, const Utils::buffer& buffer, Utils::TEXTURE_TYPES texture_type,
						glw::GLuint color, glw::GLuint unit);

	bool verifyBuffer(const Utils::buffer& buffer) const;
	bool verifyTexture(const Utils::texture& texture) const;

	/* Protected constants */
	static const glw::GLuint m_width;
	static const glw::GLuint m_green_color;
	static const glw::GLuint m_height;
	static const glw::GLuint m_depth;
};

/** Test implementation, description follows:
 *
 * GLSL Tests:
 *
 *   * Unix-style new line continuation:
 *
 *    Run test with shader that contains line continuation and Unix-style (LF)
 *    new line characters inside:
 *
 *     - assignment expression (after and before '=' operator)
 *
 *     - vector variable initializer (after ',' in contructor)
 *
 *     - tokens (inside function name, inside type name, inside variable name).
 *       These tokens are later used to generate some color value, that
 *       is later verifed.
 *
 *     - preprocessor (#define) syntax  - inside and in between preprocessor
 *       tokens. These tokens are later used to generate some color value,
 *       that is later verifed.
 *
 *     - comments
 *
 *    For example test for line continuation inside preprocessor tokens may use
 *    following GLSL code:
 *
 *        #define ADD_ONE(XX) (X\\
         *        X + 1.0)
 *        vec4 getColor(float f) {
 *            return vec4(0.0, ADD_ONE(0.0), 0.0, 1.0);
 *        }
 *
 *     Where returned color is verified agains some reference value.
 *
 *
 *   * DOS-style line continuation:
 *
 *    Run same test with line continuation sign before DOS-style (CR+LF) new
 *    line character.
 *
 *
 *   * Multiple line continuations in same GLSL token:
 *
 *    Run test with shader that contains multiple (3 or more) line
 *    continuation and newlines inside same GLSL tokens (function or variable
 *    names).
 *
 *
 *   * Line continuation near GLSL shader source null-termination:
 *
 *    Run test with shader that contains line continuation character as the
 *    last character in null terminated shader string.
 *
 *
 *   * Line continuation near GLSL shader source end:
 *
 *    Run test with shader that contains line continuation character as the
 *    last character in not null terminated shader string (shader source length
 *    parameter is specified in glShaderSource call).
 *
 *
 *   * Line continuation near end of GLSL shader source string:
 *
 *    Run test with shader constructed by multple strings passed to
 *    glShaderSource. New line continuation characters placed as:
 *
 *     - last character of passed null terminated string
 *     - next-to-last character of passed null terminated string,
 *       followed by newline
 *     - last character of passed not null terminated string
 *     - next-to-last character of passed not null terminated string,
 *       followed by newline
 *
 *     Each string with line continuation should be followed by a next,
 *     non-empty string.
 **/
class LineContinuationTest : public GLSLTestBase
{
public:
	/* Public methods */
	LineContinuationTest(deqp::Context&);

	virtual ~LineContinuationTest()
	{
	}

protected:
	/* Protected methods inherited from GLSLTestBase */
	virtual void getShaderSourceConfig(glw::GLuint& out_n_parts, bool& out_use_lengths);

	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual const glw::GLchar* prepareSourceTexture(Utils::texture& texture);

	virtual void prepareVertexBuffer(const Utils::program& program, Utils::buffer& buffer, Utils::vertexArray& vao);

private:
	/* Private enums */
	enum CASES
	{
		ASSIGNMENT_BEFORE_OPERATOR = 0,
		ASSIGNMENT_AFTER_OPERATOR,
		VECTOR_VARIABLE_INITIALIZER,
		TOKEN_INSIDE_FUNCTION_NAME,
		TOKEN_INSIDE_TYPE_NAME,
		TOKEN_INSIDE_VARIABLE_NAME,
		PREPROCESSOR_TOKEN_INSIDE,
		PREPROCESSOR_TOKEN_BETWEEN,
		COMMENT,
		SOURCE_TERMINATION_NULL,
		SOURCE_TERMINATION_NON_NULL,
		PART_TERMINATION_NULL,
		PART_NEXT_TO_TERMINATION_NULL,
		PART_TERMINATION_NON_NULL,
		PART_NEXT_TO_TERMINATION_NON_NULL,

		/* DEBUG: there will be no line continuations at all */
		DEBUG_CASE
	};

	enum REPETITIONS
	{
		ONCE = 0,
		MULTIPLE_TIMES,
	};

	enum LINE_ENDINGS
	{
		UNIX = 0,
		DOS,
	};

	/* Private types */
	/** Declare test case
	 *
	 **/
	struct testCase
	{
		glw::GLuint m_case;
		glw::GLuint m_repetitions;
		glw::GLuint m_line_endings;
	};

	/* Private methods */
	const glw::GLchar* casesToStr(CASES cases) const;
	const glw::GLchar* getExpectedValueString() const;
	std::string		   getLineContinuationString() const;
	bool			   isShaderMultipart() const;
	const glw::GLchar* lineEndingsToStr(LINE_ENDINGS line_ending) const;
	void prepareComputShaderSource(Utils::shaderSource& shaderSource);

	void prepareShaderSourceForDraw(Utils::SHADER_STAGES stage, bool use_version_400, Utils::shaderSource& source);

	const glw::GLchar* repetitionsToStr(REPETITIONS repetitions) const;
	void replaceAllCaseTokens(std::string& source) const;
	bool useSourceLengths() const;

	/* Private constants */
	static const glw::GLuint  m_n_repetitions;
	static const glw::GLchar* m_texture_coordinates_name;

	/* Private variables */
	testCase m_test_case;
};

/** Test implementation, description follows:
 *
 * Correct numbering of lines with line continuations:
 *
 * Try to compile shader with line continuation schemes, followed
 * by __LINE__ macro capturing the current line number.
 * The value of __LINE__ is than validated against expected
 * constant. Expected value must account for continued lines,
 * for example in code below, they are two line continuations,
 * so the expected value is N - 2 (where N is the "raw" line number).
 *
 *     ivec4 glsl\\
         *     Test\\
         *     Func(float f) {
 *         obvious = error;
 *         return vec4(__LINE__, 0, 0, 1);
 *     }
 **/
class LineNumberingTest : public GLSLTestBase
{
public:
	/* Public methods */
	LineNumberingTest(deqp::Context&);

	virtual ~LineNumberingTest()
	{
	}

protected:
	/* Protected methods inherited from GLSLTestBase */
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);
};

/** Test implementation, description follows:
 *
 * * UTF-8 characters in comments:
 *
 *   Run test with shader that contains non-ASCII UTF-8 characters in comments.
 *   Use 2-byte UTF-8 characters (Latin-1 supplements, Greek, Hebrew, Cyril),
 *   3-byte (Chinese/Japanese/Korean), 4-byte (less common CJK).
 *   Also test 5 and 6 byte codes.
 *   Also test base plane ASCII characters encoded with redundant bytes,
 *   such as 'a' or <whitespace> encoded by 4 bytes.
 *
 *   Encode UTF-8 strings manually in test, either by c-array or '\0xNN' escape
 *   sequences.
 *
 *
 *  * UTF-8 characters in preprocessor:
 *
 *   Run test with shader that contains non-ASCII UTF-8 characters (arbitrary
 *   from above) in preprocessor tokens. Use preprocessor to strip these UTF-8
 *   characters, so they does not occur in preprocessed GLSL shader source.
 *
 *
 *  * Incomplete UTF-8 near GLSL shader source null-termination:
 *
 *   Run test with shader that contains comment with incomplete UTF-8
 *   character as the last character in null terminated shader string.
 *
 *
 *  * Incomplete UTF-8 near GLSL shader source end:
 *
 *   Run test with shader that contains comment with incomplete UTF-8
 *   character as the last character in not-null terminated shader string.
 *   Shader source length parameter is specified in glShaderSource call.
 **/
class UTF8CharactersTest : public GLSLTestBase
{
public:
	/* Public methods */
	UTF8CharactersTest(deqp::Context&);

	virtual ~UTF8CharactersTest()
	{
	}

	/* Protected methods inherited from GLSLTestBase */
	virtual void getShaderSourceConfig(glw::GLuint& out_n_parts, bool& out_use_lengths);

	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual const glw::GLchar* prepareSourceTexture(Utils::texture& texture);

private:
	/* Private enums */
	enum CASES
	{
		IN_COMMENT = 0,
		IN_PREPROCESSOR,
		AS_LAST_CHARACTER_NULL_TERMINATED,
		AS_LAST_CHARACTER_NON_NULL_TERMINATED,

		DEBUG_CASE
	};

	/* Private types */
	struct testCase
	{
		CASES				   m_case;
		Utils::UTF8_CHARACTERS m_character;
	};

	/* Private methods */
	const glw::GLchar* casesToStr() const;

	/* Private variables */
	testCase m_test_case;
};

/** Test implementation, description follows:
 *
 * * UTF-8 in after preprocessor, in GLSL syntax:
 *
 *   Try to compile shader that contains non-ASCII UTF-8 character after
 *   preprocessing. Expect compilation error.
 **/
class UTF8InSourceTest : public NegativeTestBase
{
public:
	/* Public methods */
	UTF8InSourceTest(deqp::Context&);

	virtual ~UTF8InSourceTest()
	{
	}

	/* Protected methods inherited from GLSLTestBase */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

private:
	/* Private variables */
	Utils::UTF8_CHARACTERS m_character;
};

/** Test implementation, description follows:
 *
 * * Check all implicit conversions on function return:
 *
 *    Run test with shader that verifies value being return by following
 *    function:
 *
 *        T1 f(T2 x, T2 y) { return x + y; }'
 *
 *   By substituting T1 and T2 typenames check following conversions:
 *    - int to uint
 *    - int to float
 *    - uint to float
 *    - int to double
 *    - uint to double
 *    - float to double
 *   Use scalars and vector types (all vector sizes). For conversions not
 *   involving ints or uints test also matrix types (all matrix sizes)
 *
 *   Call this function on literals, constant expressions and variables
 *   (variables should contain values that cannot be constant folded during
 *   compilation).
 **/
class ImplicitConversionsValidTest : public GLSLTestBase
{
public:
	/* Public methods */
	ImplicitConversionsValidTest(deqp::Context&);

	virtual ~ImplicitConversionsValidTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual bool testInit();

private:
	/* Private types */
	struct typesPair
	{
		Utils::TYPES m_t1;
		Utils::TYPES m_t2;
	};

	struct testCase
	{
		typesPair   m_types;
		glw::GLuint m_n_cols;
		glw::GLuint m_n_rows;
	};

	/* Private methods */
	const testCase& getCurrentTestCase();

	std::string getValueList(glw::GLuint n_columns, glw::GLuint n_rows);

	/* Private variables */
	testCase			  m_debug_test_case;
	std::vector<testCase> m_test_cases;
	glw::GLuint			  m_current_test_case_index;
};

/** Test implementation, description follows:
 *
 * * Check if uint to int conversion is forbidden:
 *
 *   Try to compile shader that returns uint value from function returning int.
 *   Expect shader compilation error. Use scalars and vector types.
 **/
class ImplicitConversionsInvalidTest : public NegativeTestBase
{
public:
	/* Public methods */
	ImplicitConversionsInvalidTest(deqp::Context&);

	virtual ~ImplicitConversionsInvalidTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

private:
	/* Private methods */
	std::string getValueList(glw::GLuint n_rows);

	/* Private variables */
	glw::GLuint m_current_test_case_index;
};

/** Test implementation, description follows:
 *
 * * Read-only variables:
 *
 *   Run shader which contains and uses following read-only variables:
 *    const float c1 = X1;
 *    const vec4 c2 = X2;
 *    const mat2 c3 = X3;
 *    const S c4 = X4;
 *    const vec4 c5[15] = X5;
 *
 *   Where X1..X5 are non-constant initializer expressions (expressions which
 *   cannot be constant folded).  S is a struct of scalar, vector and matrix
 *   transparent types. Verify value of each read-only variable.
 **/
class ConstDynamicValueTest : public GLSLTestBase
{
public:
	/* Public methods */
	ConstDynamicValueTest(deqp::Context&);

	virtual ~ConstDynamicValueTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
};

/** Test implementation, description follows:
 *
 * * Override value of read-only variable:
 *
 *   Try to compile shaders, that override value of constant variable.
 *   Use constant variable defined as:
 *     const float c1 = X1;
 *
 *   Where X1 is once a literal initializer and in another shader is a
 *   non-const-foldable non-constant variable.
 *
 *   Variable is non-const-foldable when it's value cannot be deduced during
 *   shader compilation. (As an example uniforms and varyings are non const
 *   foldable).
 *
 *   Expect compilation errors on any assignment to such variable.
 **/
class ConstAssignmentTest : public NegativeTestBase
{
public:
	/* Public methods */
	ConstAssignmentTest(deqp::Context&);

	virtual ~ConstAssignmentTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

private:
	/* Private variables */
	glw::GLuint m_current_test_case_index;
};

/** Test implementation, description follows:
 *
 * * Read-only variable use in place of constant expression:
 *
 *   Try to compile shader, that tries to force constant folding on const
 *   variable, when constant variable was initialized with non-constant,
 *   non const foldable expression. For example:
 *
 *   vec4 glslTestFunc(float f) {
 *        const float fConst1 = f;
 *        float a[f]; //force constant folding of f.
 *        return vec4(a[0]);
 *    }
 *    ...
 *    glslTestFunc(gl_FragCoord.x);
 **/
class ConstDynamicValueAsConstExprTest : public NegativeTestBase
{
public:
	/* Public methods */
	ConstDynamicValueAsConstExprTest(deqp::Context&);

	virtual ~ConstDynamicValueAsConstExprTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);
};

/** Test implementation, description follows:
 *
 * * Input variable qualifier order:
 *
 *   Run shader which uses input variable, that is declared with all
 *   permutations of following qualifiers:
 *
 *    storage qualifiers: in
 *    interpolation qualifiers: (none), flat, noperespective, smooth
 *    auxaliary qualifiers: (none), patch, sample, centroid
 *    precision qualifiers: (none), precise
 *    invariance qualifiers: (none), invariant
 *    layout qualifiers: (none), layout(location = 0)
 *
 *   Test fragment, tessellation evaluation, tessellation control and geometry
 *   shader inputs.  Skip illegal permutations: flat interpolation qualifier
 *   used with non empty auxaliary qualifier, patch qualifier outside
 *   tessellation shaders. Also skip non-flat interpolation qualifiers for
 *   vertex, tessellation and geometry shaders.
 *
 * * Input variable qualifers used multiple times:
 *
 *   Same as above, but use some qualifiers multiple times.
 *
 * * Output variable qualifier order:
 *   Run shader which uses output variable, that is declared with all
 *    permutations of following qualifiers:
 *
 *     storage qualifiers: out
 *     interpolation qualifiers: (none), flat, noperespective, smooth
 *     auxaliary qualifiers: (none), patch, sample, centroid
 *     precision qualifiers: (none), precise
 *     invariance qualifiers: (none), invariant
 *     layout qualifiers: (none), layout(location = 0)
 *
 *    All permutations above following sets should be used (so all combinations
 *    of qualifiers are tested and all orderings of such combinations are tested).
 *    Used shader input must match output from earlier shader stage.
 *
 *    Test tessellation evaluation, tessellation control, geometry and vertex
 *    shader inputs. Skip illegal permutations: flat interpolation qualifier used
 *    with non empty auxaliary qualifier, patch qualifier outside tessellation
 *    shaders.
 *
 *
 * * Output variable qualifers used multiple times:
 *
 *   Same as above, but use some qualifiers multiple times.
 **/
class QualifierOrderTest : public GLSLTestBase
{
public:
	/* Public methods */
	QualifierOrderTest(deqp::Context&);

	virtual ~QualifierOrderTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareVertexBuffer(const Utils::program& program, Utils::buffer& buffer, Utils::vertexArray& vao);

	virtual bool testInit();

private:
	/* Private methods */
	const Utils::qualifierSet& getCurrentTestCase();

	/* Private varaibles */
	std::vector<Utils::qualifierSet> m_test_cases;
	glw::GLuint						 m_current_test_case_index;
};

/** Test implementation, description follows:
 *
 * * Input block interface qualifier order:
 *
 *   Run shaders with same variable qualifications as above used for input
 *   interface block member.
 *
 *    Use following block declaration:
 *      in BLOCK {
 *          vec4 color;
 *      };
 *
 *   Test fragment shader, tessellation evaluation, tessellation control and
 *   geometry shader inputs. Skip illegal permutations, same as in previous
 *   test cases.
 *
 *
 * * Input block interface qualifers used multiple times:
 *
 *   Same as above, but use some qualifiers multiple times.
 *
 * * Output block interface qualifier order:
 *   Run shaders with same variable qualifications as above used for output
 *   interface block member.
 *
 *   Use following block declaration:
 *     out BLOCK {
 *         vec4 color;
 *     };
 *
 *   Test tessellation evaluation, tessellation control, geometry and vertex
 *   shader outputs. Skip illegal permutations, same as in previous test case.
 *
 *
 * * Output block interface qualifers used multiple times:
 *
 *   Same as above, but use some qualifiers multiple times.
 **/
class QualifierOrderBlockTest : public GLSLTestBase
{
public:
	/* Public methods */
	QualifierOrderBlockTest(deqp::Context&);

	virtual ~QualifierOrderBlockTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareVertexBuffer(const Utils::program& program, Utils::buffer& buffer, Utils::vertexArray& vao);

	virtual bool testInit();

private:
	/* Private methods */
	const Utils::qualifierSet& getCurrentTestCase();

	/* Private varaibles */
	std::vector<Utils::qualifierSet> m_test_cases;
	glw::GLuint						 m_current_test_case_index;
};

/** Test implementation, description follows:
 *
 * * Uniform variable qualifier order:
 *
 *   Run shaders which use uniform, that is declared with all permutations of
 *   'precise', 'uniform', and 'layout(...)' qualifiers.
 *
 *
 * * Uniform qualifers used multiple times:
 *
 *   Same as above, but use some qualifiers multiple times.
 **/
class QualifierOrderUniformTest : public GLSLTestBase
{
public:
	/* Public methods */
	QualifierOrderUniformTest(deqp::Context&);

	virtual ~QualifierOrderUniformTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);

	virtual bool testInit();

private:
	/* Private methods */
	const Utils::qualifierSet& getCurrentTestCase();

	/* Private varaibles */
	std::vector<Utils::qualifierSet> m_test_cases;
	glw::GLuint						 m_current_test_case_index;
};

/** Test implementation, description follows:
 *
 * * Function inout parameter qualifier order:
 *
 *   Run shaders which use function, that has inout parameter declared with all
 *   permutations of 'lowp' or 'mediump' or 'highp', 'precise' qualifiers.
 *
 *   Also run with some qualifiers used multiple times.
 **/
class QualifierOrderFunctionInoutTest : public GLSLTestBase
{
public:
	/* Public methods */
	QualifierOrderFunctionInoutTest(deqp::Context&);

	virtual ~QualifierOrderFunctionInoutTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual bool testInit();

private:
	/* Private methods */
	const Utils::qualifierSet& getCurrentTestCase();

	/* Private varaibles */
	std::vector<Utils::qualifierSet> m_test_cases;
	glw::GLuint						 m_current_test_case_index;
};

/** Test implementation, description follows:
 *
 * * Function input parameter qualifier order:
 *
 *   Run shaders which use function, that has 'in' parameter declared with all
 *   permutations of 'in', 'lowp' or 'mediump' or 'highp', 'precise', 'const'
 *   qualifiers.
 *
 *   Also run with some qualifiers used multiple times.
 **/
class QualifierOrderFunctionInputTest : public GLSLTestBase
{
public:
	/* Public methods */
	QualifierOrderFunctionInputTest(deqp::Context&);

	virtual ~QualifierOrderFunctionInputTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual bool testInit();

private:
	/* Private methods */
	const Utils::qualifierSet& getCurrentTestCase();

	/* Private varaibles */
	std::vector<Utils::qualifierSet> m_test_cases;
	glw::GLuint						 m_current_test_case_index;
};

/** Test implementation, description follows:
 *
 * * Function output parameter qualifier order:
 *
 *   Run shaders which use function, that has out parameter declared with all
 *   permutations of  'lowp' or 'mediump' or 'highp', 'precise' qualifiers.
 *
 *   Also run with some qualifiers used multiple times.
 **/
class QualifierOrderFunctionOutputTest : public GLSLTestBase
{
public:
	/* Public methods */
	QualifierOrderFunctionOutputTest(deqp::Context&);

	virtual ~QualifierOrderFunctionOutputTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual bool testInit();

private:
	/* Private methods */
	const Utils::qualifierSet& getCurrentTestCase();

	/* Private varaibles */
	std::vector<Utils::qualifierSet> m_test_cases;
	glw::GLuint						 m_current_test_case_index;
};

/** Test implementation, description follows:
 *
 * * Input variable layout qualifiers override:
 *
 *   Run shaders which use input variable, qualified with multiple layout
 *   qualifiers. For example:
 *
 *       layout(location = 3) layout(location = 2) out vec4 gColor
 *
 *
 * * Geometry shader layout qualifiers override:
 *
 *   Run shader which use multiple global geometry shader qualifiers.
 *   For example:
 *
 *       layout( triangle_strip, max_vertices = 2 ) layout( max_vertices = 3) out;'
 *
 *
 * * Tesselation shader layout qualifiers override:
 *
 *   Run shader which use multiple tesselation shader qualifiers, for example:
 *
 *       layout(vertices = 2) layout(vertices = 4) out;
 **/
class QualifierOverrideLayoutTest : public GLSLTestBase
{
public:
	/* Public methods */
	QualifierOverrideLayoutTest(deqp::Context&);

	virtual ~QualifierOverrideLayoutTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareVertexBuffer(const Utils::program& program, Utils::buffer& buffer, Utils::vertexArray& vao);
};

/** Test implementation, description follows:
 *
 * * 'binding' qualified used for uniform block:
 *
 *   Create shader program which uses uniform block declaration
 *   with 'binding' layout qualifier specified. For example:
 *
 *        layout(std140, binding = 2) uniform BLOCK {
 *           vec4 color;
 *        } block;
 *
 *   Bind filled uniform buffer object to binding point 2.
 *
 *   Run shader program, validate uniform buffer contents in shader.
 *
 *
 * * 'binding' layout qualifier used for multiple uniform blocks in same shader:
 *
 *   Same as above, but use multiple uniform block declarations, each with
 *   different 'layout(binding = X)' qualifier. Validate contents of all
 *   uniform buffers in shader.
 *
 *
 * * 'binding' layout qualifier used for uniform block in different shader
 *    stages:
 *
 *   Link multiple shaders of different stage that use same uniform block.
 *   All uniform block declarations use same 'binding' layout qualifier.
 *
 *   Validate contents of uniform buffer in all shader stages.
 **/
class BindingUniformBlocksTest : public GLSLTestBase
{
public:
	/* Public methods */
	BindingUniformBlocksTest(deqp::Context&);

	virtual ~BindingUniformBlocksTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual void releaseResource();

private:
	/* Private variables */
	Utils::buffer m_goku_buffer;
	Utils::buffer m_vegeta_buffer;
	Utils::buffer m_children_buffer;
};

/** Test implementation, description follows:
 *
 * * 'binding' layout qualifier used only once for same uniform block in
 *   different shader stages:

 *   Link multiple shaders of different stage that use same uniform block.
 *   'binding' layout qualifier is used only in one shader stage, other shader
 *   stages does not specify layout qualifier.
 *
 *   Validate contents of uniform buffer in all shader stages.
 **/
class BindingUniformSingleBlockTest : public GLSLTestBase
{
public:
	/* Public methods */
	BindingUniformSingleBlockTest(deqp::Context&);

	virtual ~BindingUniformSingleBlockTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual void releaseResource();

private:
	/* Private variables */
	Utils::buffer		 m_goku_buffer;
	Utils::SHADER_STAGES m_test_stage;
};

/** Test implementation, description follows:
 *
 * * 'binding' layout qualifier used with uniform block array.
 *
 *   Create shader program which uses uniform block array, with 'binding'
 *   layout qualifier specified, example:
 *
 *       layout(std140, binding = 2) uniform BLOCK {
 *          vec4 color;
 *       } block[14];
 *
 *   Bind filled uniform buffer objects to binding points 2..16. Validate
 *   contents of all uniform buffers in shader.
 *
 * * bindings of array of uniform blocks:
 *
 *   Check if uniform buffer array elements automatically get subsequent
 *   binding values, when their interface is specified using 'binding'
 *   layout qualifier. Use glGetActiveUniformBlockiv.
 **/
class BindingUniformBlockArrayTest : public GLSLTestBase
{
public:
	/* Public methods */
	BindingUniformBlockArrayTest(deqp::Context&);

	virtual ~BindingUniformBlockArrayTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual void releaseResource();

private:
	/* Private methods */
	void checkBinding(Utils::program& program, glw::GLuint index, glw::GLint expected_binding);

	/* Private variables */
	Utils::buffer m_goku_00_buffer;
	Utils::buffer m_goku_01_buffer;
	Utils::buffer m_goku_02_buffer;
	Utils::buffer m_goku_03_buffer;
	Utils::buffer m_goku_04_buffer;
	Utils::buffer m_goku_05_buffer;
	Utils::buffer m_goku_06_buffer;
	Utils::buffer m_goku_07_buffer;
	Utils::buffer m_goku_08_buffer;
	Utils::buffer m_goku_09_buffer;
	Utils::buffer m_goku_10_buffer;
	Utils::buffer m_goku_11_buffer;
	Utils::buffer m_goku_12_buffer;
	Utils::buffer m_goku_13_buffer;
};

/** Test implementation, description follows:
 *
 * * Default binding value:
 *
 *   Create shader program, with uniform buffer interface declared without
 *   'binding' layout qualifier. Use glGetActiveUniformBlockiv to test if
 *   default 'binding' value is 0.
 **/
class BindingUniformDefaultTest : public APITestBase
{
public:
	/* Public methods */
	BindingUniformDefaultTest(deqp::Context&);

	virtual ~BindingUniformDefaultTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool checkResults(Utils::program& program);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);
};

/** Test implementation, description follows:
 *
 * * Override binding value from API:
 *
 *   Create a shader program with uniform buffer interface declared with
 *   'layout(..., binding = 3)'. Use glUniformBlockBinding to change binding
 *   value to 11. Test if binding point 11 is now used during rendering.
 *   Test if binding point 11 is returned when enumerating interface with
 *   glGetActiveUniformBlockiv.
 **/
class BindingUniformAPIOverirdeTest : public GLSLTestBase
{
public:
	/* Public methods */
	BindingUniformAPIOverirdeTest(deqp::Context&);

	virtual ~BindingUniformAPIOverirdeTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual void releaseResource();

private:
	/* Private variables */
	Utils::buffer m_goku_buffer;
};

/** Test implementation, description follows:
 *
 * * 'binding' layout qualifier used with global uniform
 *
 *   Use 'binding' layout qualifier on global (default block) uniform.
 *   Expect shader compilation error.
 **/
class BindingUniformGlobalBlockTest : public NegativeTestBase
{
public:
	/* Public methods */
	BindingUniformGlobalBlockTest(deqp::Context&);

	virtual ~BindingUniformGlobalBlockTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);
};

/** Test implementation, description follows:
 *
 * * Wrong value for 'binding' layout qualifier.
 *
 *   Use -1, variable name, 'std140' as binding value.
 *   Expect shader compilation error in each case.
 *
 * * Missing value for 'binding' layout qualifier.
 *
 *   Expect shader compilation error in following declaration:
 *
 *       layout(std140, binding) uniform BLOCK {
 *          vec4 color;
 *       } block[14];
 **/
class BindingUniformInvalidTest : public NegativeTestBase
{
public:
	/* Public methods */
	BindingUniformInvalidTest(deqp::Context&);

	virtual ~BindingUniformInvalidTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

private:
	/* Private enums */
	enum TESTCASES
	{
		NEGATIVE_VALUE,
		VARIABLE_NAME,
		STD140,
		MISSING,

		/* */
		TEST_CASES_MAX
	};

	/* Private methods */
	const glw::GLchar* getCaseString(TESTCASES test_case);

	/* Provate variables */
	TESTCASES m_case;
};

/** Test implementation, description follows:
 *
 * * 'binding' qualified used for sampler uniform:
 *
 *   Create shader program which uses sampler uniform declaration with
 *   'binding' layout qualifier specified. For example:
 *
 *        layout(binding = 2) uniform sampler2D s;
 *
 *   Bind 2D texture to texture unit GL_TEXTURE2.
 *
 *   Run shader program, validate binding by sampling from texture in shader.
 *
 *
 * * 'binding' layout qualifier used for multiple sampler uniforms in same
 *   shader:
 *
 *   Same as above, but use multiple sampler uniform declarations, each with
 *   different 'layout(binding = X)' qualifier. Validate bindings of all
 *   samplers by sampling textures in shader.
 *
 *
 * * 'binding' layout qualifier used for sampler uniform in different shader
 *   stages:
 *
 *
 *   Link multiple shaders of different stages that use same sampler uniform.
 *   All sampler uniform declarations use same 'binding' layout qualifier.
 *
 *   Validate binding of sampler by sampling texture in shader.
 *
 * * 'binding layout qualifier used with sampler uniforms of various types.
 *
 *   Create shader program which uses samplers of type: samplerBuffer,
 *   sampler2D, sampler2DRect, sampler2DArray, sampler3D, samplerCubeMap,
 *   sampler1D, sampler1DArray.
 *
 *   Each sampler declaration uses 'binding' qualifier with different value.
 *
 *   Validate bindings of all samplers by sampling bound textures in shader.
 **/
class BindingSamplersTest : public GLSLTestBase
{
public:
	/* Public methods */
	BindingSamplersTest(deqp::Context&);

	virtual ~BindingSamplersTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual void releaseResource();

private:
	/* Private methods */
	void prepareTexture(Utils::texture& texture, Utils::TEXTURE_TYPES texture_type, glw::GLuint color);

	/* Private variables */
	Utils::texture		 m_goku_texture;
	Utils::texture		 m_vegeta_texture;
	Utils::texture		 m_trunks_texture;
	Utils::buffer		 m_buffer;
	Utils::TEXTURE_TYPES m_test_case;
};

/** Test implementation, description follows:
 *
 * * 'binding' layout qualifier used only once for same sampler uniform in
 *   different shader stages:
 *
 *   Link multiple shaders of different stages that use same sampler uniform.
 *   'binding' layout qualifier is used only in one shader stage, other shader
 *   stages does not specify layout qualifier.
 *
 *   Validate binding of sampler by sampling texture in all shader stages.
 **/
class BindingSamplerSingleTest : public GLSLTestBase
{
public:
	/* Public methods */
	BindingSamplerSingleTest(deqp::Context&);

	virtual ~BindingSamplerSingleTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual void releaseResource();

private:
	/* Private variables */
	Utils::texture		 m_goku_texture;
	Utils::SHADER_STAGES m_test_stage;
};

/** Test implementation, description follows:
 *
 * * 'binding' layout qualifier used with sampler uniform array.
 *
 *   Create shader program which uses sampler uniform array, with 'binding'
 *   layout qualifier specified, example:
 *
 *       layout(binding = 2) uniform sampler2D s[7];
 *
 *   Bind textures to texture units 2..9. Validate bindings of all samplers
 *   by sampling bound textures in shader.
 *
 * * bindings of array of sampler uniforms
 *
 *   Check if sampler uniform array elements automatically get subsequent
 *   binding values, when their interface is specified using 'binding'
 *   layout qualifier. Use glGetUniformiv.
 **/
class BindingSamplerArrayTest : public GLSLTestBase
{
public:
	/* Public methods */
	BindingSamplerArrayTest(deqp::Context&);

	virtual ~BindingSamplerArrayTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual void releaseResource();

private:
	/* Private methods */
	void checkBinding(Utils::program& program, glw::GLuint index, glw::GLint expected_binding);

	/* Private variables */
	Utils::texture m_goku_00_texture;
	Utils::texture m_goku_01_texture;
	Utils::texture m_goku_02_texture;
	Utils::texture m_goku_03_texture;
	Utils::texture m_goku_04_texture;
	Utils::texture m_goku_05_texture;
	Utils::texture m_goku_06_texture;
};

/** Test implementation, description follows:
 *
 * * Default binding value:
 *
 *   Create shader program, with sampler uniform declared without 'binding'
 *   layout qualifier. Use glGetUniformiv to test, if default 'binding' value
 *   is 0.
 **/
class BindingSamplerDefaultTest : public APITestBase
{
public:
	/* Public methods */
	BindingSamplerDefaultTest(deqp::Context&);

	virtual ~BindingSamplerDefaultTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool checkResults(Utils::program& program);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);
};

/** Test implementation, description follows:
 *
 * * Override binding value from API:
 *
 *   Create a shader program with sampler uniform buffer declared with
 *   'layout(binding = 3)'. Use glUniform1i to change binding value to 11.
 *   Test if binding point 11 is now used during rendering.
 *   Test if binding point 11 is returned querying interface with
 *   glGetUniformiv.
 **/
class BindingSamplerAPIOverrideTest : public GLSLTestBase
{
public:
	/* Public methods */
	BindingSamplerAPIOverrideTest(deqp::Context&);

	virtual ~BindingSamplerAPIOverrideTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual void releaseResource();

private:
	/* Private variables */
	Utils::texture m_goku_texture;
};

/** Test implementation, description follows:
 *
 * * Wrong value for 'binding' layout qualifier.
 *
 *   Use -1 or variable name as binding value. Expect shader compilation
 *   error in each case.
 *
 *
 * * Missing value for 'binding' layout qualifier.
 *
 *   Expect shader compilation error in following declaration:
 *
 *       layout(binding) uniform sampler2D s;
 **/
class BindingSamplerInvalidTest : public NegativeTestBase
{
public:
	/* Public methods */
	BindingSamplerInvalidTest(deqp::Context&);
	virtual ~BindingSamplerInvalidTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

private:
	/* Private enums */
	enum TESTCASES
	{
		NEGATIVE_VALUE,
		VARIABLE_NAME,
		STD140,
		MISSING,

		/* */
		TEST_CASES_MAX
	};

	/* Private methods */
	const glw::GLchar* getCaseString(TESTCASES test_case);

	/* Provate variables */
	TESTCASES m_case;
};

/** Test implementation, description follows:
 *
 * * 'binding' qualified used for image uniform:
 *
 *   Create shader program which uses image uniform declaration with
 *   'binding' layout qualifier specified. For example:
 *
 *       layout(rgba32f, binding = 2) image2D i;
 *
 *   Bind 2D texture to image unit 2.
 *
 *   Run shader program, validate binding by storing values to image in shader.
 *
 *
 * * 'binding' layout qualifier used for multiple image uniforms in same
 *   shader:
 *
 *   Same as above, but use multiple image uniform declarations, each with
 *   different 'layout(binding = X)' qualifier. Validate bindings of all
 *   samplers by storing values to textures in shader.
 *
 *
 * * 'binding' layout qualifier used for image uniform in different shader
 *   stages:
 *
 *   Link multiple shaders of different stages that use same image uniform.
 *   All uniform uniform declarations use same 'binding' layout qualifier.
 *
 *   Validate binding of image uniform by storing values to image in shader.
 *
 *
 * * 'binding' layout qualifier used with image uniforms of various types.
 *
 *   Create shader program which uses samplers of type: imageBuffer,
 *   image2D, image2DRect, image2DArray, image3D, imageCubeMap,
 *   image1D, image1DArray.
 *
 *   Each image declaration uses 'binding' qualifier with different value.
 *
 *   Validate bindings of all image uniforms by storing values to textures
 *   in shader.
 **/
class BindingImagesTest : public BindingImageTest
{
public:
	/* Public methods */
	BindingImagesTest(deqp::Context&);

	virtual ~BindingImagesTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual bool verifyAdditionalResults() const;
	virtual void releaseResource();

private:
	/* Private variables */
	Utils::texture		 m_goku_texture;
	Utils::texture		 m_vegeta_texture;
	Utils::texture		 m_trunks_texture;
	Utils::buffer		 m_goku_buffer;
	Utils::buffer		 m_vegeta_buffer;
	Utils::buffer		 m_trunks_buffer;
	Utils::TEXTURE_TYPES m_test_case;

	/* Private constant */
	static const glw::GLuint m_goku_data;
	static const glw::GLuint m_vegeta_data;
	static const glw::GLuint m_trunks_data;
};

/** Test implementation, description follows:
 *
 * * 'binding' layout qualifier used only once for same image uniform in
 different shader stages:
 *
 *   Link multiple shaders of different stages that use same image uniform.
 *   'binding' layout qualifier is used only in one shader stage, other shader
 *   stages does not specify layout qualifier.
 *
 *   Validate binding of image uniform by storing values to image in shader.
 **/
class BindingImageSingleTest : public BindingImageTest
{
public:
	/* Public methods */
	BindingImageSingleTest(deqp::Context&);

	virtual ~BindingImageSingleTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual bool verifyAdditionalResults() const;
	virtual void releaseResource();

private:
	/* Private variables */
	Utils::texture		 m_goku_texture;
	Utils::SHADER_STAGES m_test_stage;
};

/** Test implementation, description follows:
 *
 * * 'binding' layout qualifier used with image uniform array.
 *
 *   Create shader program which uses image uniform array, with 'binding'
 *   layout qualifier specified, example:
 *
 *       layout(rgba32f, binding = 2) uniform image2D i[7];
 *
 *   Bind textures to image units 2..9. Validate bindings of all
 *   image uniforms by storing values to textures in shader.
 *
 *
 * * Bindings of array of image uniforms
 *
 *   Check if image uniform array elements automatically get subsequent
 *   binding values, when their interface is specified using 'binding'
 *   layout qualifier. Use glGetUniformiv.
 **/
class BindingImageArrayTest : public BindingImageTest
{
public:
	/* Public methods */
	BindingImageArrayTest(deqp::Context&);

	virtual ~BindingImageArrayTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual void releaseResource();

private:
	/* Private methods */
	void checkBinding(Utils::program& program, glw::GLuint index, glw::GLint expected_binding);

	/* Private variables */
	Utils::texture m_goku_00_texture;
	Utils::texture m_goku_01_texture;
	Utils::texture m_goku_02_texture;
	Utils::texture m_goku_03_texture;
	Utils::texture m_goku_04_texture;
	Utils::texture m_goku_05_texture;
	Utils::texture m_goku_06_texture;
};

/** Test implementation, description follows:
 *
 * * Default binding value:
 *
 *   Create shader program, with image uniform declared without 'binding'
 *   layout qualifier. Use glGetUniformiv to test if default 'binding' value
 *   is 0.
 **/
class BindingImageDefaultTest : public APITestBase
{
public:
	/* Public methods */
	BindingImageDefaultTest(deqp::Context&);

	virtual ~BindingImageDefaultTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool checkResults(Utils::program& program);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);
};

/** Test implementation, description follows:
 *
 * * Override binding value from API:
 *
 *   Create a shader program with image uniform buffer declared with
 *   'layout(binding = 3)'. Use glUniform1i to change binding value to 11.
 *   Test if binding point 11 is now used during rendering.
 *   Test if binding point 11 is returned querying interface with
 *   glGetUniformiv.
 **/
class BindingImageAPIOverrideTest : public BindingImageTest
{
public:
	/* Public methods */
	BindingImageAPIOverrideTest(deqp::Context&);

	virtual ~BindingImageAPIOverrideTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual void releaseResource();

private:
	/* Private variables */
	Utils::texture m_goku_texture;
};

/** Test implementation, description follows:
 *
 * * Wrong value for 'binding' layout qualifier.
 *
 *   Use -1, 'rgba32f' or variable name as binding value. Expect shader
 *   compilation error in each case.
 *
 *
 * * Missing value for 'binding' layout qualifier.
 *
 *   Expect shader compilation error in following declaration:
 *
 *      layout(rgba32f, binding) uniform image2D s;
 **/
class BindingImageInvalidTest : public NegativeTestBase
{
public:
	/* Public methods */
	BindingImageInvalidTest(deqp::Context&);

	virtual ~BindingImageInvalidTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

private:
	/* Private enums */
	enum TESTCASES
	{
		NEGATIVE_VALUE,
		VARIABLE_NAME,
		STD140,
		MISSING,

		/* */
		TEST_CASES_MAX
	};

	/* Private methods */
	const glw::GLchar* getCaseString(TESTCASES test_case);

	/* Provate variables */
	TESTCASES m_case;
};

/** Test implementation, description follows:
 *
 * * Vectors initialized using curly brace initializer lists:
 *
 *   Test expressions like:
 *       vec4 a = { 0.0, 1.0, 2.0, 3.0 };
 *
 *   Test all vector sizes.
 *   Verify if all components were set correctly.
 *
 *
 * * Matrices initialized using curly brace initializer lists:
 *
 *   Test expressions like:
 *       mat2   a = {{ 0.0, 1.0 }, { 2.0, 3.0 }};
 *       mat2x3 b = {{ 0.0, 1.0,  2.0 }, { 3.0, 4.0, 5.0 }};
 *
 *       Test all square matrix sizes. Check all non-square matrix sizes.
 *
 *       Verify if all components were set correctly.
 *
 *
 * * Matrix rows initialized using curly brace initializer lists:
 *
 *   Test expressions like:
 *       mat2   a = { vec2( 0.0, 1.0 ), vec2( 2.0, 3.0 ) };
 *       mat2x3 b = {vec3( 0.0, 1.0, 2.0), vec3( 3.0, 4.0, 5.0 )};
 *
 *       Test all square matrix sizes. Check all non-square matrix sizes.
 *
 *       Verify if all components were set correctly.
 *
 *
 * * Arrays initialized using curly brace initializer lists:
 *
 *   - Check arrays of scalars.
 *
 *   - Check arrays of vectors. Vectors initialized using *vec*(...) constructor.
 *
 *   - Check arrays of vectors. Vectors initialized initializer lists.
 *
 *   - Check arrays of matrices. Matrices initialized using *mat*(...) contructor.
 *
 *   - Check arrays of matrices. Matrices initialized initializer lists.
 *
 *   Verify if all components were set correctly.
 *
 *
 * * Structures of transparent types initialized using initializer lists:
 *
 *   Check arrays of structures also.
 *
 *   Test expressions like:
 *      struct S { float f; int i; uint u; }
 *      S a = {1.0, 2, -3};
 *      S b[3] = { S(1.0, 2, -3 ), { 3.0, 5, -6 }, { 7.0, 8, -9 } };
 *      S c[3] = { { 1.0, 2, -3 }, { 3.0, 5, -6 }, { 7.0, 8, -9 } };
 *
 *   Verify if all components were set correctly.
 *
 *
 * * Nested structures and arrays initialized using initializer lists:
 *
 *   - Check nested structures. Members initialized using <struct-type>(...)
 *     constructor.
 *
 *   - Check nested structures. Members initialized using initializer lists.\
         *
 *   - Check nested structures with multiple nesting levels.
 *
 *   - Check structures of arrays of structures. Initialize all members using
 *     initializer lists.
 *
 *   - Check structures of arrays of structures. Use mix of constructors and
 *     initializer lists to initialize members.
 *
 *   - Check arrays of structures, containing structures. Initialize all
 *     members using initializer lists.
 *
 *   - Check arrays of structures containing structures. Use mix of
 *     constructors and initializer lists to initialize members.
 *
 *   - Check structures containing structures, that contain arrays.
 *     Initialize all members using initializer lists.
 *
 *   - Check structures containing structures, that contain arrays. Use mix of
 *     constructors and initializer lists to initialize members.
 *
 *   Verify if all components were set correctly.
 *
 *
 * * Unsized arrays initialized with initialer lists:
 *
 *   Test expressions like:
 *       int i[] = { 1, 2, 3 };
 *       S b[] = { S(1.0, 2, -3 ), { 3.0, 5, -6 }, { 7.0, 8, -9 } };
 *       S c[] = { { 1.0, 2, -3 }, { 3.0, 5, -6 }, { 7.0, 8, -9 } };
 *
 *   Verify if all components were set correctly.
 **/
class InitializerListTest : public GLSLTestBase
{
public:
	/* Public methods */
	InitializerListTest(deqp::Context&);

	virtual ~InitializerListTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual bool testInit();

private:
	/* Private enums */
	enum TESTED_INITIALIZERS
	{
		VECTOR,
		MATRIX,
		MATRIX_ROWS,
		STRUCT,
		ARRAY_SCALAR,
		ARRAY_VECTOR_CTR,
		ARRAY_VECTOR_LIST,
		ARRAY_MATRIX_CTR,
		ARRAY_MATRIX_LIST,
		ARRAY_STRUCT,
		NESTED_STRUCT_CTR,
		NESTED_STRUCT_LIST,
		NESTED_STURCT_ARRAYS_STRUCT_LIST,
		NESTED_STURCT_ARRAYS_STRUCT_MIX,
		NESTED_ARRAY_STRUCT_STRUCT_LIST,
		NESTED_ARRAY_STRUCT_STRUCT_MIX,
		NESTED_STRUCT_STRUCT_ARRAY_LIST,
		NESTED_STRUCT_STRUCT_ARRAY_MIX,
		UNSIZED_ARRAY_SCALAR,
		UNSIZED_ARRAY_VECTOR,
		UNSIZED_ARRAY_MATRIX,
		UNSIZED_ARRAY_STRUCT,

		/* */
		TESTED_INITIALIZERS_MAX
	};

	/* Private types */
	struct testCase
	{
		TESTED_INITIALIZERS m_initializer;

		glw::GLuint m_n_cols;
		glw::GLuint m_n_rows;
	};

	/* Private methods */
	std::string getArrayDefinition();
	std::string getExpectedValue();
	std::string getInitialization();
	void		logTestCaseName();
	std::string getSum();
	std::string getTypeDefinition();
	std::string getTypeName();

	std::string getVectorArrayCtr(glw::GLuint columns, glw::GLuint size);

	std::string getVectorArrayList(glw::GLuint columns, glw::GLuint size);

	std::string getVectorConstructor(glw::GLuint column, glw::GLuint size);

	std::string getVectorInitializer(glw::GLuint column, glw::GLuint size);

	std::string getVectorArraySum(const glw::GLchar* array_name, glw::GLuint columns, glw::GLuint size);

	std::string getVectorSum(const glw::GLchar* vector_name, glw::GLuint size);

	std::string getVectorValues(glw::GLuint column, glw::GLuint size);

	/* Private variables */
	std::vector<testCase> m_test_cases;
	glw::GLint			  m_current_test_case_index;

	/* Private constants */
	static const glw::GLfloat m_value;
};

/** Test implementation, description follows:
 *
 * * Wrong type of component in initializer list.
 *
 *   Try to use wrong type of component. Expect compilation error. For example:
 *
 *       int a = { true };
 *
 *
 * * Wrong number of components in initializer list.
 *
 *   Try to wrong number of components. Expect compilation error. For example:
 *
 *       vec4 a = { 0.0, 0.0, 0.0 };
 *       vec3 a = { 0.0, 0.0, 0.0, 0.0 };
 *
 *
 * * Wrong matrix sizes in initializer lists:
 *
 *   Try to use wrong matrix row size or column count. Expect compilation error.
 *   For example:
 *
 *       mat2x3 b = {{ 0.0, 1.0,  2.0 }, { 3.0, 4.0}};
 *       mat2x3 b = {{ 0.0, 1.0}, { 2.0, 3.0}, { 4.0, 5.0 }};
 *       mat2x3 b = {{ 0.0, 1.0,  2.0 }, { 3.0, 4.0, 5.0 }};
 *       mat2x3 b = {{ 0.0, 1.0,  2.0 }, { 3.0, 4.0, 5.0 }};
 *
 *
 * * Initializer list inside constructor:
 *   Try to use initializer list inside constructor. Expect compilation error.
 *   For example:
 *
 *       struct S { vec2 v; };
 *       S s = S( {1.0, 2.0 } );
 *
 *
 * * Wrong struct layout in initializer list:
 *   Try to initialize struct with bad initializer list layout.
 *   Expect compilation error.
 *
 *   Check wrong member type, wrong member count and wrong member ordering.
 **/
class InitializerListNegativeTest : public NegativeTestBase
{
public:
	/* Public methods */
	InitializerListNegativeTest(deqp::Context&);

	virtual ~InitializerListNegativeTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual bool testInit();

private:
	/* Private enums */
	enum TESTED_ERRORS
	{
		TYPE_UIVEC_BOOL,
		TYPE_IVEC_BOOL,
		TYPE_VEC_BOOL,
		TYPE_MAT_BOOL,
		COMPONENTS_VEC_LESS,
		COMPONENTS_VEC_MORE,
		COMPONENTS_MAT_LESS_ROWS,
		COMPONENTS_MAT_LESS_COLUMNS,
		COMPONENTS_MAT_MORE_ROWS,
		COMPONENTS_MAT_MORE_COLUMNS,
		LIST_IN_CONSTRUCTOR,
		STRUCT_LAYOUT_MEMBER_TYPE,
		STRUCT_LAYOUT_MEMBER_COUNT_MORE,
		STRUCT_LAYOUT_MEMBER_COUNT_LESS,
		STRUCT_LAYOUT_MEMBER_ORDER,

		/* */
		TESTED_ERRORS_MAX
	};

	/* Private methods */
	std::string getInitialization();
	void		logTestCaseName();
	std::string getSum();
	std::string getTypeDefinition();
	std::string getTypeName();

	/* Private variables */
	std::vector<TESTED_ERRORS> m_test_cases;
	glw::GLint				   m_current_test_case_index;
};

/** Test implementation, description follows:
 *
 * * Apply .length() to various types:
 *
 *   Check value returned by .length(), when applied to vectors of all types.
 *   Check value returned by .length(), when applied to matrices of all types.
 *
 *   Check float, int and uint base types of vectors and matrices.
 *   Check all vector sizes, check all matrix dimensions.
 *
 *   Also check value returned by .length() when applied to vector or matrix
 *   members of a structures or interface blocks.
 *
 *
 * * Constant folding of .length() expressions:
 *
 *   Use value of .length() to set array size. For example:
 *
 *       vec4 a;
 *       float b[a.length()];
 **/
class LengthOfVectorAndMatrixTest : public GLSLTestBase
{
public:
	/* Public methods */
	LengthOfVectorAndMatrixTest(deqp::Context&);

	virtual ~LengthOfVectorAndMatrixTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);

	virtual void prepareVertexBuffer(const Utils::program& program, Utils::buffer& buffer, Utils::vertexArray& vao);

	virtual bool testInit();

private:
	/* Private types */
	struct testCase
	{
		Utils::TYPES m_type;
		glw::GLuint  m_n_cols;
		glw::GLuint  m_n_rows;
	};

	/* Private methods */
	std::string getExpectedValue(Utils::SHADER_STAGES in_stage);
	std::string getInitialization();

	std::string getMatrixInitializer(glw::GLuint n_cols, glw::GLuint n_rows);

	std::string getVectorInitializer(Utils::TYPES type, glw::GLuint n_rows);

	void prepareComputeShaderSource(Utils::shaderSource& out_source);

	void prepareDrawShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
								 Utils::shaderSource& out_source);

	glw::GLuint			  m_current_test_case_index;
	bool				  m_is_compute_program;
	std::vector<testCase> m_test_cases;
};

/** Test implementation, description follows:
 *
 * * .length() called on compute type:
 *
 *   Check value returned by .length(), when applied to computed types:
 *
 *   - rows of matrices
 *        mat4x3 a;
 *        a[<variable>].length()
 *
 *   - computed types: matrix multiplication
 *       mat4x2 a;
 *       mat3x4 b;
 *       (a * b).length()
 *       (a * b)[<variable>].length()
 *
 *   - computed types: vector multiplication
 *       vec3 a;
 *       vec3 b;
 *       (a * b).length()
 *
 *
 * * Constant folding of .length() expressions using computed type.
 *
 *   Use value of .length() to set array size, when called on computed type.
 *   For example:
 *      mat4x2 a;
 *      mat3x4 b;
 *      float c[a(a * b).length()];
 *      float d[(a * b)[<variable>].length()];
 *
 *
 * * .length() called on build-in values.
 *
 *   Check value returned by .length when called on gl_Position,
 *   gl_PointCoord, gl_SamplePosition
 *
 *
 * * .length() called on build-in functions
 *
 *   Check value returned by .length() when called on values returned from
 *   build in functions. For example:
 *      outerProduct(vec4(0.0), vec3(0.0)).length()
 **/
class LengthOfComputeResultTest : public GLSLTestBase
{
public:
	/* Public methods */
	LengthOfComputeResultTest(deqp::Context&);

	virtual ~LengthOfComputeResultTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
};

/** Test implementation, description follows:
 *
 * * All sizes of scalar swizzle
 *
 *   Test value returned by all sizes of scalar swizzlers: .x, .xx, .xxx and
 *   .xxx, when called on a float variable.
 *
 * * Scalar swizzling of literals
 *
 *   Call scalar swizzler .xxx on literal, for example (0.0).xxx.
 *
 * * Scalar swizzling of constant expressions
 *
 *   Call scalar swizzler .xxx on constant, for example:
 *
 *       const float x = 0.0;
 *       x.xxx
 *
 * * Mixed scalar swizzling
 *
 *   Check combinations of 'x', 'r', 's' swizzlers: .xx, .rr, .ss, .xrs
 *
 * * Nested swizzlers
 *
 *   Check nested swizzlers. For example:
 *       const float x = 0.0;
 *       x.r.s.x.ss
 **/
class ScalarSwizzlersTest : public GLSLTestBase
{
public:
	/* Public methods */
	ScalarSwizzlersTest(deqp::Context&);

	virtual ~ScalarSwizzlersTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
};

/** Test implementation, description follows:
 *
 * * Wrong swizzlers for scalars:
 *
 *   Swizzlers not applicable for scalars like .z, .xz, .q should fail
 *   shader compilation.
 *
 * * Wrong swizzlers:
 *
 *   Wrong swizzlers, like .u  should fail shader compilation.
 *
 * * Wrong syntax:
 *
 *   Literal swizzlers without parenthesis, like 1.x, should fail shader
 *   compilation.
 **/
class ScalarSwizzlersInvalidTest : public NegativeTestBase
{
public:
	/* Public methods */
	ScalarSwizzlersInvalidTest(deqp::Context&);

	virtual ~ScalarSwizzlersInvalidTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

private:
	/* Private enums */
	enum TESTED_CASES
	{
		INVALID_Y,
		INVALID_B,
		INVALID_Q,
		INVALID_XY,
		INVALID_XRS,
		WRONG,
		MISSING_PARENTHESIS,
	};

	TESTED_CASES m_case;
};

/** Test implementation, description follows:
 *
 * * Value of gl_MinProgramTexelOffset:
 *
 *   Check that gl_MinProgramTexelOffset matches the value of
 *   GL_MIN_PROGRAM_TEXEL_OFFSET from API.
 *
 *   Check that both values satisfy minimal requirement from OpenGL
 *   specification.
 *
 * * Value of gl_MinProgramTexelOffset:
 *
 *   Check that gl_MinProgramTexelOffset matches the value of
 *   GL_MAX_PROGRAM_TEXEL_OFFSET from API.
 *
 *   Check that both values satisfy minimal requirement from OpenGL
 *   specification.
 **/
class BuiltInValuesTest : public GLSLTestBase
{
public:
	/* Public methods */
	BuiltInValuesTest(deqp::Context&);

	virtual ~BuiltInValuesTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

	virtual void prepareUniforms(Utils::program& program);
	virtual bool testInit();

private:
	/* Private constants */
	static const glw::GLint m_min_program_texel_offset_limit;
	static const glw::GLint m_max_program_texel_offset_limit;

	/* Private variables */
	glw::GLint m_min_program_texel_offset;
	glw::GLint m_max_program_texel_offset;
};

/** Test implementation, description follows:
 *
 **/
class BuiltInAssignmentTest : public NegativeTestBase
{
public:
	/* Public methods */
	BuiltInAssignmentTest(deqp::Context&);

	virtual ~BuiltInAssignmentTest()
	{
	}

protected:
	/* Methods to be implemented by child class */
	virtual bool prepareNextTestCase(glw::GLuint test_case_index);

	virtual void prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400,
									 Utils::shaderSource& out_source);

private:
	/* Private variables */
	glw::GLuint m_case;
};
} /* GLSL420Pack namespace */

/** Group class for Shader Language 420Pack conformance tests */
class ShadingLanguage420PackTests : public deqp::TestCaseGroup
{
public:
	/* Public methods */
	ShadingLanguage420PackTests(deqp::Context& context);

	virtual ~ShadingLanguage420PackTests(void)
	{
	}

	virtual void init(void);

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

} // gl4cts

#endif // _GL4CSHADINGLANGUAGE420PACKTESTS_HPP