external/openglcts/modules/glesext/geometry_shader/esextcGeometryShaderNonarrayInput.cpp - third_party/vulkan-cts - Git at Google

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

 #include "esextcGeometryShaderNonarrayInput.hpp"

 #include "gluContextInfo.hpp"
 #include "gluDefs.hpp"
 #include "glwEnums.hpp"
 #include "glwFunctions.hpp"
 #include "tcuTestLog.hpp"

 #include <algorithm>
 #include <string>
 #include <vector>

 namespace glcts
 {

 /* Fragment shader code */
 const char* GeometryShaderNonarrayInputCase::m_fs_code = "${VERSION}\n"
 														 "\n"
 														 "precision highp float;\n"
 														 "\n"
 														 "out vec4 color;\n"
 														 "\n"
 														 "void main()\n"
 														 "{\n"
 														 "    color = vec4(0, 1, 0, 1);\n"
 														 "}\n";

 /* Geometry shader body parts */
 const char* GeometryShaderNonarrayInputCase::m_gs_code_preamble = "${VERSION}\n"
 																  "${GEOMETRY_SHADER_REQUIRE}\n"
 																  "\n";

 const char* GeometryShaderNonarrayInputCase::m_gs_code_body = "layout(points)                         in;\n"
 															  "layout(triangle_strip, max_vertices=4) out;\n"
 															  "\n"
 															  "#ifndef USE_BLOCK\n"
 															  "    #define V1 v1[0]\n"
 															  "    #define V2 v2[0]\n"
 															  "    #define V3 v3[0]\n"
 															  "\n"
 															  "    in vec4 v1[];\n"
 															  "    in vec4 v2[];\n"
 															  "    in vec4 v3[];\n"
 															  "    \n"
 															  "    #ifdef CORRUPT\n"
 															  "        #define V4 v4\n"
 															  "        in vec4 v4;\n"
 															  "    #else\n"
 															  "        #define V4 v4[0]\n"
 															  "        in vec4 v4[];\n"
 															  "    #endif\n"
 															  "#else\n"
 															  "    in VS_GS\n"
 															  "    {\n"
 															  "        in vec4 v1;\n"
 															  "        in vec4 v2;\n"
 															  "        in vec4 v3;\n"
 															  "        in vec4 v4;\n"
 															  "    #ifdef CORRUPT\n"
 															  "        } interface_block;\n"
 															  "\n"
 															  "        #define V1 interface_block.v1\n"
 															  "        #define V2 interface_block.v2\n"
 															  "        #define V3 interface_block.v3\n"
 															  "        #define V4 interface_block.v4\n"
 															  "    #else\n"
 															  "        } interface_block[];\n"
 															  "\n"
 															  "        #define V1 interface_block[0].v1\n"
 															  "        #define V2 interface_block[0].v2\n"
 															  "        #define V3 interface_block[0].v3\n"
 															  "        #define V4 interface_block[0].v4\n"
 															  "    #endif\n"
 															  "#endif\n"
 															  "\n"
 															  "void main()\n"
 															  "{\n"
 															  "    gl_Position = V1;\n"
 															  "    EmitVertex();\n"
 															  "    gl_Position = V2;\n"
 															  "    EmitVertex();\n"
 															  "    gl_Position = V3;\n"
 															  "    EmitVertex();\n"
 															  "    gl_Position = V4;\n"
 															  "    EmitVertex();\n"
 															  "    EndPrimitive();\n"
 															  "}\n";

 /* Vertex shader body parts */
 const char* GeometryShaderNonarrayInputCase::m_vs_code_preamble = "${VERSION}\n"
 																  "\n";

 const char* GeometryShaderNonarrayInputCase::m_vs_code_body = "#ifndef USE_BLOCK\n"
 															  "    #define V1 v1\n"
 															  "    #define V2 v2\n"
 															  "    #define V3 v3\n"
 															  "    #define V4 v4\n"
 															  "\n"
 															  "    out vec4 v1;\n"
 															  "    out vec4 v2;\n"
 															  "    out vec4 v3;\n"
 															  "    out vec4 v4;\n"
 															  "#else\n"
 															  "    ${SHADER_IO_BLOCKS_ENABLE}\n"
 															  "    #define V1 interface_block.v1\n"
 															  "    #define V2 interface_block.v2\n"
 															  "    #define V3 interface_block.v3\n"
 															  "    #define V4 interface_block.v4\n"
 															  "\n"
 															  "    out VS_GS\n"
 															  "    {\n"
 															  "        vec4 v1;\n"
 															  "        vec4 v2;\n"
 															  "        vec4 v3;\n"
 															  "        vec4 v4;\n"
 															  "    } interface_block;\n"
 															  "#endif\n"
 															  "\n"
 															  "void main()\n"
 															  "{\n"
 															  "    V1 = vec4(-1, -1, 0, 1);\n"
 															  "    V2 = vec4(-1,  1, 0, 1);\n"
 															  "    V3 = vec4( 1, -1, 0, 1);\n"
 															  "    V4 = vec4( 1,  1, 0, 1);\n"
 															  "}\n";

 /* Definitions */
 #define TEXTURE_HEIGHT (4)
 #define TEXTURE_WIDTH (4)

 /** Constructor
  *
  * @param context       Test context
  * @param name          Test case's name
  * @param description   Test case's desricption
  **/
 GeometryShaderNonarrayInputCase::GeometryShaderNonarrayInputCase(Context& context, const ExtParameters& extParams,
 																 const char* name, const char* description)
 	: TestCaseBase(context, extParams, name, description)
 	, m_fbo_id(0)
 	, m_fs(0)
 	, m_gs_invalid_non_ib(0)
 	, m_gs_invalid_ib(0)
 	, m_gs_valid_non_ib(0)
 	, m_gs_valid_ib(0)
 	, m_po_a_invalid(0)
 	, m_po_b_invalid(0)
 	, m_po_a_valid(0)
 	, m_po_b_valid(0)
 	, m_to_id(0)
 	, m_vao_id(0)
 	, m_vs_valid_ib(0)
 	, m_vs_valid_non_ib(0)
 {
 }

 /** Executes the test.
  *  Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
  *  @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again.
  *  Note the function throws exception should an error occur!
  **/
 tcu::TestNode::IterateResult GeometryShaderNonarrayInputCase::iterate(void)
 {
 	glw::GLint			  compile_status = GL_FALSE;
 	const glw::Functions& gl			 = m_context.getRenderContext().getFunctions();
 	glw::GLint			  link_status	= GL_FALSE;
 	unsigned int		  m				 = 0;
 	unsigned int		  n				 = 0;

 	/* Form the shaders */
 	const char* fs_parts[]				  = { m_fs_code };
 	const char* gs_invalid_non_ib_parts[] = { m_gs_code_preamble, "#define CORRUPT\n", m_gs_code_body };
 	const char* gs_invalid_ib_parts[] = { m_gs_code_preamble, "#define CORRUPT\n#define USE_BLOCK\n", m_gs_code_body };
 	const char* gs_valid_non_ib_parts[] = { m_gs_code_preamble, m_gs_code_body };
 	const char* gs_valid_ib_parts[]		= { m_gs_code_preamble, "#define USE_BLOCK\n", m_gs_code_body };
 	const char* vs_valid_non_ib_parts[] = { m_vs_code_preamble, m_vs_code_body };
 	const char* vs_valid_ib_parts[]		= { m_vs_code_preamble, "#define USE_BLOCK\n", m_vs_code_body };

 	/* This test should only run if EXT_geometry_shader is supported.
 	 * Note that EXT_shader_io_blocks support is implied. */
 	if (!m_is_geometry_shader_extension_supported)
 	{
 		throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
 	}

 	/* Create program objects */
 	m_po_a_invalid = gl.createProgram();
 	m_po_b_invalid = gl.createProgram();

 	/* Create shader objects */
 	m_fs				= gl.createShader(GL_FRAGMENT_SHADER);
 	m_gs_invalid_non_ib = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
 	m_gs_invalid_ib		= gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
 	m_gs_valid_non_ib   = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
 	m_gs_valid_ib		= gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
 	m_vs_valid_non_ib   = gl.createShader(GL_VERTEX_SHADER);
 	m_vs_valid_ib		= gl.createShader(GL_VERTEX_SHADER);

 	shaderSourceSpecialized(m_fs, DE_LENGTH_OF_ARRAY(fs_parts), fs_parts);
 	shaderSourceSpecialized(m_gs_invalid_non_ib, DE_LENGTH_OF_ARRAY(gs_invalid_non_ib_parts), gs_invalid_non_ib_parts);
 	shaderSourceSpecialized(m_gs_invalid_ib, DE_LENGTH_OF_ARRAY(gs_invalid_ib_parts), gs_invalid_ib_parts);
 	shaderSourceSpecialized(m_gs_valid_non_ib, DE_LENGTH_OF_ARRAY(gs_valid_non_ib_parts), gs_valid_non_ib_parts);
 	shaderSourceSpecialized(m_gs_valid_ib, DE_LENGTH_OF_ARRAY(gs_valid_ib_parts), gs_valid_ib_parts);
 	shaderSourceSpecialized(m_vs_valid_non_ib, DE_LENGTH_OF_ARRAY(vs_valid_non_ib_parts), vs_valid_non_ib_parts);
 	shaderSourceSpecialized(m_vs_valid_ib, DE_LENGTH_OF_ARRAY(vs_valid_ib_parts), vs_valid_ib_parts);

 	/* Create and form invalid programs */
 	gl.attachShader(m_po_a_invalid, m_fs);
 	gl.attachShader(m_po_a_invalid, m_gs_invalid_non_ib);
 	gl.attachShader(m_po_a_invalid, m_vs_valid_non_ib);

 	gl.attachShader(m_po_b_invalid, m_fs);
 	gl.attachShader(m_po_b_invalid, m_gs_invalid_ib);
 	gl.attachShader(m_po_b_invalid, m_vs_valid_ib);

 	/* Try to compile the shaders. Do not check GL_COMPILE_STATUS - we expect a linking failure */
 	gl.compileShader(m_fs);
 	gl.compileShader(m_gs_invalid_non_ib);
 	gl.compileShader(m_gs_invalid_ib);
 	gl.compileShader(m_vs_valid_non_ib);
 	gl.compileShader(m_vs_valid_ib);

 	/* Try to link the programs */
 	gl.linkProgram(m_po_a_invalid);
 	gl.getProgramiv(m_po_a_invalid, GL_LINK_STATUS, &link_status);

 	if (link_status != GL_FALSE)
 	{
 		m_testCtx.getLog() << tcu::TestLog::Message
 						   << "Program linked sucessfully although it shouldn't because geometry shaders are not "
 							  "expected to support non-array input attributes."
 						   << tcu::TestLog::EndMessage;

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

 	gl.linkProgram(m_po_b_invalid);
 	gl.getProgramiv(m_po_b_invalid, GL_LINK_STATUS, &link_status);

 	if (link_status != GL_FALSE)
 	{
 		m_testCtx.getLog() << tcu::TestLog::Message
 						   << "Program linked sucessfully although it shouldn't because geometry shaders are not "
 							  "expected to support non-array block input attributes."
 						   << tcu::TestLog::EndMessage;

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

 	/* Release the programs before we continue */
 	gl.deleteProgram(m_po_a_invalid);
 	gl.deleteProgram(m_po_b_invalid);

 	m_po_a_invalid = 0;
 	m_po_b_invalid = 0;

 	/* Release the invalid geometry shaders */
 	gl.deleteShader(m_gs_invalid_non_ib);
 	gl.deleteShader(m_gs_invalid_ib);

 	m_gs_invalid_non_ib = 0;
 	m_gs_invalid_ib		= 0;

 	/* Create and form valid programs */
 	m_po_a_valid = gl.createProgram();
 	m_po_b_valid = gl.createProgram();

 	gl.attachShader(m_po_a_valid, m_fs);
 	gl.attachShader(m_po_a_valid, m_gs_valid_non_ib);
 	gl.attachShader(m_po_a_valid, m_vs_valid_non_ib);

 	gl.attachShader(m_po_b_valid, m_fs);
 	gl.attachShader(m_po_b_valid, m_gs_valid_ib);
 	gl.attachShader(m_po_b_valid, m_vs_valid_ib);

 	gl.compileShader(m_gs_valid_non_ib);
 	gl.compileShader(m_gs_valid_ib);

 	gl.getShaderiv(m_gs_valid_non_ib, GL_COMPILE_STATUS, &compile_status);

 	if (compile_status != GL_TRUE)
 	{
 		std::string log = getCompilationInfoLog(m_gs_valid_non_ib);

 		m_testCtx.getLog() << tcu::TestLog::Message << "Valid geometry shader didn't compile. Error message: " << log
 						   << tcu::TestLog::EndMessage;

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

 	gl.getShaderiv(m_gs_valid_ib, GL_COMPILE_STATUS, &compile_status);

 	if (compile_status != GL_TRUE)
 	{
 		std::string log = getCompilationInfoLog(m_gs_valid_ib);

 		m_testCtx.getLog() << tcu::TestLog::Message << "Valid geometry shader didn't compile. Error message: " << log
 						   << tcu::TestLog::EndMessage;

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

 	gl.linkProgram(m_po_a_valid);
 	gl.getProgramiv(m_po_a_valid, GL_LINK_STATUS, &link_status);

 	if (link_status != GL_TRUE)
 	{
 		std::string log = getLinkingInfoLog(m_po_a_valid);

 		m_testCtx.getLog() << tcu::TestLog::Message
 						   << "Program failed to link although it was expected to link successfully. Error message: "
 						   << log << tcu::TestLog::EndMessage;

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

 	gl.linkProgram(m_po_b_valid);
 	gl.getProgramiv(m_po_b_valid, GL_LINK_STATUS, &link_status);

 	if (link_status != GL_TRUE)
 	{
 		std::string log = getLinkingInfoLog(m_po_b_valid);

 		m_testCtx.getLog() << tcu::TestLog::Message
 						   << "Program failed to link although it was expected to link successfully. Error message: "
 						   << log << tcu::TestLog::EndMessage;

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

 	/* Set up a FBO */
 	gl.genFramebuffers(1, &m_fbo_id);
 	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_id);

 	gl.genTextures(1, &m_to_id);
 	gl.bindTexture(GL_TEXTURE_2D, m_to_id);
 	gl.texStorage2D(GL_TEXTURE_2D, 1 /* levels */, GL_RGBA8, TEXTURE_WIDTH, TEXTURE_HEIGHT);
 	gl.framebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_to_id, 0 /* level */);

 	GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set up a framebuffer object");

 	gl.viewport(0 /* x */, 0 /* y */, TEXTURE_WIDTH, TEXTURE_HEIGHT);

 	/* Generate and bind a VAO */
 	gl.genVertexArrays(1, &m_vao_id);
 	gl.bindVertexArray(m_vao_id);

 	/* Set up clear color */
 	gl.clearColor(1.0f, 0, 0, 0);

 	/* Use both program objects and verify they work correctly */
 	for (m = 0; m < 2 /* programs */; ++m)
 	{
 		glw::GLuint   program = (m == 0) ? m_po_a_valid : m_po_b_valid;
 		unsigned char result[TEXTURE_WIDTH * TEXTURE_HEIGHT * 4 /*components */];

 		/* Clear the color attachment before we continue */
 		gl.clear(GL_COLOR_BUFFER_BIT);

 		/* Render! */
 		gl.useProgram(program);
 		gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);

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

 		/* Read back the result */
 		gl.readPixels(0 /* x */, 0 /* y */, TEXTURE_WIDTH, TEXTURE_HEIGHT, GL_RGBA, GL_UNSIGNED_BYTE, result);

 		GLU_EXPECT_NO_ERROR(gl.getError(), "Could not read back pixels from color attachment 0");

 		/* Verify the result data is correct */
 		for (n = 0; n < TEXTURE_WIDTH * TEXTURE_HEIGHT; ++n)
 		{
 			if (result[n * 4 + 0] != 0 || result[n * 4 + 1] != 255 || result[n * 4 + 2] != 0 ||
 				result[n * 4 + 3] != 255)
 			{
 				m_testCtx.getLog() << tcu::TestLog::Message
 								   << "Pixel data isn't correct. All pixels should have green color. Pixel at: "
 								   << "[" << n / 4 << ", " << n % 4 << "] "
 								   << "has color: "
 								   << "[" << result[n * 4 + 0] << ", " << result[n * 4 + 1] << ", " << result[n * 4 + 2]
 								   << ", " << result[n * 4 + 3] << "]" << tcu::TestLog::EndMessage;

 				m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 				return STOP;
 			} /* if (result data is invalid) */
 		}	 /* for (all pixels) */
 	}		  /* for (all programs) */

 	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 	return STOP;
 }

 /** Deinitializes GLES objects created during the test.
  *
  */
 void GeometryShaderNonarrayInputCase::deinit(void)
 {
 	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

 	/* Reset OpenGL ES state */
 	gl.useProgram(0);
 	gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
 	gl.bindVertexArray(0);

 	if (m_po_a_valid != 0)
 	{
 		gl.deleteProgram(m_po_a_valid);
 	}

 	if (m_po_b_valid != 0)
 	{
 		gl.deleteProgram(m_po_b_valid);
 	}

 	if (m_fs != 0)
 	{
 		gl.deleteShader(m_fs);
 	}

 	if (m_gs_invalid_ib != 0)
 	{
 		gl.deleteShader(m_gs_invalid_ib);
 	}

 	if (m_gs_invalid_non_ib != 0)
 	{
 		gl.deleteShader(m_gs_invalid_non_ib);
 	}

 	if (m_gs_valid_ib != 0)
 	{
 		gl.deleteShader(m_gs_valid_ib);
 	}

 	if (m_gs_valid_non_ib != 0)
 	{
 		gl.deleteShader(m_gs_valid_non_ib);
 	}

 	if (m_vs_valid_ib != 0)
 	{
 		gl.deleteShader(m_vs_valid_ib);
 	}

 	if (m_vs_valid_non_ib != 0)
 	{
 		gl.deleteShader(m_vs_valid_non_ib);
 	}

 	if (m_to_id != 0)
 	{
 		gl.deleteTextures(1, &m_to_id);
 	}

 	if (m_fbo_id != 0)
 	{
 		gl.deleteFramebuffers(1, &m_fbo_id);
 	}

 	if (m_vao_id != 0)
 	{
 		gl.deleteVertexArrays(1, &m_vao_id);
 	}

 	/* Release base class */
 	TestCaseBase::deinit();
 }

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

	#include "esextcGeometryShaderNonarrayInput.hpp"

	#include "gluContextInfo.hpp"
	#include "gluDefs.hpp"
	#include "glwEnums.hpp"
	#include "glwFunctions.hpp"
	#include "tcuTestLog.hpp"

	#include <algorithm>
	#include <string>
	#include <vector>

	namespace glcts
	{

	/* Fragment shader code */
	const char* GeometryShaderNonarrayInputCase::m_fs_code = "${VERSION}\n"
	"\n"
	"precision highp float;\n"
	"\n"
	"out vec4 color;\n"
	"\n"
	"void main()\n"
	"{\n"
	" color = vec4(0, 1, 0, 1);\n"
	"}\n";

	/* Geometry shader body parts */
	const char* GeometryShaderNonarrayInputCase::m_gs_code_preamble = "${VERSION}\n"
	"${GEOMETRY_SHADER_REQUIRE}\n"
	"\n";

	const char* GeometryShaderNonarrayInputCase::m_gs_code_body = "layout(points) in;\n"
	"layout(triangle_strip, max_vertices=4) out;\n"
	"\n"
	"#ifndef USE_BLOCK\n"
	" #define V1 v1[0]\n"
	" #define V2 v2[0]\n"
	" #define V3 v3[0]\n"
	"\n"
	" in vec4 v1[];\n"
	" in vec4 v2[];\n"
	" in vec4 v3[];\n"
	" \n"
	" #ifdef CORRUPT\n"
	" #define V4 v4\n"
	" in vec4 v4;\n"
	" #else\n"
	" #define V4 v4[0]\n"
	" in vec4 v4[];\n"
	" #endif\n"
	"#else\n"
	" in VS_GS\n"
	" {\n"
	" in vec4 v1;\n"
	" in vec4 v2;\n"
	" in vec4 v3;\n"
	" in vec4 v4;\n"
	" #ifdef CORRUPT\n"
	" } interface_block;\n"
	"\n"
	" #define V1 interface_block.v1\n"
	" #define V2 interface_block.v2\n"
	" #define V3 interface_block.v3\n"
	" #define V4 interface_block.v4\n"
	" #else\n"
	" } interface_block[];\n"
	"\n"
	" #define V1 interface_block[0].v1\n"
	" #define V2 interface_block[0].v2\n"
	" #define V3 interface_block[0].v3\n"
	" #define V4 interface_block[0].v4\n"
	" #endif\n"
	"#endif\n"
	"\n"
	"void main()\n"
	"{\n"
	" gl_Position = V1;\n"
	" EmitVertex();\n"
	" gl_Position = V2;\n"
	" EmitVertex();\n"
	" gl_Position = V3;\n"
	" EmitVertex();\n"
	" gl_Position = V4;\n"
	" EmitVertex();\n"
	" EndPrimitive();\n"
	"}\n";

	/* Vertex shader body parts */
	const char* GeometryShaderNonarrayInputCase::m_vs_code_preamble = "${VERSION}\n"
	"\n";

	const char* GeometryShaderNonarrayInputCase::m_vs_code_body = "#ifndef USE_BLOCK\n"
	" #define V1 v1\n"
	" #define V2 v2\n"
	" #define V3 v3\n"
	" #define V4 v4\n"
	"\n"
	" out vec4 v1;\n"
	" out vec4 v2;\n"
	" out vec4 v3;\n"
	" out vec4 v4;\n"
	"#else\n"
	" ${SHADER_IO_BLOCKS_ENABLE}\n"
	" #define V1 interface_block.v1\n"
	" #define V2 interface_block.v2\n"
	" #define V3 interface_block.v3\n"
	" #define V4 interface_block.v4\n"
	"\n"
	" out VS_GS\n"
	" {\n"
	" vec4 v1;\n"
	" vec4 v2;\n"
	" vec4 v3;\n"
	" vec4 v4;\n"
	" } interface_block;\n"
	"#endif\n"
	"\n"
	"void main()\n"
	"{\n"
	" V1 = vec4(-1, -1, 0, 1);\n"
	" V2 = vec4(-1, 1, 0, 1);\n"
	" V3 = vec4( 1, -1, 0, 1);\n"
	" V4 = vec4( 1, 1, 0, 1);\n"
	"}\n";

	/* Definitions */
	#define TEXTURE_HEIGHT (4)
	#define TEXTURE_WIDTH (4)

	/** Constructor
	*
	* @param context Test context
	* @param name Test case's name
	* @param description Test case's desricption
	**/
	GeometryShaderNonarrayInputCase::GeometryShaderNonarrayInputCase(Context& context, const ExtParameters& extParams,
	const char* name, const char* description)
	: TestCaseBase(context, extParams, name, description)
	, m_fbo_id(0)
	, m_fs(0)
	, m_gs_invalid_non_ib(0)
	, m_gs_invalid_ib(0)
	, m_gs_valid_non_ib(0)
	, m_gs_valid_ib(0)
	, m_po_a_invalid(0)
	, m_po_b_invalid(0)
	, m_po_a_valid(0)
	, m_po_b_valid(0)
	, m_to_id(0)
	, m_vao_id(0)
	, m_vs_valid_ib(0)
	, m_vs_valid_non_ib(0)
	{
	}

	/** Executes the test.
	* Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
	* @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again.
	* Note the function throws exception should an error occur!
	**/
	tcu::TestNode::IterateResult GeometryShaderNonarrayInputCase::iterate(void)
	{
	glw::GLint compile_status = GL_FALSE;
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();
	glw::GLint link_status = GL_FALSE;
	unsigned int m = 0;
	unsigned int n = 0;

	/* Form the shaders */
	const char* fs_parts[] = { m_fs_code };
	const char* gs_invalid_non_ib_parts[] = { m_gs_code_preamble, "#define CORRUPT\n", m_gs_code_body };
	const char* gs_invalid_ib_parts[] = { m_gs_code_preamble, "#define CORRUPT\n#define USE_BLOCK\n", m_gs_code_body };
	const char* gs_valid_non_ib_parts[] = { m_gs_code_preamble, m_gs_code_body };
	const char* gs_valid_ib_parts[] = { m_gs_code_preamble, "#define USE_BLOCK\n", m_gs_code_body };
	const char* vs_valid_non_ib_parts[] = { m_vs_code_preamble, m_vs_code_body };
	const char* vs_valid_ib_parts[] = { m_vs_code_preamble, "#define USE_BLOCK\n", m_vs_code_body };

	/* This test should only run if EXT_geometry_shader is supported.
	* Note that EXT_shader_io_blocks support is implied. */
	if (!m_is_geometry_shader_extension_supported)
	{
	throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
	}

	/* Create program objects */
	m_po_a_invalid = gl.createProgram();
	m_po_b_invalid = gl.createProgram();

	/* Create shader objects */
	m_fs = gl.createShader(GL_FRAGMENT_SHADER);
	m_gs_invalid_non_ib = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
	m_gs_invalid_ib = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
	m_gs_valid_non_ib = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
	m_gs_valid_ib = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
	m_vs_valid_non_ib = gl.createShader(GL_VERTEX_SHADER);
	m_vs_valid_ib = gl.createShader(GL_VERTEX_SHADER);

	shaderSourceSpecialized(m_fs, DE_LENGTH_OF_ARRAY(fs_parts), fs_parts);
	shaderSourceSpecialized(m_gs_invalid_non_ib, DE_LENGTH_OF_ARRAY(gs_invalid_non_ib_parts), gs_invalid_non_ib_parts);
	shaderSourceSpecialized(m_gs_invalid_ib, DE_LENGTH_OF_ARRAY(gs_invalid_ib_parts), gs_invalid_ib_parts);
	shaderSourceSpecialized(m_gs_valid_non_ib, DE_LENGTH_OF_ARRAY(gs_valid_non_ib_parts), gs_valid_non_ib_parts);
	shaderSourceSpecialized(m_gs_valid_ib, DE_LENGTH_OF_ARRAY(gs_valid_ib_parts), gs_valid_ib_parts);
	shaderSourceSpecialized(m_vs_valid_non_ib, DE_LENGTH_OF_ARRAY(vs_valid_non_ib_parts), vs_valid_non_ib_parts);
	shaderSourceSpecialized(m_vs_valid_ib, DE_LENGTH_OF_ARRAY(vs_valid_ib_parts), vs_valid_ib_parts);

	/* Create and form invalid programs */
	gl.attachShader(m_po_a_invalid, m_fs);
	gl.attachShader(m_po_a_invalid, m_gs_invalid_non_ib);
	gl.attachShader(m_po_a_invalid, m_vs_valid_non_ib);

	gl.attachShader(m_po_b_invalid, m_fs);
	gl.attachShader(m_po_b_invalid, m_gs_invalid_ib);
	gl.attachShader(m_po_b_invalid, m_vs_valid_ib);

	/* Try to compile the shaders. Do not check GL_COMPILE_STATUS - we expect a linking failure */
	gl.compileShader(m_fs);
	gl.compileShader(m_gs_invalid_non_ib);
	gl.compileShader(m_gs_invalid_ib);
	gl.compileShader(m_vs_valid_non_ib);
	gl.compileShader(m_vs_valid_ib);

	/* Try to link the programs */
	gl.linkProgram(m_po_a_invalid);
	gl.getProgramiv(m_po_a_invalid, GL_LINK_STATUS, &link_status);

	if (link_status != GL_FALSE)
	{
	m_testCtx.getLog() << tcu::TestLog::Message
	<< "Program linked sucessfully although it shouldn't because geometry shaders are not "
	"expected to support non-array input attributes."
	<< tcu::TestLog::EndMessage;

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

	gl.linkProgram(m_po_b_invalid);
	gl.getProgramiv(m_po_b_invalid, GL_LINK_STATUS, &link_status);

	if (link_status != GL_FALSE)
	{
	m_testCtx.getLog() << tcu::TestLog::Message
	<< "Program linked sucessfully although it shouldn't because geometry shaders are not "
	"expected to support non-array block input attributes."
	<< tcu::TestLog::EndMessage;

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

	/* Release the programs before we continue */
	gl.deleteProgram(m_po_a_invalid);
	gl.deleteProgram(m_po_b_invalid);

	m_po_a_invalid = 0;
	m_po_b_invalid = 0;

	/* Release the invalid geometry shaders */
	gl.deleteShader(m_gs_invalid_non_ib);
	gl.deleteShader(m_gs_invalid_ib);

	m_gs_invalid_non_ib = 0;
	m_gs_invalid_ib = 0;

	/* Create and form valid programs */
	m_po_a_valid = gl.createProgram();
	m_po_b_valid = gl.createProgram();

	gl.attachShader(m_po_a_valid, m_fs);
	gl.attachShader(m_po_a_valid, m_gs_valid_non_ib);
	gl.attachShader(m_po_a_valid, m_vs_valid_non_ib);

	gl.attachShader(m_po_b_valid, m_fs);
	gl.attachShader(m_po_b_valid, m_gs_valid_ib);
	gl.attachShader(m_po_b_valid, m_vs_valid_ib);

	gl.compileShader(m_gs_valid_non_ib);
	gl.compileShader(m_gs_valid_ib);

	gl.getShaderiv(m_gs_valid_non_ib, GL_COMPILE_STATUS, &compile_status);

	if (compile_status != GL_TRUE)
	{
	std::string log = getCompilationInfoLog(m_gs_valid_non_ib);

	m_testCtx.getLog() << tcu::TestLog::Message << "Valid geometry shader didn't compile. Error message: " << log
	<< tcu::TestLog::EndMessage;

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

	gl.getShaderiv(m_gs_valid_ib, GL_COMPILE_STATUS, &compile_status);

	if (compile_status != GL_TRUE)
	{
	std::string log = getCompilationInfoLog(m_gs_valid_ib);

	m_testCtx.getLog() << tcu::TestLog::Message << "Valid geometry shader didn't compile. Error message: " << log
	<< tcu::TestLog::EndMessage;

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

	gl.linkProgram(m_po_a_valid);
	gl.getProgramiv(m_po_a_valid, GL_LINK_STATUS, &link_status);

	if (link_status != GL_TRUE)
	{
	std::string log = getLinkingInfoLog(m_po_a_valid);

	m_testCtx.getLog() << tcu::TestLog::Message
	<< "Program failed to link although it was expected to link successfully. Error message: "
	<< log << tcu::TestLog::EndMessage;

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

	gl.linkProgram(m_po_b_valid);
	gl.getProgramiv(m_po_b_valid, GL_LINK_STATUS, &link_status);

	if (link_status != GL_TRUE)
	{
	std::string log = getLinkingInfoLog(m_po_b_valid);

	m_testCtx.getLog() << tcu::TestLog::Message
	<< "Program failed to link although it was expected to link successfully. Error message: "
	<< log << tcu::TestLog::EndMessage;

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

	/* Set up a FBO */
	gl.genFramebuffers(1, &m_fbo_id);
	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_id);

	gl.genTextures(1, &m_to_id);
	gl.bindTexture(GL_TEXTURE_2D, m_to_id);
	gl.texStorage2D(GL_TEXTURE_2D, 1 /* levels */, GL_RGBA8, TEXTURE_WIDTH, TEXTURE_HEIGHT);
	gl.framebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_to_id, 0 /* level */);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set up a framebuffer object");

	gl.viewport(0 /* x /, 0 / y */, TEXTURE_WIDTH, TEXTURE_HEIGHT);

	/* Generate and bind a VAO */
	gl.genVertexArrays(1, &m_vao_id);
	gl.bindVertexArray(m_vao_id);

	/* Set up clear color */
	gl.clearColor(1.0f, 0, 0, 0);

	/* Use both program objects and verify they work correctly */
	for (m = 0; m < 2 /* programs */; ++m)
	{
	glw::GLuint program = (m == 0) ? m_po_a_valid : m_po_b_valid;
	unsigned char result[TEXTURE_WIDTH * TEXTURE_HEIGHT * 4 /components /];

	/* Clear the color attachment before we continue */
	gl.clear(GL_COLOR_BUFFER_BIT);

	/* Render! */
	gl.useProgram(program);
	gl.drawArrays(GL_POINTS, 0 /* first /, 1 / count */);

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

	/* Read back the result */
	gl.readPixels(0 /* x /, 0 / y */, TEXTURE_WIDTH, TEXTURE_HEIGHT, GL_RGBA, GL_UNSIGNED_BYTE, result);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not read back pixels from color attachment 0");

	/* Verify the result data is correct */
	for (n = 0; n < TEXTURE_WIDTH * TEXTURE_HEIGHT; ++n)
	{
	if (result[n * 4 + 0] != 0 \|\| result[n * 4 + 1] != 255 \|\| result[n * 4 + 2] != 0 \|\|
	result[n * 4 + 3] != 255)
	{
	m_testCtx.getLog() << tcu::TestLog::Message
	<< "Pixel data isn't correct. All pixels should have green color. Pixel at: "
	<< "[" << n / 4 << ", " << n % 4 << "] "
	<< "has color: "
	<< "[" << result[n * 4 + 0] << ", " << result[n * 4 + 1] << ", " << result[n * 4 + 2]
	<< ", " << result[n * 4 + 3] << "]" << tcu::TestLog::EndMessage;

	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
	return STOP;
	} /* if (result data is invalid) */
	} /* for (all pixels) */
	} /* for (all programs) */

	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	return STOP;
	}

	/** Deinitializes GLES objects created during the test.
	*
	*/
	void GeometryShaderNonarrayInputCase::deinit(void)
	{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Reset OpenGL ES state */
	gl.useProgram(0);
	gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
	gl.bindVertexArray(0);

	if (m_po_a_valid != 0)
	{
	gl.deleteProgram(m_po_a_valid);
	}

	if (m_po_b_valid != 0)
	{
	gl.deleteProgram(m_po_b_valid);
	}

	if (m_fs != 0)
	{
	gl.deleteShader(m_fs);
	}

	if (m_gs_invalid_ib != 0)
	{
	gl.deleteShader(m_gs_invalid_ib);
	}

	if (m_gs_invalid_non_ib != 0)
	{
	gl.deleteShader(m_gs_invalid_non_ib);
	}

	if (m_gs_valid_ib != 0)
	{
	gl.deleteShader(m_gs_valid_ib);
	}

	if (m_gs_valid_non_ib != 0)
	{
	gl.deleteShader(m_gs_valid_non_ib);
	}

	if (m_vs_valid_ib != 0)
	{
	gl.deleteShader(m_vs_valid_ib);
	}

	if (m_vs_valid_non_ib != 0)
	{
	gl.deleteShader(m_vs_valid_non_ib);
	}

	if (m_to_id != 0)
	{
	gl.deleteTextures(1, &m_to_id);
	}

	if (m_fbo_id != 0)
	{
	gl.deleteFramebuffers(1, &m_fbo_id);
	}

	if (m_vao_id != 0)
	{
	gl.deleteVertexArrays(1, &m_vao_id);
	}

	/* Release base class */
	TestCaseBase::deinit();
	}

	} // namespace glcts