external/openglcts/modules/glesext/tessellation_shader/esextcTessellationShaderProperties.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 "esextcTessellationShaderProperties.hpp"
 #include "gluContextInfo.hpp"
 #include "gluDefs.hpp"
 #include "glwEnums.hpp"
 #include "glwFunctions.hpp"
 #include "tcuTestLog.hpp"
 #include <cmath>
 #include <cstring>

 namespace glcts
 {
 /** Constructor
  *
  * @param context Test context
  **/
 TessellationShaderPropertiesDefaultContextWideValues::TessellationShaderPropertiesDefaultContextWideValues(
 	Context& context, const ExtParameters& extParams)
 	: TestCaseBase(context, extParams, "default_values_of_context_wide_properties",
 				   "Verifies default values of context-wide tessellation stage properties")
 {
 	/* Left blank on purpose */
 }

 /** Executes the test.
  *
  *  Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
  *
  *  Note the function throws exception should an error occur!
  *
  *  @return STOP if the test has finished, CONTINUE to indicate iterate() should be called once again.
  **/
 tcu::TestNode::IterateResult TessellationShaderPropertiesDefaultContextWideValues::iterate(void)
 {
 	/* Do not execute if required extensions are not supported. */
 	if (!m_is_tessellation_shader_supported)
 	{
 		throw tcu::NotSupportedError(TESSELLATION_SHADER_EXTENSION_NOT_SUPPORTED);
 	}

 	/* Iterate through all context-wide properties and compare expected values
 	 * against the reference ones
 	 */
 	const float			  epsilon = (float)1e-5;
 	const glw::Functions& gl	  = m_context.getRenderContext().getFunctions();

 	const glw::GLint property_value_data[] = { /* pname */ /* n components */ /* default value */
 											   static_cast<glw::GLint>(m_glExtTokens.PATCH_VERTICES), 1, 3,
 											   /* The following values are only applicable to Desktop OpenGL. */
 											   GL_PATCH_DEFAULT_OUTER_LEVEL, 4, 1, GL_PATCH_DEFAULT_INNER_LEVEL, 2, 1 };

 	const unsigned int n_properties = (glu::isContextTypeES(m_context.getRenderContext().getType())) ? 1 : 3;

 	for (unsigned int n_property = 0; n_property < n_properties; ++n_property)
 	{
 		glw::GLboolean bool_value[4]  = { GL_FALSE };
 		glw::GLfloat   float_value[4] = { 0.0f };
 		glw::GLint	 int_value[4]   = { 0 };

 		glw::GLenum pname		   = property_value_data[n_property * 3 + 0];
 		glw::GLint  n_components   = property_value_data[n_property * 3 + 1];
 		glw::GLint  expected_value = property_value_data[n_property * 3 + 2];

 		/* Call all relevant getters */
 		gl.getBooleanv(pname, bool_value);
 		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv() failed.");

 		gl.getFloatv(pname, float_value);
 		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetFloatv() failed.");

 		gl.getIntegerv(pname, int_value);
 		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed.");

 		/* Compare retrieved vector value components against expected value */
 		glw::GLboolean expected_bool_value[4] = {
 			(expected_value != 0) ? (glw::GLboolean)GL_TRUE : (glw::GLboolean)GL_FALSE,
 			(expected_value != 0) ? (glw::GLboolean)GL_TRUE : (glw::GLboolean)GL_FALSE,
 			(expected_value != 0) ? (glw::GLboolean)GL_TRUE : (glw::GLboolean)GL_FALSE,
 			(expected_value != 0) ? (glw::GLboolean)GL_TRUE : (glw::GLboolean)GL_FALSE
 		};
 		glw::GLint expected_int_value[4] = { expected_value, expected_value, expected_value, expected_value };

 		if (memcmp(expected_bool_value, bool_value, sizeof(bool) * n_components) != 0)
 		{
 			m_testCtx.getLog() << tcu::TestLog::Message << "glGetBooleanv() called for pname " << pname
 							   << " reported invalid value." << tcu::TestLog::EndMessage;

 			TCU_FAIL("Invalid value reported by glGetBooleanv()");
 		}

 		if (memcmp(expected_int_value, int_value, sizeof(int) * n_components) != 0)
 		{
 			m_testCtx.getLog() << tcu::TestLog::Message << "glGetIntegerv() called for pname " << pname
 							   << " reported invalid value." << tcu::TestLog::EndMessage;

 			TCU_FAIL("Invalid value reported by glGetIntegerv()");
 		}

 		if ((n_components >= 1 && de::abs(float_value[0] - (float)expected_value) > epsilon) ||
 			(n_components >= 2 && de::abs(float_value[1] - (float)expected_value) > epsilon) ||
 			(n_components >= 3 && de::abs(float_value[2] - (float)expected_value) > epsilon) ||
 			(n_components >= 4 && de::abs(float_value[3] - (float)expected_value) > epsilon))
 		{
 			m_testCtx.getLog() << tcu::TestLog::Message << "glGetFloatv() called for pname " << pname
 							   << " reported invalid value." << tcu::TestLog::EndMessage;

 			TCU_FAIL("Invalid value reported by glGetFloatv()");
 		}
 	} /* for (all properties) */

 	/* All done */
 	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 	return STOP;
 }

 /** Constructor
  *
  * @param context Test context
  **/
 TessellationShaderPropertiesProgramObject::TessellationShaderPropertiesProgramObject(Context&			  context,
 																					 const ExtParameters& extParams)
 	: TestCaseBase(context, extParams, "program_object_properties",
 				   "Verifies tessellation-specific properties of program objects are reported correctly.")
 	, m_fs_id(0)
 	, m_po_id(0)
 	, m_tc_id(0)
 	, m_te_id(0)
 	, m_vs_id(0)
 {
 	/* Left blank on purpose */
 }

 /** Deinitializes ES objects created for the test */
 void TessellationShaderPropertiesProgramObject::deinit(void)
 {
 	/* Call base class' deinit() */
 	TestCaseBase::deinit();

 	/* Release any ES objects created */
 	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

 	if (m_fs_id != 0)
 	{
 		gl.deleteShader(m_fs_id);

 		m_fs_id = 0;
 	}

 	if (m_po_id != 0)
 	{
 		gl.deleteProgram(m_po_id);

 		m_po_id = 0;
 	}

 	if (m_tc_id != 0)
 	{
 		gl.deleteShader(m_tc_id);

 		m_tc_id = 0;
 	}

 	if (m_te_id != 0)
 	{
 		gl.deleteShader(m_te_id);

 		m_te_id = 0;
 	}

 	if (m_vs_id != 0)
 	{
 		gl.deleteShader(m_vs_id);

 		m_vs_id = 0;
 	}
 }

 /** Initializes ES objects necessary to execute the test */
 void TessellationShaderPropertiesProgramObject::initTest(void)
 {
 	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

 	/* Do not execute if required extension is not supported */
 	if (!m_is_tessellation_shader_supported)
 	{
 		return;
 	}

 	/* Generate all objects */
 	m_po_id = gl.createProgram();
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() failed");

 	m_fs_id = gl.createShader(GL_FRAGMENT_SHADER);
 	m_tc_id = gl.createShader(m_glExtTokens.TESS_CONTROL_SHADER);
 	m_te_id = gl.createShader(m_glExtTokens.TESS_EVALUATION_SHADER);
 	m_vs_id = gl.createShader(GL_VERTEX_SHADER);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() failed");

 	/* Attach the shader to the program object */
 	gl.attachShader(m_po_id, m_fs_id);
 	gl.attachShader(m_po_id, m_tc_id);
 	gl.attachShader(m_po_id, m_te_id);
 	gl.attachShader(m_po_id, m_vs_id);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() failed");

 	/* Since this test does not care much about fragment & vertex shaders, set
 	 * their bodies and compile these shaders now */
 	const char* fs_body = "${VERSION}\n"
 						  "\n"
 						  "void main()\n"
 						  "{\n"
 						  "}\n";

 	const char* vs_body = "${VERSION}\n"
 						  "\n"
 						  "void main()\n"
 						  "{\n"
 						  "}\n";

 	glw::GLint fs_compile_status = GL_FALSE;
 	glw::GLint vs_compile_status = GL_FALSE;

 	shaderSourceSpecialized(m_fs_id, 1 /* count */, &fs_body);
 	shaderSourceSpecialized(m_vs_id, 1 /* count */, &vs_body);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() failed");

 	gl.compileShader(m_fs_id);
 	gl.compileShader(m_vs_id);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() failed");

 	gl.getShaderiv(m_fs_id, GL_COMPILE_STATUS, &fs_compile_status);
 	gl.getShaderiv(m_vs_id, GL_COMPILE_STATUS, &vs_compile_status);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() failed");

 	if (fs_compile_status != GL_TRUE)
 	{
 		TCU_FAIL("Could not compile fragment shader");
 	}

 	if (vs_compile_status != GL_TRUE)
 	{
 		TCU_FAIL("Could not compile vertex shader");
 	}
 }

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

 	/* Do not execute if required extensions are not supported. */
 	if (!m_is_tessellation_shader_supported)
 	{
 		throw tcu::NotSupportedError(TESSELLATION_SHADER_EXTENSION_NOT_SUPPORTED);
 	}

 	/* Initialize ES test objects */
 	initTest();

 	/* Test 1: Default values. Values as per spec, define as little qualifiers as possible */
 	_test_descriptor test_1;

 	test_1.expected_control_output_vertices_value = 4;
 	test_1.expected_gen_mode_value				  = m_glExtTokens.QUADS;
 	test_1.expected_gen_point_mode_value		  = GL_FALSE;
 	test_1.expected_gen_spacing_value			  = GL_EQUAL;
 	test_1.expected_gen_vertex_order_value		  = GL_CCW;
 	test_1.tc_body								  = "${VERSION}\n"
 					 "${TESSELLATION_SHADER_REQUIRE}\n"
 					 "\n"
 					 "layout(vertices=4) out;\n"
 					 "\n"
 					 "void main()\n"
 					 "{\n"
 					 "    gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
 					 "}\n";
 	test_1.te_body = "${VERSION}\n"
 					 "${TESSELLATION_SHADER_REQUIRE}\n"
 					 "\n"
 					 "layout(quads) in;\n"
 					 "\n"
 					 "void main()\n"
 					 "{\n"
 					 "    gl_Position = gl_in[0].gl_Position;\n"
 					 "}\n";

 	/* Test 2: 16 vertices per patch + isolines + fractional_even_spacing + cw combination */
 	_test_descriptor test_2;

 	test_2.expected_control_output_vertices_value = 16;
 	test_2.expected_gen_mode_value				  = m_glExtTokens.ISOLINES;
 	test_2.expected_gen_point_mode_value		  = GL_FALSE;
 	test_2.expected_gen_spacing_value			  = m_glExtTokens.FRACTIONAL_EVEN;
 	test_2.expected_gen_vertex_order_value		  = GL_CW;
 	test_2.tc_body								  = "${VERSION}\n"
 					 "${TESSELLATION_SHADER_REQUIRE}\n"
 					 "\n"
 					 "layout(vertices=16) out;\n"
 					 "\n"
 					 "void main()\n"
 					 "{\n"
 					 "    gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
 					 "}\n";
 	test_2.te_body = "${VERSION}\n"
 					 "${TESSELLATION_SHADER_REQUIRE}\n"
 					 "\n"
 					 "layout(isolines, fractional_even_spacing, cw) in;\n"
 					 "\n"
 					 "void main()\n"
 					 "{\n"
 					 "    gl_Position = gl_in[0].gl_Position;\n"
 					 "}\n";

 	/* Test 3: 32 vertices per patch + triangles + fractional_odd_spacing + ccw combination + point mode*/
 	_test_descriptor test_3;

 	test_3.expected_control_output_vertices_value = 32;
 	test_3.expected_gen_mode_value				  = GL_TRIANGLES;
 	test_3.expected_gen_point_mode_value		  = GL_TRUE;
 	test_3.expected_gen_spacing_value			  = m_glExtTokens.FRACTIONAL_ODD;
 	test_3.expected_gen_vertex_order_value		  = GL_CCW;
 	test_3.tc_body								  = "${VERSION}\n"
 					 "${TESSELLATION_SHADER_REQUIRE}\n"
 					 "\n"
 					 "layout(vertices=32) out;\n"
 					 "\n"
 					 "void main()\n"
 					 "{\n"
 					 "    gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
 					 "}\n";
 	test_3.te_body = "${VERSION}\n"
 					 "${TESSELLATION_SHADER_REQUIRE}\n"
 					 "\n"
 					 "layout(triangles, fractional_odd_spacing, ccw, point_mode) in;\n"
 					 "\n"
 					 "void main()\n"
 					 "{\n"
 					 "    gl_Position = gl_in[0].gl_Position;\n"
 					 "}\n";

 	/* Test 4: 8 vertices per patch + quads + equal_spacing + ccw combination + point mode*/
 	_test_descriptor test_4;

 	test_4.expected_control_output_vertices_value = 8;
 	test_4.expected_gen_mode_value				  = m_glExtTokens.QUADS;
 	test_4.expected_gen_point_mode_value		  = GL_TRUE;
 	test_4.expected_gen_spacing_value			  = GL_EQUAL;
 	test_4.expected_gen_vertex_order_value		  = GL_CCW;
 	test_4.tc_body								  = "${VERSION}\n"
 					 "${TESSELLATION_SHADER_REQUIRE}\n"
 					 "\n"
 					 "layout(vertices=8) out;\n"
 					 "\n"
 					 "void main()\n"
 					 "{\n"
 					 "    gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
 					 "}\n";
 	test_4.te_body = "${VERSION}\n"
 					 "${TESSELLATION_SHADER_REQUIRE}\n"
 					 "\n"
 					 "layout(quads, equal_spacing, ccw, point_mode) in;\n"
 					 "\n"
 					 "void main()\n"
 					 "{\n"
 					 "    gl_Position = gl_in[0].gl_Position;\n"
 					 "}\n";

 	/* Store all tests in a single vector */
 	_tests tests;

 	tests.push_back(test_1);
 	tests.push_back(test_2);
 	tests.push_back(test_3);
 	tests.push_back(test_4);

 	/* Iterate through all the tests and verify the values reported */
 	for (_tests_const_iterator test_iterator = tests.begin(); test_iterator != tests.end(); test_iterator++)
 	{
 		const _test_descriptor& test = *test_iterator;

 		/* Set tessellation control & evaluation shader bodies. */
 		shaderSourceSpecialized(m_tc_id, 1 /* count */, &test.tc_body);
 		shaderSourceSpecialized(m_te_id, 1 /* count */, &test.te_body);

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

 		/* Compile the shaders */
 		gl.compileShader(m_tc_id);
 		gl.compileShader(m_te_id);

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

 		/* Make sure the shaders compiled */
 		glw::GLint tc_compile_status = GL_FALSE;
 		glw::GLint te_compile_status = GL_FALSE;

 		gl.getShaderiv(m_tc_id, GL_COMPILE_STATUS, &tc_compile_status);
 		gl.getShaderiv(m_te_id, GL_COMPILE_STATUS, &te_compile_status);

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

 		if (tc_compile_status != GL_TRUE)
 		{
 			TCU_FAIL("Could not compile tessellation control shader");
 		}

 		if (te_compile_status != GL_TRUE)
 		{
 			TCU_FAIL("Could not compile tessellation evaluation shader");
 		}

 		/* Try to link the program object */
 		glw::GLint link_status = GL_FALSE;

 		gl.linkProgram(m_po_id);
 		GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() failed");

 		gl.getProgramiv(m_po_id, GL_LINK_STATUS, &link_status);
 		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() failed");

 		if (link_status != GL_TRUE)
 		{
 			TCU_FAIL("Program linking failed");
 		}

 		/* Query the tessellation properties of the program object and make sure
 		 * the values reported are valid */
 		glw::GLint control_output_vertices_value = 0;
 		glw::GLint gen_mode_value				 = GL_NONE;
 		glw::GLint gen_spacing_value			 = GL_NONE;
 		glw::GLint gen_vertex_order_value		 = GL_NONE;
 		glw::GLint gen_point_mode_value			 = GL_NONE;

 		gl.getProgramiv(m_po_id, m_glExtTokens.TESS_CONTROL_OUTPUT_VERTICES, &control_output_vertices_value);
 		gl.getProgramiv(m_po_id, m_glExtTokens.TESS_GEN_MODE, &gen_mode_value);
 		gl.getProgramiv(m_po_id, m_glExtTokens.TESS_GEN_SPACING, &gen_spacing_value);
 		gl.getProgramiv(m_po_id, m_glExtTokens.TESS_GEN_POINT_MODE, &gen_point_mode_value);
 		gl.getProgramiv(m_po_id, m_glExtTokens.TESS_GEN_VERTEX_ORDER, &gen_vertex_order_value);
 		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() for tessellation-specific properties failed.");

 		if (control_output_vertices_value != test.expected_control_output_vertices_value)
 		{
 			m_testCtx.getLog() << tcu::TestLog::Message
 							   << "Invalid value reported for GL_TESS_CONTROL_OUTPUT_VERTICES_EXT property; "
 							   << " expected: " << test.expected_control_output_vertices_value
 							   << ", retrieved: " << control_output_vertices_value << tcu::TestLog::EndMessage;

 			TCU_FAIL("Invalid value reported for GL_TESS_CONTROL_OUTPUT_VERTICES_EXT property.");
 		}

 		if ((glw::GLuint)gen_mode_value != test.expected_gen_mode_value)
 		{
 			m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported for GL_TESS_GEN_MODE_EXT property; "
 							   << " expected: " << test.expected_gen_mode_value << ", retrieved: " << gen_mode_value
 							   << tcu::TestLog::EndMessage;

 			TCU_FAIL("Invalid value reported for GL_TESS_GEN_MODE_EXT property.");
 		}

 		if ((glw::GLuint)gen_spacing_value != test.expected_gen_spacing_value)
 		{
 			m_testCtx.getLog() << tcu::TestLog::Message
 							   << "Invalid value reported for GL_TESS_GEN_SPACING_EXT property; "
 							   << " expected: " << test.expected_gen_spacing_value
 							   << ", retrieved: " << gen_spacing_value << tcu::TestLog::EndMessage;

 			TCU_FAIL("Invalid value reported for GL_TESS_GEN_SPACING_EXT property.");
 		}

 		if ((glw::GLuint)gen_point_mode_value != test.expected_gen_point_mode_value)
 		{
 			m_testCtx.getLog() << tcu::TestLog::Message
 							   << "Invalid value reported for GL_TESS_GEN_POINT_MODE_EXT property; "
 							   << " expected: " << test.expected_gen_point_mode_value
 							   << ", retrieved: " << gen_point_mode_value << tcu::TestLog::EndMessage;

 			TCU_FAIL("Invalid value reported for GL_TESS_GEN_POINT_MODE_EXT property.");
 		}

 		if ((glw::GLuint)gen_vertex_order_value != test.expected_gen_vertex_order_value)
 		{
 			m_testCtx.getLog() << tcu::TestLog::Message
 							   << "Invalid value reported for GL_TESS_GEN_VERTEX_ORDER_EXT property; "
 							   << " expected: " << test.expected_gen_vertex_order_value
 							   << ", retrieved: " << gen_vertex_order_value << tcu::TestLog::EndMessage;

 			TCU_FAIL("Invalid value reported for GL_TESS_GEN_VERTEX_ORDER_EXT property.");
 		}
 	} /* for (all test descriptors) */

 	/* All done */
 	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 	return STOP;
 }

 } /* 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 "esextcTessellationShaderProperties.hpp"
	#include "gluContextInfo.hpp"
	#include "gluDefs.hpp"
	#include "glwEnums.hpp"
	#include "glwFunctions.hpp"
	#include "tcuTestLog.hpp"
	#include <cmath>
	#include <cstring>

	namespace glcts
	{
	/** Constructor
	*
	* @param context Test context
	**/
	TessellationShaderPropertiesDefaultContextWideValues::TessellationShaderPropertiesDefaultContextWideValues(
	Context& context, const ExtParameters& extParams)
	: TestCaseBase(context, extParams, "default_values_of_context_wide_properties",
	"Verifies default values of context-wide tessellation stage properties")
	{
	/* Left blank on purpose */
	}

	/** Executes the test.
	*
	* Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
	*
	* Note the function throws exception should an error occur!
	*
	* @return STOP if the test has finished, CONTINUE to indicate iterate() should be called once again.
	**/
	tcu::TestNode::IterateResult TessellationShaderPropertiesDefaultContextWideValues::iterate(void)
	{
	/* Do not execute if required extensions are not supported. */
	if (!m_is_tessellation_shader_supported)
	{
	throw tcu::NotSupportedError(TESSELLATION_SHADER_EXTENSION_NOT_SUPPORTED);
	}

	/* Iterate through all context-wide properties and compare expected values
	* against the reference ones
	*/
	const float epsilon = (float)1e-5;
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	const glw::GLint property_value_data[] = { /* pname / / n components / / default value */
	static_cast<glw::GLint>(m_glExtTokens.PATCH_VERTICES), 1, 3,
	/* The following values are only applicable to Desktop OpenGL. */
	GL_PATCH_DEFAULT_OUTER_LEVEL, 4, 1, GL_PATCH_DEFAULT_INNER_LEVEL, 2, 1 };

	const unsigned int n_properties = (glu::isContextTypeES(m_context.getRenderContext().getType())) ? 1 : 3;

	for (unsigned int n_property = 0; n_property < n_properties; ++n_property)
	{
	glw::GLboolean bool_value[4] = { GL_FALSE };
	glw::GLfloat float_value[4] = { 0.0f };
	glw::GLint int_value[4] = { 0 };

	glw::GLenum pname = property_value_data[n_property * 3 + 0];
	glw::GLint n_components = property_value_data[n_property * 3 + 1];
	glw::GLint expected_value = property_value_data[n_property * 3 + 2];

	/* Call all relevant getters */
	gl.getBooleanv(pname, bool_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv() failed.");

	gl.getFloatv(pname, float_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetFloatv() failed.");

	gl.getIntegerv(pname, int_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed.");

	/* Compare retrieved vector value components against expected value */
	glw::GLboolean expected_bool_value[4] = {
	(expected_value != 0) ? (glw::GLboolean)GL_TRUE : (glw::GLboolean)GL_FALSE,
	(expected_value != 0) ? (glw::GLboolean)GL_TRUE : (glw::GLboolean)GL_FALSE,
	(expected_value != 0) ? (glw::GLboolean)GL_TRUE : (glw::GLboolean)GL_FALSE,
	(expected_value != 0) ? (glw::GLboolean)GL_TRUE : (glw::GLboolean)GL_FALSE
	};
	glw::GLint expected_int_value[4] = { expected_value, expected_value, expected_value, expected_value };

	if (memcmp(expected_bool_value, bool_value, sizeof(bool) * n_components) != 0)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "glGetBooleanv() called for pname " << pname
	<< " reported invalid value." << tcu::TestLog::EndMessage;

	TCU_FAIL("Invalid value reported by glGetBooleanv()");
	}

	if (memcmp(expected_int_value, int_value, sizeof(int) * n_components) != 0)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "glGetIntegerv() called for pname " << pname
	<< " reported invalid value." << tcu::TestLog::EndMessage;

	TCU_FAIL("Invalid value reported by glGetIntegerv()");
	}

	if ((n_components >= 1 && de::abs(float_value[0] - (float)expected_value) > epsilon) \|\|
	(n_components >= 2 && de::abs(float_value[1] - (float)expected_value) > epsilon) \|\|
	(n_components >= 3 && de::abs(float_value[2] - (float)expected_value) > epsilon) \|\|
	(n_components >= 4 && de::abs(float_value[3] - (float)expected_value) > epsilon))
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "glGetFloatv() called for pname " << pname
	<< " reported invalid value." << tcu::TestLog::EndMessage;

	TCU_FAIL("Invalid value reported by glGetFloatv()");
	}
	} /* for (all properties) */

	/* All done */
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	return STOP;
	}

	/** Constructor
	*
	* @param context Test context
	**/
	TessellationShaderPropertiesProgramObject::TessellationShaderPropertiesProgramObject(Context& context,
	const ExtParameters& extParams)
	: TestCaseBase(context, extParams, "program_object_properties",
	"Verifies tessellation-specific properties of program objects are reported correctly.")
	, m_fs_id(0)
	, m_po_id(0)
	, m_tc_id(0)
	, m_te_id(0)
	, m_vs_id(0)
	{
	/* Left blank on purpose */
	}

	/** Deinitializes ES objects created for the test */
	void TessellationShaderPropertiesProgramObject::deinit(void)
	{
	/* Call base class' deinit() */
	TestCaseBase::deinit();

	/* Release any ES objects created */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	if (m_fs_id != 0)
	{
	gl.deleteShader(m_fs_id);

	m_fs_id = 0;
	}

	if (m_po_id != 0)
	{
	gl.deleteProgram(m_po_id);

	m_po_id = 0;
	}

	if (m_tc_id != 0)
	{
	gl.deleteShader(m_tc_id);

	m_tc_id = 0;
	}

	if (m_te_id != 0)
	{
	gl.deleteShader(m_te_id);

	m_te_id = 0;
	}

	if (m_vs_id != 0)
	{
	gl.deleteShader(m_vs_id);

	m_vs_id = 0;
	}
	}

	/** Initializes ES objects necessary to execute the test */
	void TessellationShaderPropertiesProgramObject::initTest(void)
	{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Do not execute if required extension is not supported */
	if (!m_is_tessellation_shader_supported)
	{
	return;
	}

	/* Generate all objects */
	m_po_id = gl.createProgram();
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() failed");

	m_fs_id = gl.createShader(GL_FRAGMENT_SHADER);
	m_tc_id = gl.createShader(m_glExtTokens.TESS_CONTROL_SHADER);
	m_te_id = gl.createShader(m_glExtTokens.TESS_EVALUATION_SHADER);
	m_vs_id = gl.createShader(GL_VERTEX_SHADER);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() failed");

	/* Attach the shader to the program object */
	gl.attachShader(m_po_id, m_fs_id);
	gl.attachShader(m_po_id, m_tc_id);
	gl.attachShader(m_po_id, m_te_id);
	gl.attachShader(m_po_id, m_vs_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() failed");

	/* Since this test does not care much about fragment & vertex shaders, set
	* their bodies and compile these shaders now */
	const char* fs_body = "${VERSION}\n"
	"\n"
	"void main()\n"
	"{\n"
	"}\n";

	const char* vs_body = "${VERSION}\n"
	"\n"
	"void main()\n"
	"{\n"
	"}\n";

	glw::GLint fs_compile_status = GL_FALSE;
	glw::GLint vs_compile_status = GL_FALSE;

	shaderSourceSpecialized(m_fs_id, 1 /* count */, &fs_body);
	shaderSourceSpecialized(m_vs_id, 1 /* count */, &vs_body);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() failed");

	gl.compileShader(m_fs_id);
	gl.compileShader(m_vs_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() failed");

	gl.getShaderiv(m_fs_id, GL_COMPILE_STATUS, &fs_compile_status);
	gl.getShaderiv(m_vs_id, GL_COMPILE_STATUS, &vs_compile_status);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() failed");

	if (fs_compile_status != GL_TRUE)
	{
	TCU_FAIL("Could not compile fragment shader");
	}

	if (vs_compile_status != GL_TRUE)
	{
	TCU_FAIL("Could not compile vertex shader");
	}
	}

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

	/* Do not execute if required extensions are not supported. */
	if (!m_is_tessellation_shader_supported)
	{
	throw tcu::NotSupportedError(TESSELLATION_SHADER_EXTENSION_NOT_SUPPORTED);
	}

	/* Initialize ES test objects */
	initTest();

	/* Test 1: Default values. Values as per spec, define as little qualifiers as possible */
	_test_descriptor test_1;

	test_1.expected_control_output_vertices_value = 4;
	test_1.expected_gen_mode_value = m_glExtTokens.QUADS;
	test_1.expected_gen_point_mode_value = GL_FALSE;
	test_1.expected_gen_spacing_value = GL_EQUAL;
	test_1.expected_gen_vertex_order_value = GL_CCW;
	test_1.tc_body = "${VERSION}\n"
	"${TESSELLATION_SHADER_REQUIRE}\n"
	"\n"
	"layout(vertices=4) out;\n"
	"\n"
	"void main()\n"
	"{\n"
	" gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
	"}\n";
	test_1.te_body = "${VERSION}\n"
	"${TESSELLATION_SHADER_REQUIRE}\n"
	"\n"
	"layout(quads) in;\n"
	"\n"
	"void main()\n"
	"{\n"
	" gl_Position = gl_in[0].gl_Position;\n"
	"}\n";

	/* Test 2: 16 vertices per patch + isolines + fractional_even_spacing + cw combination */
	_test_descriptor test_2;

	test_2.expected_control_output_vertices_value = 16;
	test_2.expected_gen_mode_value = m_glExtTokens.ISOLINES;
	test_2.expected_gen_point_mode_value = GL_FALSE;
	test_2.expected_gen_spacing_value = m_glExtTokens.FRACTIONAL_EVEN;
	test_2.expected_gen_vertex_order_value = GL_CW;
	test_2.tc_body = "${VERSION}\n"
	"${TESSELLATION_SHADER_REQUIRE}\n"
	"\n"
	"layout(vertices=16) out;\n"
	"\n"
	"void main()\n"
	"{\n"
	" gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
	"}\n";
	test_2.te_body = "${VERSION}\n"
	"${TESSELLATION_SHADER_REQUIRE}\n"
	"\n"
	"layout(isolines, fractional_even_spacing, cw) in;\n"
	"\n"
	"void main()\n"
	"{\n"
	" gl_Position = gl_in[0].gl_Position;\n"
	"}\n";

	/* Test 3: 32 vertices per patch + triangles + fractional_odd_spacing + ccw combination + point mode*/
	_test_descriptor test_3;

	test_3.expected_control_output_vertices_value = 32;
	test_3.expected_gen_mode_value = GL_TRIANGLES;
	test_3.expected_gen_point_mode_value = GL_TRUE;
	test_3.expected_gen_spacing_value = m_glExtTokens.FRACTIONAL_ODD;
	test_3.expected_gen_vertex_order_value = GL_CCW;
	test_3.tc_body = "${VERSION}\n"
	"${TESSELLATION_SHADER_REQUIRE}\n"
	"\n"
	"layout(vertices=32) out;\n"
	"\n"
	"void main()\n"
	"{\n"
	" gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
	"}\n";
	test_3.te_body = "${VERSION}\n"
	"${TESSELLATION_SHADER_REQUIRE}\n"
	"\n"
	"layout(triangles, fractional_odd_spacing, ccw, point_mode) in;\n"
	"\n"
	"void main()\n"
	"{\n"
	" gl_Position = gl_in[0].gl_Position;\n"
	"}\n";

	/* Test 4: 8 vertices per patch + quads + equal_spacing + ccw combination + point mode*/
	_test_descriptor test_4;

	test_4.expected_control_output_vertices_value = 8;
	test_4.expected_gen_mode_value = m_glExtTokens.QUADS;
	test_4.expected_gen_point_mode_value = GL_TRUE;
	test_4.expected_gen_spacing_value = GL_EQUAL;
	test_4.expected_gen_vertex_order_value = GL_CCW;
	test_4.tc_body = "${VERSION}\n"
	"${TESSELLATION_SHADER_REQUIRE}\n"
	"\n"
	"layout(vertices=8) out;\n"
	"\n"
	"void main()\n"
	"{\n"
	" gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
	"}\n";
	test_4.te_body = "${VERSION}\n"
	"${TESSELLATION_SHADER_REQUIRE}\n"
	"\n"
	"layout(quads, equal_spacing, ccw, point_mode) in;\n"
	"\n"
	"void main()\n"
	"{\n"
	" gl_Position = gl_in[0].gl_Position;\n"
	"}\n";

	/* Store all tests in a single vector */
	_tests tests;

	tests.push_back(test_1);
	tests.push_back(test_2);
	tests.push_back(test_3);
	tests.push_back(test_4);

	/* Iterate through all the tests and verify the values reported */
	for (_tests_const_iterator test_iterator = tests.begin(); test_iterator != tests.end(); test_iterator++)
	{
	const _test_descriptor& test = *test_iterator;

	/* Set tessellation control & evaluation shader bodies. */
	shaderSourceSpecialized(m_tc_id, 1 /* count */, &test.tc_body);
	shaderSourceSpecialized(m_te_id, 1 /* count */, &test.te_body);

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

	/* Compile the shaders */
	gl.compileShader(m_tc_id);
	gl.compileShader(m_te_id);

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

	/* Make sure the shaders compiled */
	glw::GLint tc_compile_status = GL_FALSE;
	glw::GLint te_compile_status = GL_FALSE;

	gl.getShaderiv(m_tc_id, GL_COMPILE_STATUS, &tc_compile_status);
	gl.getShaderiv(m_te_id, GL_COMPILE_STATUS, &te_compile_status);

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

	if (tc_compile_status != GL_TRUE)
	{
	TCU_FAIL("Could not compile tessellation control shader");
	}

	if (te_compile_status != GL_TRUE)
	{
	TCU_FAIL("Could not compile tessellation evaluation shader");
	}

	/* Try to link the program object */
	glw::GLint link_status = GL_FALSE;

	gl.linkProgram(m_po_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() failed");

	gl.getProgramiv(m_po_id, GL_LINK_STATUS, &link_status);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() failed");

	if (link_status != GL_TRUE)
	{
	TCU_FAIL("Program linking failed");
	}

	/* Query the tessellation properties of the program object and make sure
	* the values reported are valid */
	glw::GLint control_output_vertices_value = 0;
	glw::GLint gen_mode_value = GL_NONE;
	glw::GLint gen_spacing_value = GL_NONE;
	glw::GLint gen_vertex_order_value = GL_NONE;
	glw::GLint gen_point_mode_value = GL_NONE;

	gl.getProgramiv(m_po_id, m_glExtTokens.TESS_CONTROL_OUTPUT_VERTICES, &control_output_vertices_value);
	gl.getProgramiv(m_po_id, m_glExtTokens.TESS_GEN_MODE, &gen_mode_value);
	gl.getProgramiv(m_po_id, m_glExtTokens.TESS_GEN_SPACING, &gen_spacing_value);
	gl.getProgramiv(m_po_id, m_glExtTokens.TESS_GEN_POINT_MODE, &gen_point_mode_value);
	gl.getProgramiv(m_po_id, m_glExtTokens.TESS_GEN_VERTEX_ORDER, &gen_vertex_order_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() for tessellation-specific properties failed.");

	if (control_output_vertices_value != test.expected_control_output_vertices_value)
	{
	m_testCtx.getLog() << tcu::TestLog::Message
	<< "Invalid value reported for GL_TESS_CONTROL_OUTPUT_VERTICES_EXT property; "
	<< " expected: " << test.expected_control_output_vertices_value
	<< ", retrieved: " << control_output_vertices_value << tcu::TestLog::EndMessage;

	TCU_FAIL("Invalid value reported for GL_TESS_CONTROL_OUTPUT_VERTICES_EXT property.");
	}

	if ((glw::GLuint)gen_mode_value != test.expected_gen_mode_value)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported for GL_TESS_GEN_MODE_EXT property; "
	<< " expected: " << test.expected_gen_mode_value << ", retrieved: " << gen_mode_value
	<< tcu::TestLog::EndMessage;

	TCU_FAIL("Invalid value reported for GL_TESS_GEN_MODE_EXT property.");
	}

	if ((glw::GLuint)gen_spacing_value != test.expected_gen_spacing_value)
	{
	m_testCtx.getLog() << tcu::TestLog::Message
	<< "Invalid value reported for GL_TESS_GEN_SPACING_EXT property; "
	<< " expected: " << test.expected_gen_spacing_value
	<< ", retrieved: " << gen_spacing_value << tcu::TestLog::EndMessage;

	TCU_FAIL("Invalid value reported for GL_TESS_GEN_SPACING_EXT property.");
	}

	if ((glw::GLuint)gen_point_mode_value != test.expected_gen_point_mode_value)
	{
	m_testCtx.getLog() << tcu::TestLog::Message
	<< "Invalid value reported for GL_TESS_GEN_POINT_MODE_EXT property; "
	<< " expected: " << test.expected_gen_point_mode_value
	<< ", retrieved: " << gen_point_mode_value << tcu::TestLog::EndMessage;

	TCU_FAIL("Invalid value reported for GL_TESS_GEN_POINT_MODE_EXT property.");
	}

	if ((glw::GLuint)gen_vertex_order_value != test.expected_gen_vertex_order_value)
	{
	m_testCtx.getLog() << tcu::TestLog::Message
	<< "Invalid value reported for GL_TESS_GEN_VERTEX_ORDER_EXT property; "
	<< " expected: " << test.expected_gen_vertex_order_value
	<< ", retrieved: " << gen_vertex_order_value << tcu::TestLog::EndMessage;

	TCU_FAIL("Invalid value reported for GL_TESS_GEN_VERTEX_ORDER_EXT property.");
	}
	} /* for (all test descriptors) */

	/* All done */
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	return STOP;
	}

	} /* namespace glcts */