xref: /third_party/vk-gl-cts/external/openglcts/modules/gl/gl4cES31CompatibilityTests.cpp

/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * Copyright (c) 2015-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
 */ /*-------------------------------------------------------------------*/

/* Includes. */
#include "gl4cES31CompatibilityTests.hpp"
#include "gluContextInfo.hpp"
#include "gluDefs.hpp"
#include "gluRenderContext.hpp"
#include "gluStrUtil.hpp"
#include "tcuTestLog.hpp"

/******************************** Test Group Implementation       ********************************/

/** @brief ES3.1 Compatibility tests group constructor.
 *
 *  @param [in] context     OpenGL context.
 */
gl4cts::es31compatibility::Tests::Tests(deqp::Context& context)
	: TestCaseGroup(context, "es_31_compatibility", "ES3.1 Compatibility Test Suite")
{
	/* Intentionally left blank */
}

/** @brief ES3.1 Compatibility Tests initializer. */
void gl4cts::es31compatibility::Tests::init()
{
	/* New tests. */
	addChild(new gl4cts::es31compatibility::ShaderCompilationCompatibilityTests(m_context));
	addChild(new gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest(m_context));

	/* Ported tests. */
	addChild(new gl4cts::es31compatibility::SampleVariablesTests(m_context, glu::GLSL_VERSION_310_ES));
	addChild(new gl4cts::es31compatibility::ShaderImageLoadStoreTests(m_context));
	addChild(new gl4cts::es31compatibility::ShaderStorageBufferObjectTests(m_context));
}

/******************************** Shader Compilation Compatibility Tests Implementation   ********************************/

/** @brief ShaderCompilationCompatibilityTests constructor.
 *
 *  @param [in] context     OpenGL context.
 */
gl4cts::es31compatibility::ShaderCompilationCompatibilityTests::ShaderCompilationCompatibilityTests(
	deqp::Context& context)
	: deqp::TestCase(context, "shader_compilation", "Shader Compilation Compatibility Test")
{
}

/** @brief ShaderCompilationCompatibilityTests test cases iterations.
 */
tcu::TestNode::IterateResult gl4cts::es31compatibility::ShaderCompilationCompatibilityTests::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* OpenGL support query. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_es31_compatibility = m_context.getContextInfo().isExtensionSupported("GL_ARB_ES3_1_compatibility");

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	glw::GLuint shader = 0;

	/* Test */
	try
	{
		if (is_at_least_gl_45 || is_arb_es31_compatibility)
		{
			for (glw::GLsizei i = 0; i < s_shaders_count; ++i)
			{
				/* Shader compilation. */
				shader = gl.createShader(s_shaders[i].type);

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

				if (0 == shader)
				{
					throw 0;
				}

				gl.shaderSource(shader, 1, &(s_shaders[i].source), NULL);

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

				gl.compileShader(shader);

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

				/* Checking for errors. */
				glw::GLint status = GL_FALSE;

				gl.getShaderiv(shader, GL_COMPILE_STATUS, &status);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed.");

				if (GL_FALSE == status)
				{
					/* Setup result. */
					is_ok = false;

					/* Getting compilation informations. */
					glw::GLint log_size = 0;

					gl.getShaderiv(shader, GL_INFO_LOG_LENGTH, &log_size);

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

					if (log_size)
					{
						glw::GLchar* log = new glw::GLchar[log_size];

						if (log)
						{
							memset(log, 0, log_size);

							gl.getShaderInfoLog(shader, log_size, DE_NULL, log);

							/* Logging. */
							m_context.getTestContext().getLog() << tcu::TestLog::Message << "Compilation of "
																<< s_shaders[i].type_name
																<< " shader have failed.\n Shader source was:\n"
																<< s_shaders[i].source << "\nCompillation log:\n"
																<< log << tcu::TestLog::EndMessage;

							delete[] log;

							GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderInfoLog() call failed.");
						}
					}
				}

				/* Cleanup. */
				gl.deleteShader(shader);

				shader = 0;

				GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteShader call failed.");
			}
		}
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	if (0 != shader)
	{
		gl.deleteShader(shader);

		shader = 0;
	}

	/* Result's setup and logging. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_context.getTestContext().getLog() << tcu::TestLog::Message
												<< "Internal error has occured during the Shader Version Test."
												<< tcu::TestLog::EndMessage;

			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Test error.");
		}
		else
		{
			m_context.getTestContext().getLog() << tcu::TestLog::Message << "The Shader Version Test has failed."
												<< tcu::TestLog::EndMessage;

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

	return STOP;
}

const gl4cts::es31compatibility::ShaderCompilationCompatibilityTests::TestShader
	gl4cts::es31compatibility::ShaderCompilationCompatibilityTests::s_shaders[] = {
		{ /* Shader for testing ES 3.1 version string support.*/
		  GL_VERTEX_SHADER, "vertex", "#version 310 es\n"
									  "\n"
									  "void main()\n"
									  "{\n"
									  "    gl_Position = vec4(1.0);\n"
									  "}\n" },
		{ /* Shader for testing ES 3.1 version string support.*/
		  GL_FRAGMENT_SHADER, "fragment", "#version 310 es\n"
										  "\n"
										  "out highp vec4 color;"
										  "\n"
										  "void main()\n"
										  "{\n"
										  "    color = vec4(1.0);\n"
										  "}\n" },
		{ /* Shader for testing that gl_HelperInvocation variable is supported.*/
		  GL_FRAGMENT_SHADER, "fragment", "#version 310 es\n"
										  "\n"
										  "out highp vec4 color;"
										  "\n"
										  "void main()\n"
										  "{\n"
										  "    if(gl_HelperInvocation)\n"
										  "    {\n"
										  "        color = vec4(1.0);\n"
										  "    }\n"
										  "    else\n"
										  "    {\n"
										  "        color = vec4(0.0);\n"
										  "    }\n"
										  "}\n" },
		{ /* Shader for testing ES 3.1 version string support.*/
		  GL_COMPUTE_SHADER, "compute",
		  "#version 310 es\n"
		  "\n"
		  "layout(local_size_x = 128) in;\n"
		  "layout(std140, binding = 0) buffer Output\n"
		  "{\n"
		  "    uint elements[];\n"
		  "} output_data;\n"
		  "\n"
		  "void main()\n"
		  "{\n"
		  "    output_data.elements[gl_GlobalInvocationID.x] = gl_GlobalInvocationID.x * gl_GlobalInvocationID.x;\n"
		  "}\n" }
	};

const glw::GLsizei gl4cts::es31compatibility::ShaderCompilationCompatibilityTests::s_shaders_count =
	sizeof(s_shaders) / sizeof(s_shaders[0]);

/******************************** Shader Functional Compatibility Test Implementation   ********************************/

/** @brief Shader Functional Compatibility Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::ShaderFunctionalCompatibilityTest(deqp::Context& context)
	: deqp::TestCase(context, "shader_functional", "Shader Functional Compatibility Test")
	, m_po_id(0)
	, m_fbo_id(0)
	, m_rbo_id(0)
	, m_vao_id(0)
{
}

/** @brief ShaderCompilationCompatibilityTests test cases iterations.
 */
tcu::TestNode::IterateResult gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::iterate()
{
	/* OpenGL support query. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_es31_compatibility = m_context.getContextInfo().isExtensionSupported("GL_ARB_ES3_1_compatibility");

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	/* Test */
	try
	{
		if (is_at_least_gl_45 || is_arb_es31_compatibility)
		{
			createFramebufferAndVertexArrayObject();

			for (glw::GLsizei i = 0; i < s_shaders_count; ++i)
			{
				if (!createProgram(s_shaders[i]))
				{
					is_ok = false;

					continue; /* if createProgram failed we shall omit this iteration */
				}

				is_ok &= test();

				cleanProgram();
			}

			cleanFramebufferAndVertexArrayObject();
		}
	}
	catch (...)
	{
		/* Result setup. */
		is_ok	= false;
		is_error = true;

		/* Cleanup. */
		cleanProgram();
		cleanFramebufferAndVertexArrayObject();
	}

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_context.getTestContext().getLog() << tcu::TestLog::Message
												<< "Internal error has occured during the Shader Version Test."
												<< tcu::TestLog::EndMessage;

			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Test error.");
		}
		else
		{
			m_context.getTestContext().getLog() << tcu::TestLog::Message << "The Shader Version Test has failed."
												<< tcu::TestLog::EndMessage;

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

	return STOP;
}

/** @brief Create program object
 *
 *  @note Program object is going to be stored into m_po_id.
 *        If building succeeded program will be set current (glUseProgram).
 *
 *  @param [in] shader_source   Shader source to be builded.
 *
 *  @return True if succeeded, false otherwise.
 */
bool gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::createProgram(const struct Shader shader_source)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	struct _Shader
	{
		const glw::GLchar* const* source;
		const glw::GLenum		  type;
		glw::GLuint				  id;
	} shader[] = { { shader_source.vertex, GL_VERTEX_SHADER, 0 }, { shader_source.fragment, GL_FRAGMENT_SHADER, 0 } };

	glw::GLuint const shader_count = sizeof(shader) / sizeof(shader[0]);

	try
	{
		/* Make sure m_po_id is cleaned. */
		if (m_po_id)
		{
			cleanProgram();
		}

		/* Create program. */
		m_po_id = gl.createProgram();
		GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram call failed.");

		/* Shader compilation. */

		for (glw::GLuint i = 0; i < shader_count; ++i)
		{
			if (DE_NULL != shader[i].source)
			{
				shader[i].id = gl.createShader(shader[i].type);

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

				gl.attachShader(m_po_id, shader[i].id);

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

				gl.shaderSource(shader[i].id, 3, shader[i].source, NULL);

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

				gl.compileShader(shader[i].id);

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

				glw::GLint status = GL_FALSE;

				gl.getShaderiv(shader[i].id, GL_COMPILE_STATUS, &status);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed.");

				if (GL_FALSE == status)
				{
					glw::GLint log_size = 0;

					gl.getShaderiv(shader[i].id, GL_INFO_LOG_LENGTH, &log_size);

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

					if (log_size)
					{
						glw::GLchar* log = new glw::GLchar[log_size];

						if (log)
						{
							memset(log, 0, log_size);

							gl.getShaderInfoLog(shader[i].id, log_size, DE_NULL, log);

							m_context.getTestContext().getLog()
								<< tcu::TestLog::Message << "Compilation of shader has failed.\nShader source:\n"
								<< shader[i].source[0] << shader[i].source[1] << shader[i].source[2]
								<< "\nCompillation log:\n"
								<< log << tcu::TestLog::EndMessage;

							delete[] log;

							GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderInfoLog() call failed.");
						}
					}

					throw 0;
				}
			}
		}

		/* Link. */
		gl.linkProgram(m_po_id);

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

		glw::GLint status = GL_FALSE;

		gl.getProgramiv(m_po_id, GL_LINK_STATUS, &status);

		if (GL_TRUE == status)
		{
			for (glw::GLuint i = 0; i < shader_count; ++i)
			{
				if (shader[i].id)
				{
					gl.detachShader(m_po_id, shader[i].id);

					GLU_EXPECT_NO_ERROR(gl.getError(), "glDetachShader call failed.");
				}
			}
		}
		else
		{
			glw::GLint log_size = 0;

			gl.getProgramiv(m_po_id, GL_INFO_LOG_LENGTH, &log_size);

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

			if (log_size)
			{
				glw::GLchar* log = new glw::GLchar[log_size];

				if (log)
				{
					memset(log, 0, log_size);

					gl.getProgramInfoLog(m_po_id, log_size, DE_NULL, log);

					m_context.getTestContext().getLog() << tcu::TestLog::Message
														<< "Linkage of shader program has failed.\nLinkage log:\n"
														<< log << tcu::TestLog::EndMessage;

					delete[] log;

					GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderInfoLog() call failed.");
				}
			}

			throw 0;
		}
	}
	catch (...)
	{
		if (m_po_id)
		{
			gl.deleteProgram(m_po_id);

			m_po_id = 0;
		}
	}

	for (glw::GLuint i = 0; i < shader_count; ++i)
	{
		if (0 != shader[i].id)
		{
			gl.deleteShader(shader[i].id);

			shader[i].id = 0;
		}
	}

	if (m_po_id)
	{
		gl.useProgram(m_po_id);

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

		return true;
	}

	return false;
}

/** @brief Create framebuffer and vertex array object.
 *
 *  @note Frembuffer will be stored in m_fbo_id and m_rbo_id.
 *        Vertex array object will be stored in m_vao_id.
 *        Function will throw 0 if erro has occured.
 */
void gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::createFramebufferAndVertexArrayObject()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Prepare framebuffer. */
	gl.clearColor(0.0f, 0.0f, 0.0f, 0.0f);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor call failed.");

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

	gl.genRenderbuffers(1, &m_rbo_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");

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

	gl.bindRenderbuffer(GL_RENDERBUFFER, m_rbo_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");

	gl.renderbufferStorage(GL_RENDERBUFFER, GL_R8, 1 /* x size */, 1 /* y size */);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glRenderbufferStorage call failed.");

	gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_rbo_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferRenderbuffer call failed.");

	/* Check if all went ok. */
	if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
	{
		throw 0;
	}

	/* View Setup. */
	gl.viewport(0, 0, 1 /* x size */, 1 /* y size */);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed.");

	/* Create and bind empty vertex array object. */
	gl.genVertexArrays(1, &m_vao_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed.");

	if (0 == m_vao_id)
	{
		throw 0;
	}

	gl.bindVertexArray(m_vao_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed.");
}

/** @brief Run test case.
 *
 *  @note Test case run in following order:
 *         *  clear screen with 0 value (color setup in createFramebufferAndVertexArrayObject);
 *         *  draw full screen quad;
 *         *  fetch pixel from screen using glReadPixel (view is 1x1 pixel in size);
 *         *  compare results (1.0f is expected as the result of the shader).
 */
bool gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::test()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Make sure objects are cleaned. */
	if (m_fbo_id || m_rbo_id || m_vao_id)
	{
		cleanFramebufferAndVertexArrayObject();
	}

	/* Drawing quad which shall output result. */
	gl.clear(GL_COLOR_BUFFER_BIT);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glClear() call failed.");

	gl.drawArrays(GL_TRIANGLE_STRIP, 0, 4);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed.");

	/* Fetching result. */
	glw::GLfloat red = -1.f;

	gl.readPixels(0, 0, 1, 1, GL_RED, GL_FLOAT, &red);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() call failed.");

	if (de::abs(1.f - red) <= 0.125 /* Precision. */)
	{
		return true;
	}

	return false;
}

/** @brief Release program object.
 */
void gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::cleanProgram()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Deleting program. */
	if (m_po_id)
	{
		gl.useProgram(0);

		gl.deleteProgram(m_po_id);

		m_po_id = 0;
	}
}

/** @brief Release framebuffer, renderbuffer and vertex array objects.
 */
void gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::cleanFramebufferAndVertexArrayObject()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Deleting view. */
	if (m_fbo_id)
	{
		gl.deleteFramebuffers(1, &m_fbo_id);

		m_fbo_id = 0;
	}

	if (m_rbo_id)
	{
		gl.deleteRenderbuffers(1, &m_rbo_id);

		m_rbo_id = 0;
	}

	if (m_vao_id)
	{
		gl.deleteVertexArrays(1, &m_vao_id);

		m_vao_id = 0;
	}
}

const glw::GLchar* gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::s_shader_version = "#version 310 es\n";

const glw::GLchar* gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::s_vertex_shader_body =
	"\n"
	"out highp float vout;\n"
	"\n"
	"void main()\n"
	"{\n"
	"    switch(gl_VertexID % 4)\n"
	"    {\n"
	"    case 0:\n"
	"       gl_Position = vec4(-1.0, -1.0,  0.0,  1.0);\n"
	"       break;\n"
	"    case 1:\n"
	"       gl_Position = vec4( 1.0, -1.0,  0.0,  1.0);\n"
	"       break;\n"
	"    case 2:\n"
	"       gl_Position = vec4(-1.0,  1.0,  0.0,  1.0);\n"
	"       break;\n"
	"    case 3:\n"
	"       gl_Position = vec4( 1.0,  1.0,  0.0,  1.0);\n"
	"       break;\n"
	"    }\n"
	"\n"
	"    vout = float(gl_VertexID % 4);\n   /* Always less than 4. */"
	"}\n";

const glw::GLchar* gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::s_fragment_shader_body =
	"\n"
	"in highp float vout;\n"
	"\n"
	"out highp vec4 result;\n"
	"\n"
	"void main()\n"
	"{\n"
	"    TTYPE a = LEFT;\n"
	"    TTYPE b = RIGHT;\n"
	"    BTYPE c = BDATA && BTYPE(vout < 4.0);\n    /* Making sure that expression is not compile time constant. */"
	"\n"
	"    TTYPE mixed = mix(a, b, c);\n"
	"\n"
	"    if(REFERENCE == mixed)\n"
	"    {\n"
	"        result = vec4(1.0);\n"
	"    }\n"
	"    else\n"
	"    {\n"
	"        result = vec4(0.0);\n"
	"    }\n"
	"}\n";

const struct gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::Shader
	gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::s_shaders[] = {
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        highp int\n"
							  "#define BTYPE        bool\n"
							  "#define LEFT        -1\n"
							  "#define RIGHT       -2\n"
							  "#define BDATA        true\n"
							  "#define REFERENCE   -2\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        highp uint\n"
							  "#define BTYPE        bool\n"
							  "#define LEFT         1u\n"
							  "#define RIGHT        2u\n"
							  "#define BDATA        true\n"
							  "#define REFERENCE    2u\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        mediump int\n"
							  "#define BTYPE        bool\n"
							  "#define LEFT        -1\n"
							  "#define RIGHT       -2\n"
							  "#define BDATA        true\n"
							  "#define REFERENCE   -2\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        mediump uint\n"
							  "#define BTYPE        bool\n"
							  "#define LEFT         1u\n"
							  "#define RIGHT        2u\n"
							  "#define BDATA        true\n"
							  "#define REFERENCE    2u\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        lowp int\n"
							  "#define BTYPE        bool\n"
							  "#define LEFT        -1\n"
							  "#define RIGHT       -2\n"
							  "#define BDATA        true\n"
							  "#define REFERENCE   -2\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        lowp uint\n"
							  "#define BTYPE        bool\n"
							  "#define LEFT         1u\n"
							  "#define RIGHT        2u\n"
							  "#define BDATA        true\n"
							  "#define REFERENCE    2u\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        bool\n"
							  "#define BTYPE        bool\n"
							  "#define LEFT         false\n"
							  "#define RIGHT        true\n"
							  "#define BDATA        true\n"
							  "#define REFERENCE    true\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        highp ivec2\n"
							  "#define BTYPE        bvec2\n"
							  "#define LEFT         ivec2(-1, -2)\n"
							  "#define RIGHT        ivec2(-3, -4)\n"
							  "#define BDATA        bvec2(true, false)\n"
							  "#define REFERENCE    ivec2(-3, -2)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        highp uvec2\n"
							  "#define BTYPE        bvec2\n"
							  "#define LEFT         uvec2(1, 2)\n"
							  "#define RIGHT        uvec2(3, 4)\n"
							  "#define BDATA        bvec2(true, false)\n"
							  "#define REFERENCE    uvec2(3, 2)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        mediump ivec2\n"
							  "#define BTYPE        bvec2\n"
							  "#define LEFT         ivec2(-1, -2)\n"
							  "#define RIGHT        ivec2(-3, -4)\n"
							  "#define BDATA        bvec2(true, false)\n"
							  "#define REFERENCE    ivec2(-3, -2)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        mediump uvec2\n"
							  "#define BTYPE        bvec2\n"
							  "#define LEFT         uvec2(1, 2)\n"
							  "#define RIGHT        uvec2(3, 4)\n"
							  "#define BDATA        bvec2(true, false)\n"
							  "#define REFERENCE    uvec2(3, 2)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        lowp ivec2\n"
							  "#define BTYPE        bvec2\n"
							  "#define LEFT         ivec2(-1, -2)\n"
							  "#define RIGHT        ivec2(-3, -4)\n"
							  "#define BDATA        bvec2(true, false)\n"
							  "#define REFERENCE    ivec2(-3, -2)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        lowp uvec2\n"
							  "#define BTYPE        bvec2\n"
							  "#define LEFT         uvec2(1, 2)\n"
							  "#define RIGHT        uvec2(3, 4)\n"
							  "#define BDATA        bvec2(true, false)\n"
							  "#define REFERENCE    uvec2(3, 2)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        bvec2\n"
							  "#define BTYPE        bvec2\n"
							  "#define LEFT         bvec2(true,  true)\n"
							  "#define RIGHT        bvec2(false, false)\n"
							  "#define BDATA        bvec2(true,  false)\n"
							  "#define REFERENCE    bvec2(false, true)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        highp ivec3\n"
							  "#define BTYPE        bvec3\n"
							  "#define LEFT         ivec3(-1, -2, -3)\n"
							  "#define RIGHT        ivec3(-4, -5, -6)\n"
							  "#define BDATA        bvec3(true, false, true)\n"
							  "#define REFERENCE    ivec3(-4, -2, -6)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        highp uvec3\n"
							  "#define BTYPE        bvec3\n"
							  "#define LEFT         uvec3(1, 2, 3)\n"
							  "#define RIGHT        uvec3(4, 5, 6)\n"
							  "#define BDATA        bvec3(true, false, true)\n"
							  "#define REFERENCE    uvec3(4, 2, 6)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        mediump ivec3\n"
							  "#define BTYPE        bvec3\n"
							  "#define LEFT         ivec3(-1, -2, -3)\n"
							  "#define RIGHT        ivec3(-4, -5, -6)\n"
							  "#define BDATA        bvec3(true, false, true)\n"
							  "#define REFERENCE    ivec3(-4, -2, -6)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        mediump uvec3\n"
							  "#define BTYPE        bvec3\n"
							  "#define LEFT         uvec3(1, 2, 3)\n"
							  "#define RIGHT        uvec3(4, 5, 6)\n"
							  "#define BDATA        bvec3(true, false, true)\n"
							  "#define REFERENCE    uvec3(4, 2, 6)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        lowp ivec3\n"
							  "#define BTYPE        bvec3\n"
							  "#define LEFT         ivec3(-1, -2, -3)\n"
							  "#define RIGHT        ivec3(-4, -5, -6)\n"
							  "#define BDATA        bvec3(true, false, true)\n"
							  "#define REFERENCE    ivec3(-4, -2, -6)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        lowp uvec3\n"
							  "#define BTYPE        bvec3\n"
							  "#define LEFT         uvec3(1, 2, 3)\n"
							  "#define RIGHT        uvec3(4, 5, 6)\n"
							  "#define BDATA        bvec3(true, false, true)\n"
							  "#define REFERENCE    uvec3(4, 2, 6)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        bvec3\n"
							  "#define BTYPE        bvec3\n"
							  "#define LEFT         bvec3(true,  true, true)\n"
							  "#define RIGHT        bvec3(false, false, false)\n"
							  "#define BDATA        bvec3(true,  false, true)\n"
							  "#define REFERENCE    bvec3(false, true, false)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        highp ivec4\n"
							  "#define BTYPE        bvec4\n"
							  "#define LEFT         ivec4(-1, -2, -3, -4)\n"
							  "#define RIGHT        ivec4(-5, -6, -7, -8)\n"
							  "#define BDATA        bvec4(true, false, true, false)\n"
							  "#define REFERENCE    ivec4(-5, -2, -7, -4)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        highp uvec4\n"
							  "#define BTYPE        bvec4\n"
							  "#define LEFT         uvec4(1, 2, 3, 4)\n"
							  "#define RIGHT        uvec4(5, 6, 7, 8)\n"
							  "#define BDATA        bvec4(true, false, true, false)\n"
							  "#define REFERENCE    uvec4(5, 2, 7, 4)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        mediump ivec4\n"
							  "#define BTYPE        bvec4\n"
							  "#define LEFT         ivec4(-1, -2, -3, -4)\n"
							  "#define RIGHT        ivec4(-5, -6, -7, -8)\n"
							  "#define BDATA        bvec4(true, false, true, false)\n"
							  "#define REFERENCE    ivec4(-5, -2, -7, -4)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        mediump uvec4\n"
							  "#define BTYPE        bvec4\n"
							  "#define LEFT         uvec4(1, 2, 3, 4)\n"
							  "#define RIGHT        uvec4(5, 6, 7, 8)\n"
							  "#define BDATA        bvec4(true, false, true, false)\n"
							  "#define REFERENCE    uvec4(5, 2, 7, 4)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        lowp ivec4\n"
							  "#define BTYPE        bvec4\n"
							  "#define LEFT         ivec4(-1, -2, -3, -4)\n"
							  "#define RIGHT        ivec4(-5, -6, -7, -8)\n"
							  "#define BDATA        bvec4(true, false, true, false)\n"
							  "#define REFERENCE    ivec4(-5, -2, -7, -4)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        lowp uvec4\n"
							  "#define BTYPE        bvec4\n"
							  "#define LEFT         uvec4(1, 2, 3, 4)\n"
							  "#define RIGHT        uvec4(5, 6, 7, 8)\n"
							  "#define BDATA        bvec4(true, false, true, false)\n"
							  "#define REFERENCE    uvec4(5, 2, 7, 4)\n",
			s_fragment_shader_body } },
		{ { s_shader_version, "", s_vertex_shader_body },
		  { s_shader_version, "#define TTYPE        bvec4\n"
							  "#define BTYPE        bvec4\n"
							  "#define LEFT         bvec4(true,  true,  true,  true)\n"
							  "#define RIGHT        bvec4(false, false, false, false)\n"
							  "#define BDATA        bvec4(true,  false, true,  false)\n"
							  "#define REFERENCE    bvec4(false, true,  false, true)\n",
			s_fragment_shader_body } }
	};

const glw::GLsizei gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::s_shaders_count =
	sizeof(s_shaders) / sizeof(s_shaders[0]);