xref: /external/deqp/external/openglcts/modules/glesext/tessellation_shader/esextcTessellationShaderInvariance.cpp

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

namespace glcts
{

/* Defines a single vertex in tessellation space */
typedef struct _vertex
{
	float u;
	float v;
	float w;

	_vertex()
	{
		u = 0.0f;
		v = 0.0f;
		w = 0.0f;
	}
} _vertex;

/** Constructor
 *
 * @param context Test context
 **/
TessellationShaderInvarianceTests::TessellationShaderInvarianceTests(glcts::Context&	  context,
																	 const ExtParameters& extParams)
	: TestCaseGroupBase(context, extParams, "tessellation_invariance",
						"Verifies the implementation conforms to invariance rules.")
{
	/* No implementation needed */
}

/**
 * Initializes test groups for geometry shader tests
 **/
void TessellationShaderInvarianceTests::init(void)
{
	addChild(new glcts::TessellationShaderInvarianceRule1Test(m_context, m_extParams));
	addChild(new glcts::TessellationShaderInvarianceRule2Test(m_context, m_extParams));
	addChild(new glcts::TessellationShaderInvarianceRule3Test(m_context, m_extParams));
	addChild(new glcts::TessellationShaderInvarianceRule4Test(m_context, m_extParams));
	addChild(new glcts::TessellationShaderInvarianceRule5Test(m_context, m_extParams));
	addChild(new glcts::TessellationShaderInvarianceRule6Test(m_context, m_extParams));
	addChild(new glcts::TessellationShaderInvarianceRule7Test(m_context, m_extParams));
}

/** Constructor
 *
 * @param context     Test context
 * @param name        Test name
 * @param description Test description
 **/
TessellationShaderInvarianceBaseTest::TessellationShaderInvarianceBaseTest(Context&				context,
																		   const ExtParameters& extParams,
																		   const char* name, const char* description)
	: TestCaseBase(context, extParams, name, description)
	, m_utils_ptr(DE_NULL)
	, m_bo_id(0)
	, m_qo_tfpw_id(0)
	, m_vao_id(0)
{
	/* Left blank on purpose */
}

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

	if (!m_is_tessellation_shader_supported)
	{
		return;
	}

	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Revert buffer object bindings */
	gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* buffer */);
	gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* index */, 0 /* buffer */);

	/* Disable GL_RASTERIZER_DISCARD mode */
	gl.disable(GL_RASTERIZER_DISCARD);

	/* Reset GL_PATCH_VERTICES_EXT to default value */
	gl.patchParameteri(m_glExtTokens.PATCH_VERTICES, 3);

	/* Unbind vertex array object */
	gl.bindVertexArray(0);

	/* Deinitialize all ES objects that were created for test purposes */
	if (m_bo_id != 0)
	{
		gl.deleteBuffers(1, &m_bo_id);

		m_bo_id = 0;
	}

	for (_programs_iterator it = m_programs.begin(); it != m_programs.end(); ++it)
	{
		_test_program& program = *it;

		if (program.po_id != 0)
		{
			gl.deleteProgram(program.po_id);
		}
	}
	m_programs.clear();

	if (m_qo_tfpw_id != 0)
	{
		gl.deleteQueries(1, &m_qo_tfpw_id);

		m_qo_tfpw_id = 0;
	}

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

		m_vao_id = 0;
	}

	/* Deinitialize TS utils instance */
	if (m_utils_ptr != NULL)
	{
		delete m_utils_ptr;

		m_utils_ptr = NULL;
	}
}

/** Executes a single-counted GL_PATCHES_EXT draw call.
 *
 *  Throws TestError exception if an error occurs.
 *
 *  @param n_iteration Not used.
 *
 **/
void TessellationShaderInvarianceBaseTest::executeDrawCall(unsigned int n_iteration)
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	DE_UNREF(n_iteration);

	gl.drawArrays(m_glExtTokens.PATCHES, 0 /* first */, getDrawCallCountArgument());
	GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed");
}

/** Returns a value that should be used for the draw call's "count" argument.
 *
 *  @param Always 1
 **/
unsigned int TessellationShaderInvarianceBaseTest::getDrawCallCountArgument()
{
	return 1;
}

/** Returns source code for fragment shader stage which does
 *  not do anything.
 *
 *  @param n_iteration Not used.
 *
 *  @return Requested string.
 **/
std::string TessellationShaderInvarianceBaseTest::getFSCode(unsigned int n_iteration)
{
	DE_UNREF(n_iteration);

	std::string result = "${VERSION}\n"
						 "\n"
						 "void main()\n"
						 "{\n"
						 "}\n";

	return result;
}

/** Retrieves name of a vec2 uniform that stores inner tesselaton level information,
 *  later assigned to gl_TessLevelInner in tessellation evaluation shader.
 *
 *  @return Requested name.
 **/
const char* TessellationShaderInvarianceBaseTest::getInnerTessLevelUniformName()
{
	static const char* result = "inner_tess_level";

	return result;
}

/** Retrieves name of a vec4 uniform that stores outer tesselation level information,
 *  later assigned to gl_TessLevelOuter in tessellation evaluation shader.
 *
 *  @return Requested name.
 **/
const char* TessellationShaderInvarianceBaseTest::getOuterTessLevelUniformName()
{
	static const char* result = "outer_tess_level";

	return result;
}

/** Returns generic tessellation control shader code, which sends 4 output patch
 *  to tessellation evaluation shader stage and uses the very first input patch
 *  vertex only.
 *
 *  @return Tessellation control source code.
 */
std::string TessellationShaderInvarianceBaseTest::getTCCode(unsigned int n_iteration)
{
	DE_UNREF(n_iteration);

	/* In order to support all three primitive types, our generic tessellation
	 * control shader will pass 4 vertices to TE stage */
	return TessellationShaderUtils::getGenericTCCode(4, /* n_patch_vertices */
													 false);
}

/** Retrieves XFB properties for the test pass.
 *
 *  @param n_iteration Not used.
 *  @param out_n_names Deref will be used to store amount of strings @param *out_n_names
 *                     offers.
 *  @param out_names   Deref will be used to store pointer to an array of strings holding
 *                     names of varyings that should be captured via transform feedback.
 *                     Must not be NULL.
 *
 **/
void TessellationShaderInvarianceBaseTest::getXFBProperties(unsigned int n_iteration, unsigned int* out_n_names,
															const char*** out_names)
{
	static const char* names[] = { "result_uvw" };

	DE_UNREF(n_iteration);

	*out_n_names = 1;
	*out_names   = names;
}

/** Returns vertex shader source code. The shader sets gl_Position to
 *  vec4(1, 2, 3, 0).
 *
 *  @return Vertex shader source code.
 **/
std::string TessellationShaderInvarianceBaseTest::getVSCode(unsigned int n_iteration)
{
	DE_UNREF(n_iteration);

	std::string result = "${VERSION}\n"
						 "\n"
						 "void main()\n"
						 "{\n"
						 "    gl_Position = vec4(1.0, 2.0, 3.0, 0.0);\n"
						 "}\n";

	return result;
}

/** Initializes ES objects required to execute the test.
 *
 *  Throws TestError exception if an error occurs.
 *
 **/
void TessellationShaderInvarianceBaseTest::initTest()
{
	const glw::Functions& gl		   = m_context.getRenderContext().getFunctions();
	glw::GLuint			  shared_fs_id = 0;
	glw::GLuint			  shared_tc_id = 0;
	glw::GLuint			  shared_te_id = 0;
	glw::GLuint			  shared_vs_id = 0;

	gl.genVertexArrays(1, &m_vao_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not generate vertex array object");

	gl.bindVertexArray(m_vao_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Error binding vertex array object!");

	/* Initialize GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query object */
	gl.genQueries(1, &m_qo_tfpw_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenQueries() call failed");

	/* Initialize tessellation shader utils */
	m_utils_ptr = new TessellationShaderUtils(gl, this);

	/* Initialize a buffer object we will use to store XFB data.
	 * Note: we intentionally skip a glBufferData() call here,
	 *       the actual buffer storage size is iteration-specific.
	 **/
	gl.genBuffers(1, &m_bo_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed");

	gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_bo_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed");

	gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, /* index */
					  m_bo_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed");

	/* Iterate through all iterations */
	const unsigned int n_iterations = getAmountOfIterations();
	m_programs.reserve(n_iterations);

	const glw::GLenum SHADER_TYPE_FRAGMENT				  = GL_FRAGMENT_SHADER;
	const glw::GLenum SHADER_TYPE_TESSELLATION_CONTROL	= m_glExtTokens.TESS_CONTROL_SHADER;
	const glw::GLenum SHADER_TYPE_TESSELLATION_EVALUATION = m_glExtTokens.TESS_EVALUATION_SHADER;
	const glw::GLenum SHADER_TYPE_VERTEX				  = GL_VERTEX_SHADER;

	for (unsigned int n_iteration = 0; n_iteration < n_iterations; ++n_iteration)
	{
		_test_program program;

		/* Create an iteration-specific program object */
		program.po_id = gl.createProgram();

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

		/* Query the implementation on which shader types should be compiled on
		 * a per-iteration basis, and which can be initialized only once */
		static const glw::GLenum shader_types[] = { SHADER_TYPE_FRAGMENT, SHADER_TYPE_TESSELLATION_CONTROL,
													SHADER_TYPE_TESSELLATION_EVALUATION, SHADER_TYPE_VERTEX };
		static const unsigned int n_shader_types = sizeof(shader_types) / sizeof(shader_types[0]);

		for (unsigned int n_shader_type = 0; n_shader_type < n_shader_types; ++n_shader_type)
		{
			std::string shader_body;
			const char* shader_body_ptr = DE_NULL;
			glw::GLuint shader_id		= 0;
			glw::GLenum shader_type		= shader_types[n_shader_type];
			glw::GLenum shader_type_es  = (glw::GLenum)shader_type;

			// Check whether the test should use a separate program objects for each iteration.
			bool is_shader_iteration_specific = false;
			if (shader_type == SHADER_TYPE_TESSELLATION_EVALUATION)
			{
				is_shader_iteration_specific = true;
			}
			else if ((shader_type != SHADER_TYPE_FRAGMENT) && (shader_type != SHADER_TYPE_TESSELLATION_CONTROL) &&
					 (shader_type != SHADER_TYPE_VERTEX))
			{
				TCU_FAIL("Unrecognized shader type");
			}

			/* We need to initialize the shader object if:
			 *
			 * - its body differs between iterations;
			 * - its body is shared by all iterations AND this is the first iteration
			 */
			bool has_shader_been_generated = false;

			if ((!is_shader_iteration_specific && n_iteration == 0) || is_shader_iteration_specific)
			{
				/* Create the shader object */
				has_shader_been_generated = true;
				shader_id				  = gl.createShader(shader_type_es);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed");

				/* Assign shader body to the object */
				if (shader_type == SHADER_TYPE_FRAGMENT)
				{
					shader_body = getFSCode(n_iteration);
				}
				else if (shader_type == SHADER_TYPE_TESSELLATION_CONTROL)
				{
					shader_body = getTCCode(n_iteration);
				}
				else if (shader_type == SHADER_TYPE_TESSELLATION_EVALUATION)
				{
					shader_body = getTECode(n_iteration);
				}
				else if (shader_type == SHADER_TYPE_VERTEX)
				{
					shader_body = getVSCode(n_iteration);
				}
				else
				{
					TCU_FAIL("Unrecognized shader type");
				}

				shader_body_ptr = shader_body.c_str();

				shaderSourceSpecialized(shader_id, 1, &shader_body_ptr);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed");

				/* Compile the shader object */
				m_utils_ptr->compileShaders(1,				   /* n_shaders */
											&shader_id, true); /* should_succeed */

				/* If this is a shader object that will be shared by all iterations, cache it
				 * in a dedicated variable */
				if (!is_shader_iteration_specific)
				{
					if (shader_type == SHADER_TYPE_FRAGMENT)
					{
						shared_fs_id = shader_id;
					}
					else if (shader_type == SHADER_TYPE_TESSELLATION_CONTROL)
					{
						shared_tc_id = shader_id;
					}
					else if (shader_type == SHADER_TYPE_TESSELLATION_EVALUATION)
					{
						shared_te_id = shader_id;
					}
					else if (shader_type == SHADER_TYPE_VERTEX)
					{
						shared_vs_id = shader_id;
					}
					else
					{
						TCU_FAIL("Unrecognized shader type");
					}
				} /* if (!is_shader_iteration_specific) */
			}	 /* if (shader object needs to be initialized) */
			else
			{
				shader_id = (shader_type == SHADER_TYPE_FRAGMENT) ?
								shared_fs_id :
								(shader_type == SHADER_TYPE_TESSELLATION_CONTROL) ?
								shared_tc_id :
								(shader_type == SHADER_TYPE_TESSELLATION_EVALUATION) ? shared_te_id : shared_vs_id;
			}

			/* Attach the shader object to iteration-specific program object */
			gl.attachShader(program.po_id, shader_id);

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

			/* Now that the object has been attached, we can flag it for deletion */
			if (has_shader_been_generated)
			{
				gl.deleteShader(shader_id);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteShader() call failed");
			}
		} /* for (all shader types) */

		/* Set up transform feed-back */
		unsigned int n_xfb_names = 0;
		const char** xfb_names   = NULL;

		getXFBProperties(n_iteration, &n_xfb_names, &xfb_names);

		gl.transformFeedbackVaryings(program.po_id, n_xfb_names, xfb_names, GL_INTERLEAVED_ATTRIBS);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() call failed.");

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

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

		gl.getProgramiv(program.po_id, GL_LINK_STATUS, &link_status);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed");

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

		/* Retrieve inner/outer tess level uniform locations */
		program.inner_tess_level_uniform_location =
			gl.getUniformLocation(program.po_id, getInnerTessLevelUniformName());
		program.outer_tess_level_uniform_location =
			gl.getUniformLocation(program.po_id, getOuterTessLevelUniformName());

		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation() call(s) failed");

		/* Store the program object */
		m_programs.push_back(program);
	} /* for (all iterations) */
}

/** 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 TessellationShaderInvarianceBaseTest::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);
	}

	/* Initialize all objects needed to run the test */
	initTest();

	/* Do a general set-up */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.enable(GL_RASTERIZER_DISCARD);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable(GL_RASTERIZER_DISCARD) failed.");

	gl.patchParameteri(m_glExtTokens.PATCH_VERTICES, 1);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glPatchParameteriEXT() failed for GL_PATCH_VERTICES_EXT pname");

	/* There are two types of verification supported by this base test implementation:
	 *
	 * - iteration-specific (verifyResultDataForIteration() )
	 * - global             (verifyResultData() )
	 *
	 * It is up to test implementation to decide which of the two (or perhaps both)
	 * entry-points it should overload and use for validating the result data.
	 */
	const unsigned int n_iterations   = getAmountOfIterations();
	char**			   iteration_data = new char*[n_iterations];

	/* Execute the test */
	for (unsigned int n_iteration = 0; n_iteration < n_iterations; ++n_iteration)
	{
		_test_program& program = m_programs[n_iteration];

		/* Retrieve iteration properties for current iteration */
		unsigned int						 bo_size			  = 0;
		float								 inner_tess_levels[2] = { 0 };
		bool								 is_point_mode		  = false;
		float								 outer_tess_levels[4] = { 0 };
		_tessellation_primitive_mode		 primitive_mode		  = TESSELLATION_SHADER_PRIMITIVE_MODE_UNKNOWN;
		_tessellation_shader_vertex_ordering vertex_ordering	  = TESSELLATION_SHADER_VERTEX_ORDERING_UNKNOWN;

		getIterationProperties(n_iteration, inner_tess_levels, outer_tess_levels, &is_point_mode, &primitive_mode,
							   &vertex_ordering, &bo_size);

		DE_ASSERT(bo_size != 0);

		/* Activate iteration-specific program */
		gl.useProgram(program.po_id);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed.");

		/* Set up buffer object storage */
		{
			char* zero_bo_data = new char[bo_size];

			memset(zero_bo_data, 0, bo_size);

			gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, bo_size, zero_bo_data, GL_STATIC_DRAW);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed");

			delete[] zero_bo_data;
			zero_bo_data = NULL;
		}

		/* Allocate space for iteration-specific data */
		iteration_data[n_iteration] = new char[bo_size];

		/* Configure inner/outer tessellation levels as requested for the iteration */
		gl.uniform2fv(program.inner_tess_level_uniform_location, 1, /* count */
					  inner_tess_levels);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform2fv() call failed");

		gl.uniform4fv(program.outer_tess_level_uniform_location, 1, /* count */
					  outer_tess_levels);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform4fv() call failed");

		/* Launch the TFPW query */
		gl.beginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, m_qo_tfpw_id);
		GLU_EXPECT_NO_ERROR(gl.getError(),
							"glBeginQuery() for GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN target failed.");

		/* Prepare for TF */
		glw::GLenum tf_mode = TessellationShaderUtils::getTFModeForPrimitiveMode(primitive_mode, is_point_mode);

		gl.beginTransformFeedback(tf_mode);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed");
		{
			/* Execute the draw call */
			executeDrawCall(n_iteration);

			GLU_EXPECT_NO_ERROR(gl.getError(), "Draw call failed");
		}
		gl.endTransformFeedback();
		GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed");

		gl.endQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN) call failed");

		/* Make sure that we had sufficient amount of space in a buffer object we used to
		 * capture XFB data.
		 **/
		glw::GLuint n_tf_primitives_written = 0;
		glw::GLuint used_tf_bo_size			= 0;

		gl.getQueryObjectuiv(m_qo_tfpw_id, GL_QUERY_RESULT, &n_tf_primitives_written);
		GLU_EXPECT_NO_ERROR(gl.getError(),
							"Could not retrieve GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query object result");

		if (is_point_mode)
		{
			used_tf_bo_size = static_cast<glw::GLuint>(n_tf_primitives_written * sizeof(float) * 3 /* components */);
		}
		else if (primitive_mode == TESSELLATION_SHADER_PRIMITIVE_MODE_ISOLINES)
		{
			used_tf_bo_size = static_cast<glw::GLuint>(n_tf_primitives_written * sizeof(float) * 2 /* vertices */ *
													   3 /* components */);
		}
		else
		{
			used_tf_bo_size = static_cast<glw::GLuint>(n_tf_primitives_written * sizeof(float) * 3 /* vertices */ *
													   3 /* components */);
		}

		if (used_tf_bo_size != bo_size)
		{
			m_testCtx.getLog() << tcu::TestLog::Message << "Expected " << bo_size
							   << " to be filled with tessellation data, "
								  "only "
							   << used_tf_bo_size << "was used." << tcu::TestLog::EndMessage;

			TCU_FAIL("Amount of primitives generated during TF does not match amount of primitives that were expected"
					 " to be generated by the tessellator");
		}

		/* Map the buffer object we earlier bound to GL_TRANSFORM_FEEDBACK_BUFFER
		 * target into process space. */
		const void* xfb_data = gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, /* offset */
												 bo_size, GL_MAP_READ_BIT);

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

		memcpy(iteration_data[n_iteration], xfb_data, bo_size);

		/* Unmap the buffer object */
		gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed");

		/* Ask the test implementation to verify the results */
		verifyResultDataForIteration(n_iteration, iteration_data[n_iteration]);
	} /* for (all iterations) */

	/* Now that we've executed all iterations, we can call a global verification
	 * entry-point */
	verifyResultData((const void**)iteration_data);

	/* At this point we're safe to release space allocated for data coming from
	 * all the iterations */
	for (unsigned int n_iteration = 0; n_iteration < n_iterations; ++n_iteration)
	{
		char* iter_data = (char*)iteration_data[n_iteration];
		delete[] iter_data;

		iteration_data[n_iteration] = DE_NULL;
	} /* for (all iterations) */

	delete[] iteration_data;
	iteration_data = DE_NULL;

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

/* Does nothing (stub implementation)
 *
 * @param n_iteration Not used.
 * @param data        Not used.
 *
 **/
void TessellationShaderInvarianceBaseTest::verifyResultDataForIteration(unsigned int n_iteration, const void* data)
{
	DE_UNREF(n_iteration && data);

	/* Do nothing - this is just a stub. */
}

/* Does nothing (stub implementation)
 *
 * @param all_iterations_data Not used.
 *
 **/
void TessellationShaderInvarianceBaseTest::verifyResultData(const void** all_iterations_data)
{
	DE_UNREF(all_iterations_data);

	/* Do nothing - this is just a stub. */
}

/** Constructor.
 *
 *  @param context Rendering context.
 *
 **/
TessellationShaderInvarianceRule1Test::TessellationShaderInvarianceRule1Test(Context&			  context,
																			 const ExtParameters& extParams)
	: TessellationShaderInvarianceBaseTest(context, extParams, "invariance_rule1",
										   "Verifies conformance with first invariance rule")
{
	/* Left blank intentionally */
}

/** Destructor. */
TessellationShaderInvarianceRule1Test::~TessellationShaderInvarianceRule1Test()
{
	/* Left blank intentionally */
}

/** Retrieves amount of iterations the base test implementation should run before
 *  calling global verification routine.
 *
 *  @return Always 6.
 **/
unsigned int TessellationShaderInvarianceRule1Test::getAmountOfIterations()
{
	return 6;
}

/** Returns a value that should be used for the draw call's "count" argument.
 *
 *  @param Always 3
 **/
unsigned int TessellationShaderInvarianceRule1Test::getDrawCallCountArgument()
{
	return 3;
}

/** Retrieves iteration-specific tessellation properties.
 *
 *  @param n_iteration            Iteration index to retrieve the properties for.
 *  @param out_inner_tess_levels  Deref will be used to store iteration-specific inner
 *                                tessellation level values. Must not be NULL.
 *  @param out_outer_tess_levels  Deref will be used to store iteration-specific outer
 *                                tessellation level values. Must not be NULL.
 *  @param out_point_mode         Deref will be used to store iteration-specific flag
 *                                telling whether point mode should be enabled for given pass.
 *                                Must not be NULL.
 *  @param out_primitive_mode     Deref will be used to store iteration-specific primitive
 *                                mode. Must not be NULL.
 *  @param out_vertex_ordering    Deref will be used to store iteration-specific vertex ordering.
 *                                Must not be NULL.
 *  @param out_result_buffer_size Deref will be used to store amount of bytes XFB buffer object
 *                                storage should offer for the draw call to succeed. Must not
 *                                be NULL.
 **/
void TessellationShaderInvarianceRule1Test::getIterationProperties(
	unsigned int n_iteration, float* out_inner_tess_levels, float* out_outer_tess_levels, bool* out_point_mode,
	_tessellation_primitive_mode* out_primitive_mode, _tessellation_shader_vertex_ordering* out_vertex_ordering,
	unsigned int* out_result_buffer_size)
{
	*out_vertex_ordering = TESSELLATION_SHADER_VERTEX_ORDERING_CCW;

	switch (n_iteration)
	{
	case 0:
	case 5:
	{
		/* Triangles (point mode) */
		out_inner_tess_levels[0] = 1.0f;
		out_outer_tess_levels[0] = 1.0f;
		out_outer_tess_levels[1] = 1.0f;
		out_outer_tess_levels[2] = 1.0f;

		*out_point_mode		= true;
		*out_primitive_mode = TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES;

		break;
	}

	case 1:
	case 3:
	{
		/* Lines */
		out_outer_tess_levels[0] = 1.0f;
		out_outer_tess_levels[1] = 1.0f;

		*out_point_mode		= false;
		*out_primitive_mode = TESSELLATION_SHADER_PRIMITIVE_MODE_ISOLINES;

		break;
	}

	case 2:
	case 4:
	{
		/* Triangles */
		out_inner_tess_levels[0] = 1.0f;
		out_outer_tess_levels[0] = 1.0f;
		out_outer_tess_levels[1] = 1.0f;
		out_outer_tess_levels[2] = 1.0f;

		*out_point_mode		= false;
		*out_primitive_mode = TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES;

		break;
	}

	default:
	{
		TCU_FAIL("Unrecognzied iteration index");
	}
	}

	*out_result_buffer_size = m_utils_ptr->getAmountOfVerticesGeneratedByTessellator(
		*out_primitive_mode, out_inner_tess_levels, out_outer_tess_levels, TESSELLATION_SHADER_VERTEX_SPACING_EQUAL,
		*out_point_mode);

	*out_result_buffer_size = static_cast<unsigned int>(*out_result_buffer_size * getDrawCallCountArgument() *
														3 /* components */ * sizeof(float));

	DE_ASSERT(*out_result_buffer_size != 0);
}

/** Retrieves iteration-specific tessellation evaluation shader code.
 *
 *  @param n_iteration Iteration index, for which the source code is being obtained.
 *
 *  @return Requested source code.
 **/
std::string TessellationShaderInvarianceRule1Test::getTECode(unsigned int n_iteration)
{
	unsigned int						 bo_size			  = 0;
	float								 inner_tess_levels[2] = { 0 };
	float								 outer_tess_levels[4] = { 0 };
	bool								 point_mode			  = false;
	_tessellation_primitive_mode		 primitive_mode		  = TESSELLATION_SHADER_PRIMITIVE_MODE_UNKNOWN;
	_tessellation_shader_vertex_ordering vertex_ordering	  = TESSELLATION_SHADER_VERTEX_ORDERING_UNKNOWN;

	getIterationProperties(n_iteration, inner_tess_levels, outer_tess_levels, &point_mode, &primitive_mode,
						   &vertex_ordering, &bo_size);

	return TessellationShaderUtils::getGenericTECode(TESSELLATION_SHADER_VERTEX_SPACING_EQUAL, primitive_mode,
													 vertex_ordering, point_mode);
}

/** Verifies result data. Accesses data generated by all iterations.
 *
 *  Throws TestError exception if an error occurs.
 *
 *  @param all_iterations_data An array of pointers to buffers, holding gl_TessCoord
 *                             data generated by subsequent iterations.
 **/
void TessellationShaderInvarianceRule1Test::verifyResultData(const void** all_iterations_data)
{
	const float* lines_vertex_data_1 = (const float*)all_iterations_data[1];
	const float* lines_vertex_data_2 = (const float*)all_iterations_data[3];
	const float* point_vertex_data_1 = (const float*)all_iterations_data[0];
	const float* point_vertex_data_2 = (const float*)all_iterations_data[5];
	const float* tris_vertex_data_1  = (const float*)all_iterations_data[2];
	const float* tris_vertex_data_2  = (const float*)all_iterations_data[4];

	const unsigned int n_line_vertices  = 2 /* vertices per line segment */ * getDrawCallCountArgument(); /* lines */
	const unsigned int n_point_vertices = 1 /* vertices per point */ * getDrawCallCountArgument();		  /* points */
	const unsigned int n_tri_vertices   = 3 /* vertices per triangle */ * getDrawCallCountArgument(); /* triangles */
	const unsigned int vertex_size		= sizeof(float) * 3;										  /* components */

	/* Make sure the data sets match, given different draw call ordering */
	for (int n_type = 0; n_type < 3 /* lines, points, tris */; ++n_type)
	{
		const float* data1_ptr = DE_NULL;
		const float* data2_ptr = DE_NULL;
		std::string  data_type_string;
		unsigned int n_vertices = 0;

		switch (n_type)
		{
		case 0:
		{
			data1_ptr		 = lines_vertex_data_1;
			data2_ptr		 = lines_vertex_data_2;
			data_type_string = "Line";
			n_vertices		 = n_line_vertices;

			break;
		}

		case 1:
		{
			data1_ptr		 = point_vertex_data_1;
			data2_ptr		 = point_vertex_data_2;
			data_type_string = "Point";
			n_vertices		 = n_point_vertices;

			break;
		}

		case 2:
		{
			data1_ptr		 = tris_vertex_data_1;
			data2_ptr		 = tris_vertex_data_2;
			data_type_string = "Triangle";
			n_vertices		 = n_tri_vertices;

			break;
		}

		default:
		{
			TCU_FAIL("Internal error: type index was not recognized");
		}
		} /* switch (n_type) */

		/* Make sure the buffer storage in both cases has been modified */
		{
			unsigned int zero_bo_size = vertex_size * n_vertices;
			char*		 zero_bo_data = new char[vertex_size * n_vertices];

			memset(zero_bo_data, 0, zero_bo_size);

			if (memcmp(data1_ptr, zero_bo_data, zero_bo_size) == 0 ||
				memcmp(data2_ptr, zero_bo_data, zero_bo_size) == 0)
			{
				TCU_FAIL("One of the draw calls has not outputted any data to XFB buffer object storage");
			}

			delete[] zero_bo_data;
			zero_bo_data = NULL;
		}

		/* Compare the data */
		if (memcmp(data1_ptr, data2_ptr, vertex_size * n_vertices) != 0)
		{
			std::stringstream logMessage;

			logMessage << data_type_string << " data rendered in pass 1: (";

			for (unsigned int n_vertex = 0; n_vertex < n_vertices; ++n_vertex)
			{
				logMessage << data1_ptr[n_vertex];

				if (n_vertex != (n_vertices - 1))
				{
					logMessage << ", ";
				}
				else
				{
					logMessage << ") ";
				}
			} /* for (all vertices) */

			logMessage << "and in pass 2: (";

			for (unsigned int n_vertex = 0; n_vertex < n_vertices; ++n_vertex)
			{
				logMessage << data2_ptr[n_vertex];

				if (n_vertex != (n_vertices - 1))
				{
					logMessage << ", ";
				}
				else
				{
					logMessage << ") ";
				}
			} /* for (all vertices) */

			logMessage << "do not match";

			m_testCtx.getLog() << tcu::TestLog::Message << logMessage.str().c_str() << tcu::TestLog::EndMessage;

			TCU_FAIL("Data mismatch");
		} /* if (data mismatch) */
	}	 /* for (all primitive types) */
}

/** Constructor.
 *
 *  @param context Rendering context.
 *
 **/
TessellationShaderInvarianceRule2Test::TessellationShaderInvarianceRule2Test(Context&			  context,
																			 const ExtParameters& extParams)
	: TessellationShaderInvarianceBaseTest(context, extParams, "invariance_rule2",
										   "Verifies conformance with second invariance rule")
{
	memset(m_n_tessellated_vertices, 0, sizeof(m_n_tessellated_vertices));
}

/** Destructor. */
TessellationShaderInvarianceRule2Test::~TessellationShaderInvarianceRule2Test()
{
	/* Left blank intentionally */
}

/** Retrieves amount of iterations the base test implementation should run before
 *  calling global verification routine.
 *
 *  @return Always 4.
 **/
unsigned int TessellationShaderInvarianceRule2Test::getAmountOfIterations()
{
	return 4;
}

/** Retrieves iteration-specific tessellation properties.
 *
 *  @param n_iteration            Iteration index to retrieve the properties for.
 *  @param out_inner_tess_levels  Deref will be used to store iteration-specific inner
 *                                tessellation level values. Must not be NULL.
 *  @param out_outer_tess_levels  Deref will be used to store iteration-specific outer
 *                                tessellation level values. Must not be NULL.
 *  @param out_point_mode         Deref will be used to store iteration-specific flag
 *                                telling whether point mode should be enabled for given pass.
 *                                Must not be NULL.
 *  @param out_primitive_mode     Deref will be used to store iteration-specific primitive
 *                                mode. Must not be NULL.
 *  @param out_vertex_ordering    Deref will be used to store iteration-specific vertex
 *                                ordering. Must not be NULL.
 *  @param out_result_buffer_size Deref will be used to store amount of bytes XFB buffer object
 *                                storage should offer for the draw call to succeed. Can
 *                                be NULL.
 **/
void TessellationShaderInvarianceRule2Test::getIterationProperties(
	unsigned int n_iteration, float* out_inner_tess_levels, float* out_outer_tess_levels, bool* out_point_mode,
	_tessellation_primitive_mode* out_primitive_mode, _tessellation_shader_vertex_ordering* out_vertex_ordering,
	unsigned int* out_result_buffer_size)
{
	*out_vertex_ordering = TESSELLATION_SHADER_VERTEX_ORDERING_CCW;

	switch (n_iteration)
	{
	case 0:
	case 1:
	{
		/* Triangles */
		out_outer_tess_levels[0] = 2.0f;
		out_outer_tess_levels[1] = 3.0f;
		out_outer_tess_levels[2] = 4.0f;

		if (n_iteration == 0)
		{
			out_inner_tess_levels[0] = 4.0f;
			out_inner_tess_levels[1] = 5.0f;
		}
		else
		{
			out_inner_tess_levels[0] = 3.0f;
			out_inner_tess_levels[1] = 4.0f;
		}

		*out_point_mode		= false;
		*out_primitive_mode = TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES;

		break;
	}

	case 2:
	case 3:
	{
		/* Quads */
		out_outer_tess_levels[0] = 2.0f;
		out_outer_tess_levels[1] = 3.0f;
		out_outer_tess_levels[2] = 4.0f;
		out_outer_tess_levels[3] = 5.0f;

		if (n_iteration == 2)
		{
			out_inner_tess_levels[0] = 2.0f;
			out_inner_tess_levels[1] = 3.0f;
		}
		else
		{
			out_inner_tess_levels[0] = 4.0f;
			out_inner_tess_levels[1] = 5.0f;
		}

		*out_point_mode		= false;
		*out_primitive_mode = TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS;

		break;
	}

	default:
	{
		TCU_FAIL("Unrecognized iteration index");
	}
	}

	if (out_result_buffer_size != DE_NULL)
	{
		*out_result_buffer_size = m_utils_ptr->getAmountOfVerticesGeneratedByTessellator(
			*out_primitive_mode, out_inner_tess_levels, out_outer_tess_levels, TESSELLATION_SHADER_VERTEX_SPACING_EQUAL,
			*out_point_mode);

		m_n_tessellated_vertices[n_iteration] = *out_result_buffer_size;
		*out_result_buffer_size =
			static_cast<unsigned int>(*out_result_buffer_size * 3 /* components */ * sizeof(float));

		DE_ASSERT(*out_result_buffer_size != 0);
	}
}

/** Retrieves iteration-specific tessellation evaluation shader code.
 *
 *  @param n_iteration Iteration index, for which the source code is being obtained.
 *
 *  @return Requested source code.
 **/
std::string TessellationShaderInvarianceRule2Test::getTECode(unsigned int n_iteration)
{
	unsigned int						 bo_size			  = 0;
	float								 inner_tess_levels[2] = { 0 };
	float								 outer_tess_levels[4] = { 0 };
	bool								 point_mode			  = false;
	_tessellation_primitive_mode		 primitive_mode		  = TESSELLATION_SHADER_PRIMITIVE_MODE_UNKNOWN;
	_tessellation_shader_vertex_ordering vertex_ordering	  = TESSELLATION_SHADER_VERTEX_ORDERING_UNKNOWN;

	getIterationProperties(n_iteration, inner_tess_levels, outer_tess_levels, &point_mode, &primitive_mode,
						   &vertex_ordering, &bo_size);

	return TessellationShaderUtils::getGenericTECode(TESSELLATION_SHADER_VERTEX_SPACING_EQUAL, primitive_mode,
													 vertex_ordering, point_mode);
}

/** Verifies result data. Accesses data generated by all iterations.
 *
 *  Throws TestError exception if an error occurs.
 *
 *  @param all_iterations_data An array of pointers to buffers, holding gl_TessCoord
 *                             data generated by subsequent iterations.
 **/
void TessellationShaderInvarianceRule2Test::verifyResultData(const void** all_iterations_data)
{
	/* Iterate through one tessellated set of vertices for a given primitive type
	 * and identify outer vertices. Make sure exactly the same vertices can be
	 * found in the other set of vertices, generated with different input tessellation
	 * level.
	 */
	for (int n_primitive_type = 0; n_primitive_type < 2; /* triangles / quads */
		 ++n_primitive_type)
	{
		const float*				 data1_ptr		= (const float*)all_iterations_data[n_primitive_type * 2 + 0];
		const float*				 data2_ptr		= (const float*)all_iterations_data[n_primitive_type * 2 + 1];
		_tessellation_primitive_mode primitive_mode = (n_primitive_type == 0) ?
														  TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES :
														  TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS;
		std::vector<_vertex> outer_vertices;

		/* Iterate through all data1 vertices.. */
		for (unsigned int n_vertex = 0; n_vertex < m_n_tessellated_vertices[n_primitive_type * 2]; ++n_vertex)
		{
			/* Check if any of the components is equal to 0 or 1. If so, this could
			 * be an edge vertex.
			 */
			const float* vertex_ptr = data1_ptr + n_vertex * 3; /* components */

			if (TessellationShaderUtils::isOuterEdgeVertex(primitive_mode, vertex_ptr))
			{
				/* Only add the vertex if it has not been added already to the vector */
				bool has_already_been_added = false;

				for (std::vector<_vertex>::const_iterator vertex_iterator = outer_vertices.begin();
					 vertex_iterator != outer_vertices.end(); vertex_iterator++)
				{
					if (vertex_iterator->u == vertex_ptr[0] && vertex_iterator->v == vertex_ptr[1] &&
						vertex_iterator->w == vertex_ptr[2])
					{
						has_already_been_added = true;

						break;
					}
				} /* for (all outer vertices stored so far) */

				if (!has_already_been_added)
				{
					_vertex vertex;

					vertex.u = vertex_ptr[0];
					vertex.v = vertex_ptr[1];
					vertex.w = vertex_ptr[2];

					outer_vertices.push_back(vertex);
				}
			} /* if (input vertex is located on outer edge) */
		}	 /* for (all input vertices) */

		DE_ASSERT(outer_vertices.size() != 0);

		/* Now that we know where outer vertices are, make sure they are present in the other data set */
		for (std::vector<_vertex>::const_iterator ref_vertex_iterator = outer_vertices.begin();
			 ref_vertex_iterator != outer_vertices.end(); ref_vertex_iterator++)
		{
			bool		   has_been_found = false;
			const _vertex& ref_vertex	 = *ref_vertex_iterator;

			for (unsigned int n_vertex = 0; n_vertex < m_n_tessellated_vertices[n_primitive_type * 2 + 1]; ++n_vertex)
			{
				const float* vertex_ptr = data2_ptr + n_vertex * 3; /* components */

				if (vertex_ptr[0] == ref_vertex.u && vertex_ptr[1] == ref_vertex.v && vertex_ptr[2] == ref_vertex.w)
				{
					has_been_found = true;

					break;
				}
			} /* for (all vertices in the other data set) */

			if (!has_been_found)
			{
				float								 cmp_inner_tess_levels[2];
				float								 cmp_outer_tess_levels[4];
				bool								 cmp_point_mode;
				_tessellation_primitive_mode		 cmp_primitive_mode;
				_tessellation_shader_vertex_ordering cmp_vertex_ordering;
				std::string							 primitive_type = (n_primitive_type == 0) ? "triangles" : "quads";
				float								 ref_inner_tess_levels[2];
				float								 ref_outer_tess_levels[4];
				bool								 ref_point_mode;
				_tessellation_primitive_mode		 ref_primitive_mode;
				_tessellation_shader_vertex_ordering ref_vertex_ordering;

				getIterationProperties(n_primitive_type * 2, ref_inner_tess_levels, ref_outer_tess_levels,
									   &ref_point_mode, &ref_primitive_mode, &ref_vertex_ordering, NULL);
				getIterationProperties(n_primitive_type * 2 + 1, cmp_inner_tess_levels, cmp_outer_tess_levels,
									   &cmp_point_mode, &cmp_primitive_mode, &cmp_vertex_ordering, NULL);

				m_testCtx.getLog() << tcu::TestLog::Message << "Outer vertex"
								   << " (" << ref_vertex.u << ", " << ref_vertex.v << ", " << ref_vertex.w << ")"
								   << " was not found in tessellated data coordinate set generated"
								   << " for primitive type: " << primitive_type.c_str()
								   << ". Reference inner tessellation level:"
								   << " (" << ref_inner_tess_levels[0] << ", " << ref_inner_tess_levels[1]
								   << "), reference outer tessellation level:"
								   << " (" << ref_outer_tess_levels[0] << ", " << ref_outer_tess_levels[1] << ", "
								   << ref_outer_tess_levels[2] << ", " << ref_outer_tess_levels[3]
								   << "), test inner tessellation level:"
								   << " (" << cmp_inner_tess_levels[0] << ", " << cmp_inner_tess_levels[1]
								   << "), reference outer tessellation level:"
								   << " (" << cmp_outer_tess_levels[0] << ", " << cmp_outer_tess_levels[1] << ", "
								   << cmp_outer_tess_levels[2] << ", " << cmp_outer_tess_levels[3] << ")."
								   << tcu::TestLog::EndMessage;

				TCU_FAIL("Outer edge vertex was not found in tessellated coordinate set generated for "
						 "the same outer tessellation levels and vertex spacing, but different inner "
						 "tessellation levels");
			} /* if (outer edge vertex was not found in the other set) */
		}	 /* for (all outer edge vertices) */
	}		  /* for (both primitive types) */
}

/** Constructor.
 *
 *  @param context Rendering context.
 *
 **/
TessellationShaderInvarianceRule3Test::TessellationShaderInvarianceRule3Test(Context&			  context,
																			 const ExtParameters& extParams)
	: TessellationShaderInvarianceBaseTest(context, extParams, "invariance_rule3",
										   "Verifies conformance with third invariance rule")
{
}

/** Destructor. */
TessellationShaderInvarianceRule3Test::~TessellationShaderInvarianceRule3Test()
{
	/* Left blank intentionally */
}

/** Retrieves amount of iterations the base test implementation should run before
 *  calling global verification routine.
 *
 *  @return A value that depends on initTestIterations() behavior.
 **/
unsigned int TessellationShaderInvarianceRule3Test::getAmountOfIterations()
{
	if (m_test_iterations.size() == 0)
	{
		initTestIterations();
	}

	return (unsigned int)m_test_iterations.size();
}

/** Retrieves iteration-specific tessellation properties.
 *
 *  @param n_iteration            Iteration index to retrieve the properties for.
 *  @param out_inner_tess_levels  Deref will be used to store iteration-specific inner
 *                                tessellation level values. Must not be NULL.
 *  @param out_outer_tess_levels  Deref will be used to store iteration-specific outer
 *                                tessellation level values. Must not be NULL.
 *  @param out_point_mode         Deref will be used to store iteration-specific flag
 *                                telling whether point mode should be enabled for given pass.
 *                                Must not be NULL.
 *  @param out_primitive_mode     Deref will be used to store iteration-specific primitive
 *                                mode. Must not be NULL.
 *  @param out_vertex_ordering    Deref will be used to store iteration-specific vertex
 *                                ordering. Must not be NULL.
 *  @param out_result_buffer_size Deref will be used to store amount of bytes XFB buffer object
 *                                storage should offer for the draw call to succeed. Can
 *                                be NULL.
 **/
void TessellationShaderInvarianceRule3Test::getIterationProperties(
	unsigned int n_iteration, float* out_inner_tess_levels, float* out_outer_tess_levels, bool* out_point_mode,
	_tessellation_primitive_mode* out_primitive_mode, _tessellation_shader_vertex_ordering* out_vertex_ordering,
	unsigned int* out_result_buffer_size)
{
	DE_ASSERT(m_test_iterations.size() > n_iteration);

	_test_iteration& test_iteration = m_test_iterations[n_iteration];

	memcpy(out_inner_tess_levels, test_iteration.inner_tess_levels, sizeof(test_iteration.inner_tess_levels));
	memcpy(out_outer_tess_levels, test_iteration.outer_tess_levels, sizeof(test_iteration.outer_tess_levels));

	*out_point_mode		 = false;
	*out_primitive_mode  = test_iteration.primitive_mode;
	*out_vertex_ordering = TESSELLATION_SHADER_VERTEX_ORDERING_CCW;

	if (out_result_buffer_size != DE_NULL)
	{
		*out_result_buffer_size = m_utils_ptr->getAmountOfVerticesGeneratedByTessellator(
			*out_primitive_mode, out_inner_tess_levels, out_outer_tess_levels, test_iteration.vertex_spacing,
			*out_point_mode);
		test_iteration.n_vertices = *out_result_buffer_size;
		*out_result_buffer_size =
			static_cast<unsigned int>(*out_result_buffer_size * 3 /* components */ * sizeof(float));

		DE_ASSERT(*out_result_buffer_size != 0);
	}
}

/** Retrieves iteration-specific tessellation evaluation shader code.
 *
 *  @param n_iteration Iteration index, for which the source code is being obtained.
 *
 *  @return Requested source code.
 **/
std::string TessellationShaderInvarianceRule3Test::getTECode(unsigned int n_iteration)
{
	DE_ASSERT(m_test_iterations.size() > n_iteration);

	const _test_iteration& test_iteration = m_test_iterations[n_iteration];

	return TessellationShaderUtils::getGenericTECode(test_iteration.vertex_spacing, test_iteration.primitive_mode,
													 TESSELLATION_SHADER_VERTEX_ORDERING_CCW, false); /* point mode */
}

/** Initializes test iterations for the test. The following modes and inner/outer tess level
 *  configurations are used to form the test set:
 *
 *  - Inner/outer tessellation level combinations as returned by
 *    TessellationShaderUtils::getTessellationLevelSetForPrimitiveMode()
 *  - All primitive modes;
 *  - All vertex spacing modes;
 *
 *  All permutations are used to generate the test set.
 **/
void TessellationShaderInvarianceRule3Test::initTestIterations()
{
	DE_ASSERT(m_test_iterations.size() == 0);

	/* Retrieve GL_MAX_TESS_GEN_LEVEL_EXT value */
	const glw::Functions& gl						  = m_context.getRenderContext().getFunctions();
	glw::GLint			  gl_max_tess_gen_level_value = 0;

	gl.getIntegerv(m_glExtTokens.MAX_TESS_GEN_LEVEL, &gl_max_tess_gen_level_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_TESS_GEN_LEVEL_EXT pname");

	/* Iterate through all primitive and vertex spacing modes */
	_tessellation_primitive_mode primitive_modes[] = { TESSELLATION_SHADER_PRIMITIVE_MODE_ISOLINES,
													   TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS,
													   TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES };
	_tessellation_shader_vertex_spacing vs_modes[] = { TESSELLATION_SHADER_VERTEX_SPACING_EQUAL,
													   TESSELLATION_SHADER_VERTEX_SPACING_FRACTIONAL_EVEN,
													   TESSELLATION_SHADER_VERTEX_SPACING_FRACTIONAL_ODD };

	const unsigned int n_primitive_modes = sizeof(primitive_modes) / sizeof(primitive_modes[0]);
	const unsigned int n_vs_modes		 = sizeof(vs_modes) / sizeof(vs_modes[0]);

	for (unsigned int n_primitive_mode = 0; n_primitive_mode < n_primitive_modes; ++n_primitive_mode)
	{
		_tessellation_primitive_mode primitive_mode = primitive_modes[n_primitive_mode];

		for (unsigned int n_vs_mode = 0; n_vs_mode < n_vs_modes; ++n_vs_mode)
		{
			_tessellation_shader_vertex_spacing vs_mode = vs_modes[n_vs_mode];

			/* Retrieve inner/outer tessellation level combinations we want the tests to be run for */
			_tessellation_levels_set levels_set;

			levels_set = TessellationShaderUtils::getTessellationLevelSetForPrimitiveMode(
				primitive_mode, gl_max_tess_gen_level_value,
				TESSELLATION_LEVEL_SET_FILTER_ALL_LEVELS_USE_THE_SAME_VALUE);

			/* Iterate through all configurations */
			for (_tessellation_levels_set_const_iterator levels_iterator = levels_set.begin();
				 levels_iterator != levels_set.end(); levels_iterator++)
			{
				const _tessellation_levels& levels = *levels_iterator;

				/* Create a test descriptor for all the parameters we now have */
				_test_iteration test;

				memcpy(test.inner_tess_levels, levels.inner, sizeof(test.inner_tess_levels));
				memcpy(test.outer_tess_levels, levels.outer, sizeof(test.outer_tess_levels));

				test.primitive_mode = primitive_mode;
				test.vertex_spacing = vs_mode;

				m_test_iterations.push_back(test);
			} /* for (all inner/outer tessellation levels) */
		}	 /* for (all vertex spacing modes) */
	}		  /* for (all primitive modes) */
}

/** Verifies result data on per-iteration basis.
 *
 *  Throws TestError exception if an error occurs.
 *
 *  @param n_iteration Index of iteration the check should be performed for.
 *  @param data        Points to array of vec3s storing the vertices as
 *                     generated by tessellation
 **/
void TessellationShaderInvarianceRule3Test::verifyResultDataForIteration(unsigned int n_iteration, const void* data)
{
	DE_ASSERT(m_test_iterations.size() > n_iteration);

	const glw::GLfloat*	data_float	 = (const glw::GLfloat*)data;
	const _test_iteration& test_iteration = m_test_iterations[n_iteration];

	/* Iterate through all generated vertices.. */
	for (unsigned int n_vertex = 0; n_vertex < test_iteration.n_vertices; ++n_vertex)
	{
		_vertex				expected_vertex;
		const glw::GLfloat* vertex_data = data_float + 3 /* components */ * n_vertex;

		expected_vertex.u = -1.0f;
		expected_vertex.v = -1.0f;
		expected_vertex.w = -1.0f;

		/* Make sure that for each vertex, the following language from the extension
		 * spec is followed:
		 */
		switch (test_iteration.primitive_mode)
		{
		case TESSELLATION_SHADER_PRIMITIVE_MODE_ISOLINES:
		{
			/* For isoline tessellation, if it generates vertices at (0,x) and (1,x)
			 * where <x> is not zero, it will also generate vertices at exactly (0,1-x)
			 * and (1,1-x), respectively.
			 */
			if (vertex_data[0] == 0.0f && vertex_data[1] != 0.0f)
			{
				expected_vertex.u = vertex_data[0];
				expected_vertex.v = 1.0f - vertex_data[1];
				expected_vertex.w = -1.0f;
			}
			else if (vertex_data[0] == 1.0f && vertex_data[1] != 0.0f)
			{
				expected_vertex.u = vertex_data[0];
				expected_vertex.v = 1.0f - vertex_data[1];
				expected_vertex.w = -1.0f;
			}

			break;
		} /* case TESSELLATION_SHADER_PRIMITIVE_MODE_ISOLINES: */

		case TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS:
		{
			/* For quad tessellation, if the subdivision generates a vertex with
			 * coordinates of (x,0) or (0,x), it will also generate a vertex with
			 * coordinates of exactly (1-x,0) or (0,1-x), respectively.
			 */
			if (vertex_data[0] != 0.0f && vertex_data[1] == 0.0f)
			{
				expected_vertex.u = 1.0f - vertex_data[0];
				expected_vertex.v = vertex_data[1];
				expected_vertex.w = -1.0f;
			}
			else if (vertex_data[0] == 0.0f && vertex_data[1] != 0.0f)
			{
				expected_vertex.u = vertex_data[0];
				expected_vertex.v = 1.0f - vertex_data[1];
				expected_vertex.w = -1.0f;
			}

			break;
		} /* case TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS: */

		case TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES:
		{
			/* For triangle tessellation, if the subdivision generates a vertex with
			 * tessellation coordinates of the form (0,x,1-x), (x,0,1-x), or (x,1-x,0),
			 * it will also generate a vertex with coordinates of exactly (0,1-x,x),
			 * (1-x,0,x), or (1-x,x,0), respectively.
			 */
			if (vertex_data[0] == 0.0f && vertex_data[1] != 0.0f && vertex_data[2] == (1.0f - vertex_data[1]))
			{
				expected_vertex.u = vertex_data[0];
				expected_vertex.v = vertex_data[2];
				expected_vertex.w = vertex_data[1];
			}
			else if (vertex_data[0] != 0.0f && vertex_data[1] == 0.0f && vertex_data[2] == (1.0f - vertex_data[0]))
			{
				expected_vertex.u = vertex_data[2];
				expected_vertex.v = vertex_data[1];
				expected_vertex.w = vertex_data[0];
			}
			else if (vertex_data[0] != 0.0f && vertex_data[1] == (1.0f - vertex_data[0]) && vertex_data[2] == 0.0f)
			{
				expected_vertex.u = vertex_data[1];
				expected_vertex.v = vertex_data[0];
				expected_vertex.w = vertex_data[2];
			}

			break;
		} /* case TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES: */

		default:
		{
			TCU_FAIL("Primitive mode unrecognized");
		}
		} /* switch (test_iteration.primitive_mode) */

		/* If any of the "expected vertex"'s components is no longer negative,
		 * make sure the vertex can be found in the result data */
		if (expected_vertex.u >= 0.0f || expected_vertex.v >= 0.0f || expected_vertex.w >= 0.0f)
		{
			bool has_been_found = false;

			for (unsigned int n_find_vertex = 0; n_find_vertex < test_iteration.n_vertices; ++n_find_vertex)
			{
				const glw::GLfloat* current_vertex_data = data_float + 3 /* components */ * n_find_vertex;

				const glw::GLfloat epsilon	 = 1e-4f;
				glw::GLfloat	   absDelta[3] = { de::abs(current_vertex_data[0] - expected_vertex.u),
											 de::abs(current_vertex_data[1] - expected_vertex.v),
											 de::abs(current_vertex_data[2] - expected_vertex.w) };

				if (absDelta[0] < epsilon && absDelta[1] < epsilon &&
					((expected_vertex.w < 0.0f) || (expected_vertex.w >= 0.0f && absDelta[2] < epsilon)))
				{
					has_been_found = true;

					break;
				} /* if (the vertex data matches the expected vertex data) */
			}	 /* for (all generated vertices)*/

			if (!has_been_found)
			{
				TCU_FAIL("Expected symmetrical vertex data was not generated by the tessellator.");
			}
		} /* if (any of the components of expected_vertex is no longer negative) */
	}	 /* for (all generated vertices) */
}

/** Constructor.
 *
 *  @param context Rendering context.
 *
 **/
TessellationShaderInvarianceRule4Test::TessellationShaderInvarianceRule4Test(Context&			  context,
																			 const ExtParameters& extParams)
	: TessellationShaderInvarianceBaseTest(context, extParams, "invariance_rule4",
										   "Verifies conformance with fourth invariance rule")
{
}

/** Destructor. */
TessellationShaderInvarianceRule4Test::~TessellationShaderInvarianceRule4Test()
{
	/* Left blank intentionally */
}

/** Retrieves amount of iterations the base test implementation should run before
 *  calling global verification routine.
 *
 *  @return A value that depends on initTestIterations() behavior.
 **/
unsigned int TessellationShaderInvarianceRule4Test::getAmountOfIterations()
{
	if (m_test_iterations.size() == 0)
	{
		initTestIterations();
	}

	return (unsigned int)m_test_iterations.size();
}

/** Retrieves iteration-specific tessellation properties.
 *
 *  @param n_iteration            Iteration index to retrieve the properties for.
 *  @param out_inner_tess_levels  Deref will be used to store iteration-specific inner
 *                                tessellation level values. Must not be NULL.
 *  @param out_outer_tess_levels  Deref will be used to store iteration-specific outer
 *                                tessellation level values. Must not be NULL.
 *  @param out_point_mode         Deref will be used to store iteration-specific flag
 *                                telling whether point mode should be enabled for given pass.
 *                                Must not be NULL.
 *  @param out_primitive_mode     Deref will be used to store iteration-specific primitive
 *                                mode. Must not be NULL.
 *  @param out_vertex_ordering    Deref will be used to store iteration-specific vertex
 *                                ordering. Must not be NULL.
 *  @param out_result_buffer_size Deref will be used to store amount of bytes XFB buffer object
 *                                storage should offer for the draw call to succeed. Can
 *                                be NULL.
 **/
void TessellationShaderInvarianceRule4Test::getIterationProperties(
	unsigned int n_iteration, float* out_inner_tess_levels, float* out_outer_tess_levels, bool* out_point_mode,
	_tessellation_primitive_mode* out_primitive_mode, _tessellation_shader_vertex_ordering* out_vertex_ordering,
	unsigned int* out_result_buffer_size)
{
	DE_ASSERT(m_test_iterations.size() > n_iteration);

	_test_iteration& test_iteration = m_test_iterations[n_iteration];

	memcpy(out_inner_tess_levels, test_iteration.inner_tess_levels, sizeof(test_iteration.inner_tess_levels));
	memcpy(out_outer_tess_levels, test_iteration.outer_tess_levels, sizeof(test_iteration.outer_tess_levels));

	*out_point_mode		 = false;
	*out_primitive_mode  = test_iteration.primitive_mode;
	*out_vertex_ordering = TESSELLATION_SHADER_VERTEX_ORDERING_CCW;

	if (out_result_buffer_size != DE_NULL)
	{
		*out_result_buffer_size = m_utils_ptr->getAmountOfVerticesGeneratedByTessellator(
			*out_primitive_mode, out_inner_tess_levels, out_outer_tess_levels, test_iteration.vertex_spacing,
			*out_point_mode);
		test_iteration.n_vertices = *out_result_buffer_size;
		*out_result_buffer_size =
			static_cast<unsigned int>(*out_result_buffer_size * 3 /* components */ * sizeof(float));

		DE_ASSERT(*out_result_buffer_size != 0);
	}
}

/** Retrieves iteration-specific tessellation evaluation shader code.
 *
 *  @param n_iteration Iteration index, for which the source code is being obtained.
 *
 *  @return Requested source code.
 **/
std::string TessellationShaderInvarianceRule4Test::getTECode(unsigned int n_iteration)
{
	DE_ASSERT(m_test_iterations.size() > n_iteration);

	const _test_iteration& test_iteration = m_test_iterations[n_iteration];

	return TessellationShaderUtils::getGenericTECode(test_iteration.vertex_spacing, test_iteration.primitive_mode,
													 TESSELLATION_SHADER_VERTEX_ORDERING_CCW, false); /* point mode */
}

/** Initializes test iterations for the test. The following modes and inner/outer tess level
 *  configurations are used to form the test set:
 *
 *  - Inner/outer tessellation level combinations as returned by
 *    TessellationShaderUtils::getTessellationLevelSetForPrimitiveMode()
 *  - 'Quads' and 'Triangles' primitive modes;
 *  - All vertex spacing modes;
 *
 *  All permutations are used to generate the test set.
 **/
void TessellationShaderInvarianceRule4Test::initTestIterations()
{
	DE_ASSERT(m_test_iterations.size() == 0);

	/* Retrieve GL_MAX_TESS_GEN_LEVEL_EXT value */
	const glw::Functions& gl						  = m_context.getRenderContext().getFunctions();
	glw::GLint			  gl_max_tess_gen_level_value = 0;

	gl.getIntegerv(m_glExtTokens.MAX_TESS_GEN_LEVEL, &gl_max_tess_gen_level_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_TESS_GEN_LEVEL_EXT pname");

	/* Iterate through all primitive and vertex spacing modes relevant to the test */
	_tessellation_primitive_mode primitive_modes[] = { TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS,
													   TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES };
	_tessellation_shader_vertex_spacing vs_modes[] = { TESSELLATION_SHADER_VERTEX_SPACING_EQUAL,
													   TESSELLATION_SHADER_VERTEX_SPACING_FRACTIONAL_EVEN,
													   TESSELLATION_SHADER_VERTEX_SPACING_FRACTIONAL_ODD };

	const unsigned int n_primitive_modes = sizeof(primitive_modes) / sizeof(primitive_modes[0]);
	const unsigned int n_vs_modes		 = sizeof(vs_modes) / sizeof(vs_modes[0]);

	for (unsigned int n_primitive_mode = 0; n_primitive_mode < n_primitive_modes; ++n_primitive_mode)
	{
		_tessellation_primitive_mode primitive_mode = primitive_modes[n_primitive_mode];

		for (unsigned int n_vs_mode = 0; n_vs_mode < n_vs_modes; ++n_vs_mode)
		{
			_tessellation_shader_vertex_spacing vs_mode = vs_modes[n_vs_mode];

			/* Retrieve inner/outer tessellation level combinations we want the tests to be run for */
			_tessellation_levels_set levels;

			levels = TessellationShaderUtils::getTessellationLevelSetForPrimitiveMode(
				primitive_mode, gl_max_tess_gen_level_value,
				TESSELLATION_LEVEL_SET_FILTER_ALL_LEVELS_USE_THE_SAME_VALUE);

			/* Iterate through all configurations */
			for (_tessellation_levels_set_const_iterator levels_iterator = levels.begin();
				 levels_iterator != levels.end(); levels_iterator++)
			{
				const _tessellation_levels& current_levels = *levels_iterator;

				/* Create a test descriptor for all the parameters we now have.
				 *
				 * The set we're operating on uses different outer tessellation level values, so we
				 * need to make sure the levels are set to the same FP values in order for the test
				 * to succeed. */
				_test_iteration test;

				memcpy(test.inner_tess_levels, current_levels.inner, sizeof(test.inner_tess_levels));

				for (int n = 0; n < 4 /* outer tess levels */; ++n)
				{
					test.outer_tess_levels[n] = current_levels.outer[0];
				}

				test.primitive_mode = primitive_mode;
				test.vertex_spacing = vs_mode;

				m_test_iterations.push_back(test);
			} /* for (all inner/outer tessellation levels) */
		}	 /* for (all vertex spacing modes) */
	}		  /* for (all primitive modes) */
}

/** Verifies user-provided vertex data can be found in the provided vertex data array.
 *
 *  @param vertex_data                     Vertex data array the requested vertex data are to be found in.
 *  @param n_vertices                      Amount of vertices declared in @param vertex_data;
 *  @param vertex_data_seeked              Vertex data to be found in @param vertex_data;
 *  @param n_vertex_data_seeked_components Amount of components to take into account.
 *
 *  @return true if the vertex data was found, false otherwise.
 **/
bool TessellationShaderInvarianceRule4Test::isVertexDefined(const float* vertex_data, unsigned int n_vertices,
															const float* vertex_data_seeked,
															unsigned int n_vertex_data_seeked_components)
{
	bool result = false;

	DE_ASSERT(n_vertex_data_seeked_components >= 2);

	for (unsigned int n_vertex = 0; n_vertex < n_vertices; ++n_vertex)
	{
		const float* current_vertex_data = vertex_data + 3 /* components */ * n_vertex;

		if ((vertex_data_seeked[0] == current_vertex_data[0]) && (vertex_data_seeked[1] == current_vertex_data[1]) &&
			((n_vertex_data_seeked_components < 3) ||
			 (n_vertex_data_seeked_components >= 3 && (vertex_data_seeked[2] == current_vertex_data[2]))))
		{
			result = true;

			break;
		} /* if (components match) */
	}	 /* for (all vertices) */

	return result;
}

/** Verifies result data on per-iteration basis.
 *
 *  Throws TestError exception if an error occurs.
 *
 *  @param n_iteration Index of iteration the check should be performed for.
 *  @param data        Points to array of vec3s storing the vertices as
 *                     generated by tessellation
 **/
void TessellationShaderInvarianceRule4Test::verifyResultDataForIteration(unsigned int n_iteration, const void* data)
{
	DE_ASSERT(m_test_iterations.size() > n_iteration);

	const glw::GLfloat*	data_float	 = (const glw::GLfloat*)data;
	const _test_iteration& test_iteration = m_test_iterations[n_iteration];

	/* Iterate through all generated vertices.. */
	for (unsigned int n_vertex = 0; n_vertex < test_iteration.n_vertices; ++n_vertex)
	{
		std::vector<_vertex> expected_vertices;
		const glw::GLfloat*  vertex_data = data_float + 3 /* components */ * n_vertex;

		/* Make sure that for each vertex, the following language from the extension
		 * spec is followed:
		 */
		switch (test_iteration.primitive_mode)
		{
		case TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS:
		{
			/* For quad tessellation, if vertices at (x,0) and (1-x,0) are generated
			 * when subdividing the v==0 edge, vertices must be generated at (0,x) and
			 * (0,1-x) when subdividing an otherwise identical u==0 edge.
			 */
			if (vertex_data[0] != 0.0f && vertex_data[1] == 0.0f)
			{
				const float paired_vertex_data[] = { 1.0f - vertex_data[0], vertex_data[1] };

				if (isVertexDefined(data_float, test_iteration.n_vertices, paired_vertex_data, 2)) /* components */
				{
					_vertex expected_vertex;

					/* First expected vertex */
					expected_vertex.u = vertex_data[1];
					expected_vertex.v = vertex_data[0];
					expected_vertex.w = -1.0f;

					expected_vertices.push_back(expected_vertex);

					/* The other expected vertex */
					expected_vertex.u = vertex_data[1];
					expected_vertex.v = 1.0f - vertex_data[0];

					expected_vertices.push_back(expected_vertex);
				} /* if (the other required vertex is defined) */
			}	 /* if (the first required vertex is defined) */

			break;
		} /* case TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS: */

		case TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES:
		{
			/* For triangular tessellation, if vertices at (x,1-x,0) and (1-x,x,0) are
			 * generated when subdividing the w==0 edge, vertices must be generated at
			 * (x,0,1-x) and (1-x,0,x) when subdividing an otherwise identical v==0
			 * edge.
			 */
			if (vertex_data[0] != 0.0f && vertex_data[1] == (1.0f - vertex_data[0]) && vertex_data[2] == 0)
			{
				const float paired_vertex_data[] = { vertex_data[1], vertex_data[0], vertex_data[2] };

				if (isVertexDefined(data_float, test_iteration.n_vertices, paired_vertex_data, 3)) /* components */
				{
					_vertex expected_vertex;

					/* First expected vertex */
					expected_vertex.u = vertex_data[0];
					expected_vertex.v = vertex_data[2];
					expected_vertex.w = vertex_data[1];

					expected_vertices.push_back(expected_vertex);

					/* The other expected vertex */
					expected_vertex.u = vertex_data[1];
					expected_vertex.v = vertex_data[2];
					expected_vertex.w = vertex_data[0];

					expected_vertices.push_back(expected_vertex);
				} /* if (the other required vertex is defined) */
			}	 /* if (the firsst required vertex is defined) */

			break;
		} /* case TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES: */

		default:
		{
			TCU_FAIL("Primitive mode unrecognized");
		}
		} /* switch (test_iteration.primitive_mode) */

		/* Iterate through all expected vertices */
		for (std::vector<_vertex>::const_iterator expected_vertex_iterator = expected_vertices.begin();
			 expected_vertex_iterator != expected_vertices.end(); expected_vertex_iterator++)
		{
			const _vertex& expected_vertex		 = *expected_vertex_iterator;
			const float	expected_vertex_raw[] = { expected_vertex.u, expected_vertex.v, expected_vertex.w };
			bool		   has_been_found		 = false;

			has_been_found = isVertexDefined(data_float, test_iteration.n_vertices, expected_vertex_raw,
											 (expected_vertex.w < 0) ? 2 : 3);

			if (!has_been_found)
			{
				std::stringstream expected_vertex_sstream;

				expected_vertex_sstream << expected_vertex.u << ", " << expected_vertex.v;

				if (expected_vertex.w >= 0.0f)
				{
					expected_vertex_sstream << ", " << expected_vertex.w;
				}

				m_testCtx.getLog() << tcu::TestLog::Message << "For primitive mode:"
								   << "["
								   << TessellationShaderUtils::getESTokenForPrimitiveMode(test_iteration.primitive_mode)
								   << "]"
								   << "and vertex spacing mode:"
								   << "[" << TessellationShaderUtils::getESTokenForVertexSpacingMode(
												 test_iteration.vertex_spacing)
								   << "]"
								   << " and inner tessellation levels:[" << test_iteration.inner_tess_levels[0] << ", "
								   << test_iteration.inner_tess_levels[1] << ") "
								   << " and outer tessellation levels:[" << test_iteration.outer_tess_levels[0] << ", "
								   << test_iteration.outer_tess_levels[1] << ", " << test_iteration.outer_tess_levels[2]
								   << ", " << test_iteration.outer_tess_levels[3] << ") "
								   << " the following vertex was expected:[" << expected_vertex_sstream.str().c_str()
								   << "] but was not found in the tessellated cooordinate data set"
								   << tcu::TestLog::EndMessage;

				TCU_FAIL("Expected symmetrical vertex data was not generated by the tessellator.");
			} /* if (the expected vertex data was not found) */
		}	 /* for (all expected vertices) */
	}		  /* for (all generated vertices) */
}

/** Constructor.
 *
 *  @param context Rendering context.
 *
 **/
TessellationShaderInvarianceRule5Test::TessellationShaderInvarianceRule5Test(Context&			  context,
																			 const ExtParameters& extParams)
	: TessellationShaderInvarianceBaseTest(context, extParams, "invariance_rule5",
										   "Verifies conformance with fifth invariance rule")
{
}

/** Destructor. */
TessellationShaderInvarianceRule5Test::~TessellationShaderInvarianceRule5Test()
{
	/* Left blank intentionally */
}

/** Retrieves amount of iterations the base test implementation should run before
 *  calling global verification routine.
 *
 *  @return A value that depends on initTestIterations() behavior.
 **/
unsigned int TessellationShaderInvarianceRule5Test::getAmountOfIterations()
{
	if (m_test_quads_iterations.size() == 0 || m_test_triangles_iterations.size() == 0)
	{
		initTestIterations();
	}

	return (unsigned int)(m_test_quads_iterations.size() + m_test_triangles_iterations.size());
}

/** Retrieves _test_iteration instance specific for user-specified iteration index.
 *
 *  @param n_iteration Iteration index to retrieve _test_iteration instance for.
 *
 * @return Iteration-specific _test_iteration instance.
 *
 **/
TessellationShaderInvarianceRule5Test::_test_iteration& TessellationShaderInvarianceRule5Test::getTestForIteration(
	unsigned int n_iteration)
{
	unsigned int	 n_triangles_tests = (unsigned int)m_test_triangles_iterations.size();
	_test_iteration& test_iteration	= (n_iteration < n_triangles_tests) ?
										  m_test_triangles_iterations[n_iteration] :
										  m_test_quads_iterations[n_iteration - n_triangles_tests];

	return test_iteration;
}

/** Retrieves iteration-specific tessellation properties.
 *
 *  @param n_iteration            Iteration index to retrieve the properties for.
 *  @param out_inner_tess_levels  Deref will be used to store iteration-specific inner
 *                                tessellation level values. Must not be NULL.
 *  @param out_outer_tess_levels  Deref will be used to store iteration-specific outer
 *                                tessellation level values. Must not be NULL.
 *  @param out_point_mode         Deref will be used to store iteration-specific flag
 *                                telling whether point mode should be enabled for given pass.
 *                                Must not be NULL.
 *  @param out_primitive_mode     Deref will be used to store iteration-specific primitive
 *                                mode. Must not be NULL.
 *  @param out_vertex_ordering    Deref will be used to store iteration-specific vertex
 *                                ordering. Must not be NULL.
 *  @param out_result_buffer_size Deref will be used to store amount of bytes XFB buffer object
 *                                storage should offer for the draw call to succeed. Can
 *                                be NULL.
 **/
void TessellationShaderInvarianceRule5Test::getIterationProperties(
	unsigned int n_iteration, float* out_inner_tess_levels, float* out_outer_tess_levels, bool* out_point_mode,
	_tessellation_primitive_mode* out_primitive_mode, _tessellation_shader_vertex_ordering* out_vertex_ordering,
	unsigned int* out_result_buffer_size)
{
	DE_ASSERT(m_test_triangles_iterations.size() + m_test_quads_iterations.size() > n_iteration);

	_test_iteration& test_iteration = getTestForIteration(n_iteration);

	memcpy(out_inner_tess_levels, test_iteration.inner_tess_levels, sizeof(test_iteration.inner_tess_levels));
	memcpy(out_outer_tess_levels, test_iteration.outer_tess_levels, sizeof(test_iteration.outer_tess_levels));

	*out_point_mode		 = false;
	*out_primitive_mode  = test_iteration.primitive_mode;
	*out_vertex_ordering = test_iteration.vertex_ordering;

	if (out_result_buffer_size != DE_NULL)
	{
		*out_result_buffer_size = m_utils_ptr->getAmountOfVerticesGeneratedByTessellator(
			*out_primitive_mode, out_inner_tess_levels, out_outer_tess_levels, TESSELLATION_SHADER_VERTEX_SPACING_EQUAL,
			*out_point_mode);
		test_iteration.n_vertices = *out_result_buffer_size;
		*out_result_buffer_size =
			static_cast<unsigned int>(*out_result_buffer_size * 3 /* components */ * sizeof(float));

		DE_ASSERT(*out_result_buffer_size != 0);
	}
}

/** Retrieves iteration-specific tessellation evaluation shader code.
 *
 *  @param n_iteration Iteration index, for which the source code is being obtained.
 *
 *  @return Requested source code.
 **/
std::string TessellationShaderInvarianceRule5Test::getTECode(unsigned int n_iteration)
{
	DE_ASSERT(m_test_triangles_iterations.size() + m_test_quads_iterations.size() > n_iteration);

	const _test_iteration& test_iteration = getTestForIteration(n_iteration);

	return TessellationShaderUtils::getGenericTECode(TESSELLATION_SHADER_VERTEX_SPACING_EQUAL,
													 test_iteration.primitive_mode, test_iteration.vertex_ordering,
													 false); /* point mode */
}

/** Initializes test iterations for the test. The following modes and inner/outer tess level
 *  configurations are used to form the test set:
 *
 *  - Last inner/outer tessellation level combination as returned by
 *    TessellationShaderUtils::getTessellationLevelSetForPrimitiveMode()
 *  - All primitive modes;
 *  - All vertex spacing modes;
 *
 *  All permutations are used to generate the test set.
 **/
void TessellationShaderInvarianceRule5Test::initTestIterations()
{
	DE_ASSERT(m_test_quads_iterations.size() == 0 && m_test_triangles_iterations.size() == 0);

	/* Retrieve GL_MAX_TESS_GEN_LEVEL_EXT value */
	const glw::Functions& gl						  = m_context.getRenderContext().getFunctions();
	glw::GLint			  gl_max_tess_gen_level_value = 0;

	gl.getIntegerv(m_glExtTokens.MAX_TESS_GEN_LEVEL, &gl_max_tess_gen_level_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_TESS_GEN_LEVEL_EXT pname");

	/* Iterate through all primitive and vertex spacing modes relevant to the test */
	_tessellation_primitive_mode primitive_modes[] = { TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS,
													   TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES };
	_tessellation_shader_vertex_ordering vo_modes[] = {
		TESSELLATION_SHADER_VERTEX_ORDERING_CCW, TESSELLATION_SHADER_VERTEX_ORDERING_CW,
	};

	const unsigned int n_primitive_modes = sizeof(primitive_modes) / sizeof(primitive_modes[0]);
	const unsigned int n_vo_modes		 = sizeof(vo_modes) / sizeof(vo_modes[0]);

	for (unsigned int n_primitive_mode = 0; n_primitive_mode < n_primitive_modes; ++n_primitive_mode)
	{
		_tessellation_primitive_mode primitive_mode = primitive_modes[n_primitive_mode];

		for (unsigned int n_vo_mode = 0; n_vo_mode < n_vo_modes; ++n_vo_mode)
		{
			_tessellation_shader_vertex_ordering vertex_ordering = vo_modes[n_vo_mode];

			/* Retrieve inner/outer tessellation level combinations we want the tests to be run for */
			_tessellation_levels_set levels_set;

			levels_set = TessellationShaderUtils::getTessellationLevelSetForPrimitiveMode(
				primitive_mode, gl_max_tess_gen_level_value,
				TESSELLATION_LEVEL_SET_FILTER_ALL_LEVELS_USE_THE_SAME_VALUE);

			/* Only use the last inner/outer level configuration, as reported by the utils function. */
			const _tessellation_levels& levels = levels_set[levels_set.size() - 1];

			/* Create a test descriptor for all the parameters we now have */
			_test_iteration test;

			memcpy(test.inner_tess_levels, levels.inner, sizeof(test.inner_tess_levels));
			memcpy(test.outer_tess_levels, levels.outer, sizeof(test.outer_tess_levels));

			test.primitive_mode  = primitive_mode;
			test.vertex_ordering = vertex_ordering;

			if (primitive_mode == TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES)
			{
				m_test_triangles_iterations.push_back(test);
			}
			else
			{
				m_test_quads_iterations.push_back(test);
			}
		} /* for (all vertex spacing modes) */
	}	 /* for (all primitive modes) */
}

/** Verifies user-provided vertex data can be found in the provided vertex data array.
 *
 *  @param vertex_data                     Vertex data array the requested vertex data are to be found in.
 *  @param n_vertices                      Amount of vertices declared in @param vertex_data;
 *  @param vertex_data_seeked              Vertex data to be found in @param vertex_data;
 *  @param n_vertex_data_seeked_components Amount of components to take into account.
 *
 *  @return true if the vertex data was found, false otherwise.
 **/
bool TessellationShaderInvarianceRule5Test::isVertexDefined(const float* vertex_data, unsigned int n_vertices,
															const float* vertex_data_seeked,
															unsigned int n_vertex_data_seeked_components)
{
	const float epsilon = 1e-5f;
	bool		result  = false;

	DE_ASSERT(n_vertex_data_seeked_components >= 2);

	for (unsigned int n_vertex = 0; n_vertex < n_vertices; ++n_vertex)
	{
		const float* current_vertex_data = vertex_data + 3 /* components */ * n_vertex;

		if (de::abs(vertex_data_seeked[0] - current_vertex_data[0]) < epsilon &&
			de::abs(vertex_data_seeked[1] - current_vertex_data[1]) < epsilon &&
			((n_vertex_data_seeked_components < 3) ||
			 (n_vertex_data_seeked_components >= 3 &&
			  de::abs(vertex_data_seeked[2] - current_vertex_data[2]) < epsilon)))
		{
			result = true;

			break;
		} /* if (components match) */
	}	 /* for (all vertices) */

	return result;
}

/** Verifies result data. Accesses data generated by all iterations.
 *
 *  Throws TestError exception if an error occurs.
 *
 *  @param all_iterations_data An array of pointers to buffers, holding gl_TessCoord
 *                             data generated by subsequent iterations.
 **/
void TessellationShaderInvarianceRule5Test::verifyResultData(const void** all_iterations_data)
{
	/* Run two separate iterations:
	 *
	 * a) triangles
	 * b) quads
	 */
	for (unsigned int n_iteration = 0; n_iteration < 2 /* quads, triangles */; ++n_iteration)
	{
		const unsigned int n_base_iteration =
			(n_iteration == 0) ? 0 : (unsigned int)m_test_triangles_iterations.size();
		const unsigned int set_size = (n_iteration == 0) ? (unsigned int)m_test_triangles_iterations.size() :
														   (unsigned int)m_test_quads_iterations.size();
		const _test_iterations& test_iterations =
			(n_iteration == 0) ? m_test_triangles_iterations : m_test_quads_iterations;

		DE_ASSERT(test_iterations.size() != 0);

		/* For each iteration, verify that all vertices generated for all three vertex spacing modes.
		 * are exactly the same (but in different order) */
		const float* base_vertex_data = (const float*)all_iterations_data[n_base_iteration + 0];

		for (unsigned int n_set = 1; n_set < set_size; ++n_set)
		{
			const float* set_vertex_data = (const float*)all_iterations_data[n_base_iteration + n_set];

			/* Amount of vertices should not differ between sets */
			DE_ASSERT(test_iterations[0].n_vertices == test_iterations[n_set].n_vertices);

			/* Run through all vertices in base set and make sure they can be found in currently
			 * processed set */
			for (unsigned int n_base_vertex = 0; n_base_vertex < test_iterations[0].n_vertices; ++n_base_vertex)
			{
				const float* base_vertex = base_vertex_data + 3 /* components */ * n_base_vertex;

				if (!isVertexDefined(set_vertex_data, test_iterations[n_set].n_vertices, base_vertex,
									 3)) /* components */
				{
					const char* primitive_mode = (n_iteration == 0) ? "triangles" : "quads";

					m_testCtx.getLog() << tcu::TestLog::Message << "For primitive mode [" << primitive_mode << "] "
									   << "a vertex with tessellation coordinates:[" << base_vertex[0] << ", "
									   << base_vertex[1] << ", " << base_vertex[2] << ") "
									   << "could not have been found for both vertex orderings."
									   << tcu::TestLog::EndMessage;

					TCU_FAIL("Implementation does not follow Rule 5.");
				}
			} /* for (all base set's vertices) */
		}	 /* for (all sets) */
	}		  /* for (both primitive types) */
}

/** Constructor.
 *
 *  @param context Rendering context.
 *
 **/
TessellationShaderInvarianceRule6Test::TessellationShaderInvarianceRule6Test(Context&			  context,
																			 const ExtParameters& extParams)
	: TessellationShaderInvarianceBaseTest(context, extParams, "invariance_rule6",
										   "Verifies conformance with sixth invariance rule")
{
}

/** Destructor. */
TessellationShaderInvarianceRule6Test::~TessellationShaderInvarianceRule6Test()
{
	/* Left blank intentionally */
}

/** Retrieves amount of iterations the base test implementation should run before
 *  calling global verification routine.
 *
 *  @return A value that depends on initTestIterations() behavior.
 **/
unsigned int TessellationShaderInvarianceRule6Test::getAmountOfIterations()
{
	if (m_test_quads_iterations.size() == 0 || m_test_triangles_iterations.size() == 0)
	{
		initTestIterations();
	}

	return (unsigned int)(m_test_quads_iterations.size() + m_test_triangles_iterations.size());
}

/** Retrieves _test_iteration instance specific for user-specified iteration index.
 *
 *  @param n_iteration Iteration index to retrieve _test_iteration instance for.
 *
 * @return Iteration-specific _test_iteration instance.
 *
 **/
TessellationShaderInvarianceRule6Test::_test_iteration& TessellationShaderInvarianceRule6Test::getTestForIteration(
	unsigned int n_iteration)
{
	unsigned int	 n_triangles_tests = (unsigned int)m_test_triangles_iterations.size();
	_test_iteration& test_iteration	= (n_iteration < n_triangles_tests) ?
										  m_test_triangles_iterations[n_iteration] :
										  m_test_quads_iterations[n_iteration - n_triangles_tests];

	return test_iteration;
}

/** Retrieves iteration-specific tessellation properties.
 *
 *  @param n_iteration            Iteration index to retrieve the properties for.
 *  @param out_inner_tess_levels  Deref will be used to store iteration-specific inner
 *                                tessellation level values. Must not be NULL.
 *  @param out_outer_tess_levels  Deref will be used to store iteration-specific outer
 *                                tessellation level values. Must not be NULL.
 *  @param out_point_mode         Deref will be used to store iteration-specific flag
 *                                telling whether point mode should be enabled for given pass.
 *                                Must not be NULL.
 *  @param out_primitive_mode     Deref will be used to store iteration-specific primitive
 *                                mode. Must not be NULL.
 *  @param out_vertex_ordering    Deref will be used to store iteration-specific vertex
 *                                ordering. Must not be NULL.
 *  @param out_result_buffer_size Deref will be used to store amount of bytes XFB buffer object
 *                                storage should offer for the draw call to succeed. Can
 *                                be NULL.
 **/
void TessellationShaderInvarianceRule6Test::getIterationProperties(
	unsigned int n_iteration, float* out_inner_tess_levels, float* out_outer_tess_levels, bool* out_point_mode,
	_tessellation_primitive_mode* out_primitive_mode, _tessellation_shader_vertex_ordering* out_vertex_ordering,
	unsigned int* out_result_buffer_size)
{
	DE_ASSERT(m_test_triangles_iterations.size() + m_test_quads_iterations.size() > n_iteration);

	_test_iteration& test_iteration = getTestForIteration(n_iteration);

	memcpy(out_inner_tess_levels, test_iteration.inner_tess_levels, sizeof(test_iteration.inner_tess_levels));
	memcpy(out_outer_tess_levels, test_iteration.outer_tess_levels, sizeof(test_iteration.outer_tess_levels));

	*out_point_mode		 = false;
	*out_primitive_mode  = test_iteration.primitive_mode;
	*out_vertex_ordering = test_iteration.vertex_ordering;

	if (out_result_buffer_size != DE_NULL)
	{
		*out_result_buffer_size = m_utils_ptr->getAmountOfVerticesGeneratedByTessellator(
			*out_primitive_mode, out_inner_tess_levels, out_outer_tess_levels, TESSELLATION_SHADER_VERTEX_SPACING_EQUAL,
			*out_point_mode);
		test_iteration.n_vertices = *out_result_buffer_size;
		*out_result_buffer_size =
			static_cast<unsigned int>(*out_result_buffer_size * 3 /* components */ * sizeof(float));

		DE_ASSERT(*out_result_buffer_size != 0);
	}
}

/** Retrieves iteration-specific tessellation evaluation shader code.
 *
 *  @param n_iteration Iteration index, for which the source code is being obtained.
 *
 *  @return Requested source code.
 **/
std::string TessellationShaderInvarianceRule6Test::getTECode(unsigned int n_iteration)
{
	DE_ASSERT(m_test_triangles_iterations.size() + m_test_quads_iterations.size() > n_iteration);

	const _test_iteration& test_iteration = getTestForIteration(n_iteration);

	return TessellationShaderUtils::getGenericTECode(TESSELLATION_SHADER_VERTEX_SPACING_EQUAL,
													 test_iteration.primitive_mode, test_iteration.vertex_ordering,
													 false); /* point mode */
}

/** Initializes test iterations for the test. The following modes and inner/outer tess level
 *  configurations are used to form the test set:
 *
 *  - Tessellation level combinations as returned by
 *    TessellationShaderUtils::getTessellationLevelSetForPrimitiveMode() (however, the inner
 *    tessellation level values are all set to values corresponding to last item returned for
 *    the set)
 *  - All primitive modes;
 *  - All vertex ordering modes;
 *
 *  All permutations are used to generate the test set.
 **/
void TessellationShaderInvarianceRule6Test::initTestIterations()
{
	DE_ASSERT(m_test_quads_iterations.size() == 0 && m_test_triangles_iterations.size() == 0);

	/* Retrieve GL_MAX_TESS_GEN_LEVEL_EXT value */
	const glw::Functions& gl						  = m_context.getRenderContext().getFunctions();
	glw::GLint			  gl_max_tess_gen_level_value = 0;

	gl.getIntegerv(m_glExtTokens.MAX_TESS_GEN_LEVEL, &gl_max_tess_gen_level_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_TESS_GEN_LEVEL_EXT pname");

	/* Iterate through all primitive and vertex spacing modes relevant to the test */
	_tessellation_primitive_mode primitive_modes[] = { TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES,
													   TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS };
	_tessellation_shader_vertex_ordering vertex_ordering_modes[] = { TESSELLATION_SHADER_VERTEX_ORDERING_CCW,
																	 TESSELLATION_SHADER_VERTEX_ORDERING_CW };

	const unsigned int n_primitive_modes = sizeof(primitive_modes) / sizeof(primitive_modes[0]);
	const unsigned int n_vo_modes		 = sizeof(vertex_ordering_modes) / sizeof(vertex_ordering_modes[0]);

	for (unsigned int n_primitive_mode = 0; n_primitive_mode < n_primitive_modes; ++n_primitive_mode)
	{
		_tessellation_primitive_mode primitive_mode = primitive_modes[n_primitive_mode];

		for (unsigned int n_vo_mode = 0; n_vo_mode < n_vo_modes; ++n_vo_mode)
		{
			_tessellation_shader_vertex_ordering vertex_ordering = vertex_ordering_modes[n_vo_mode];

			/* Retrieve inner/outer tessellation level combinations we want the tests to be run for.
			 * Since each level set we will be provided by getTessellationLevelSetForPrimitiveMode()
			 * is unique and does not repeat, we'll just make sure the inner level values are set to
			 * the same set of values, so that the conditions the test must meet are actually met.
			 */
			float*					 inner_levels_to_use = DE_NULL;
			_tessellation_levels_set levels_set;
			unsigned int			 n_levels_sets = 0;

			levels_set = TessellationShaderUtils::getTessellationLevelSetForPrimitiveMode(
				primitive_mode, gl_max_tess_gen_level_value,
				TESSELLATION_LEVEL_SET_FILTER_ALL_LEVELS_USE_THE_SAME_VALUE);

			n_levels_sets		= (unsigned int)levels_set.size();
			inner_levels_to_use = levels_set[n_levels_sets - 1].inner;

			for (unsigned int n_levels_set = 0; n_levels_set < n_levels_sets - 1; n_levels_set++)
			{
				/* Make sure the Utils function was not changed and that inner level values
				 * are actually unique across the whole set */
				DE_ASSERT(levels_set[n_levels_set].inner[0] != levels_set[n_levels_sets - 1].inner[0] &&
						  levels_set[n_levels_set].inner[1] != levels_set[n_levels_sets - 1].inner[1]);

				/* Force the last set's inner values to all level combinations we'll be using */
				memcpy(levels_set[n_levels_set].inner, inner_levels_to_use, sizeof(levels_set[n_levels_set].inner));
			} /* for (all sets retrieved from Utils function */

			for (_tessellation_levels_set_const_iterator set_iterator = levels_set.begin();
				 set_iterator != levels_set.end(); set_iterator++)
			{
				const _tessellation_levels& levels = *set_iterator;

				/* Create a test descriptor for all the parameters we now have */
				_test_iteration test;

				memcpy(test.inner_tess_levels, levels.inner, sizeof(test.inner_tess_levels));
				memcpy(test.outer_tess_levels, levels.outer, sizeof(test.outer_tess_levels));

				test.primitive_mode  = primitive_mode;
				test.vertex_ordering = vertex_ordering;

				if (primitive_mode == TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES)
				{
					m_test_triangles_iterations.push_back(test);
				}
				else
				{
					m_test_quads_iterations.push_back(test);
				}
			} /* for (all level sets) */
		}	 /* for (all vertex ordering modes) */
	}		  /* for (all primitive modes) */
}

/** Verifies result data. Accesses data generated by all iterations.
 *
 *  Throws TestError exception if an error occurs.
 *
 *  @param all_iterations_data An array of pointers to buffers, holding gl_TessCoord
 *                             data generated by subsequent iterations.
 **/
void TessellationShaderInvarianceRule6Test::verifyResultData(const void** all_iterations_data)
{
	/* Run two separate iterations:
	 *
	 * a) triangles
	 * b) quads
	 */

	for (unsigned int n_iteration = 0; n_iteration < 2 /* quads, triangles */; ++n_iteration)
	{
		const unsigned int n_base_iteration =
			(n_iteration == 0) ? 0 : (unsigned int)m_test_triangles_iterations.size();

		const unsigned int n_sets = (n_iteration == 0) ? (unsigned int)m_test_triangles_iterations.size() :
														 (unsigned int)m_test_quads_iterations.size();

		_tessellation_primitive_mode primitive_mode = (n_iteration == 0) ?
														  TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES :
														  TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS;

		const _test_iterations& test_iterations =
			(n_iteration == 0) ? m_test_triangles_iterations : m_test_quads_iterations;

		const unsigned int n_triangles_in_base_set = test_iterations[0].n_vertices / 3 /* vertices per triangle */;

		DE_ASSERT(test_iterations.size() != 0);

		/* For each iteration, verify that all vertices generated for all three vertex spacing modes.
		 * are exactly the same (but in different order) */
		const _test_iteration& base_test		= test_iterations[0];
		const float*		   base_vertex_data = (const float*)all_iterations_data[n_base_iteration + 0];

		for (unsigned int n_set = 1; n_set < n_sets; ++n_set)
		{
			const _test_iteration& set_test		   = test_iterations[n_set];
			const float*		   set_vertex_data = (const float*)all_iterations_data[n_base_iteration + n_set];

			/* We're operating on triangles so make sure the amount of vertices we're dealing with is
			 * divisible by 3 */
			DE_ASSERT((test_iterations[n_set].n_vertices % 3) == 0);

			const unsigned int n_triangles_in_curr_set = test_iterations[n_set].n_vertices / 3;

			/* Take base triangles and make sure they can be found in iteration-specific set.
			 * Now, thing to keep in mind here is that we must not assume any specific vertex
			 * and triangle order which is why the slow search. */
			for (unsigned int n_base_triangle = 0; n_base_triangle < n_triangles_in_base_set; ++n_base_triangle)
			{
				/* Extract base triangle data first */
				const float* base_triangle_vertex1 = base_vertex_data +
													 n_base_triangle * 3 *		/* vertices per triangle */
														 3;						/* components */
				const float* base_triangle_vertex2 = base_triangle_vertex1 + 3; /* components */
				const float* base_triangle_vertex3 = base_triangle_vertex2 + 3; /* components */

				/* Only interior triangles should be left intact. Is this an interior triangle? */
				if (!TessellationShaderUtils::isOuterEdgeVertex(primitive_mode, base_triangle_vertex1) &&
					!TessellationShaderUtils::isOuterEdgeVertex(primitive_mode, base_triangle_vertex2) &&
					!TessellationShaderUtils::isOuterEdgeVertex(primitive_mode, base_triangle_vertex3))
				{
					/* Iterate through all triangles in considered set */
					bool has_base_set_triangle_been_found = false;

					for (unsigned int n_curr_set_triangle = 0; n_curr_set_triangle < n_triangles_in_curr_set;
						 ++n_curr_set_triangle)
					{
						const float* curr_triangle = set_vertex_data +
													 n_curr_set_triangle * 3 * /* vertices per triangle */
														 3;					   /* components */

						if (TessellationShaderUtils::isTriangleDefined(base_triangle_vertex1, curr_triangle))
						{
							has_base_set_triangle_been_found = true;

							break;
						}
					} /* for (all triangles in currently processed set) */

					if (!has_base_set_triangle_been_found)
					{
						std::string primitive_mode_str =
							TessellationShaderUtils::getESTokenForPrimitiveMode(base_test.primitive_mode);

						m_testCtx.getLog()
							<< tcu::TestLog::Message << "For primitive mode [" << primitive_mode_str << "]"
							<< ", base inner tessellation levels:"
							<< "[" << base_test.inner_tess_levels[0] << ", " << base_test.inner_tess_levels[1] << "]"
							<< ", base outer tessellation levels:"
							<< "[" << base_test.outer_tess_levels[0] << ", " << base_test.outer_tess_levels[1] << ", "
							<< base_test.outer_tess_levels[2] << ", " << base_test.outer_tess_levels[3] << "]"
							<< ", reference inner tessellation levels:"
							<< "[" << set_test.inner_tess_levels[0] << ", " << set_test.inner_tess_levels[1] << "]"
							<< ", reference outer tessellation levels:"
							<< "[" << set_test.outer_tess_levels[0] << ", " << set_test.outer_tess_levels[1] << ", "
							<< set_test.outer_tess_levels[2] << ", " << set_test.outer_tess_levels[3] << "]"
							<< ", the following triangle formed during base tessellation run was not found in "
							   "reference run:"
							<< "[" << base_triangle_vertex1[0] << ", " << base_triangle_vertex1[1] << ", "
							<< base_triangle_vertex1[2] << "]x"
							<< "[" << base_triangle_vertex2[0] << ", " << base_triangle_vertex2[1] << ", "
							<< base_triangle_vertex2[2] << "]x"
							<< "[" << base_triangle_vertex3[0] << ", " << base_triangle_vertex3[1] << ", "
							<< base_triangle_vertex3[2]

							<< tcu::TestLog::EndMessage;

						TCU_FAIL("Implementation does not appear to be rule 6-conformant");
					} /* if (triangle created during base run was not found in reference run) */
				}	 /* if (base triangle is interior) */
			}		  /* for (all base set's vertices) */
		}			  /* for (all sets) */
	}				  /* for (both primitive types) */
}

/** Constructor.
 *
 *  @param context Rendering context.
 *
 **/
TessellationShaderInvarianceRule7Test::TessellationShaderInvarianceRule7Test(Context&			  context,
																			 const ExtParameters& extParams)
	: TessellationShaderInvarianceBaseTest(context, extParams, "invariance_rule7",
										   "Verifies conformance with seventh invariance rule")
{
}

/** Destructor. */
TessellationShaderInvarianceRule7Test::~TessellationShaderInvarianceRule7Test()
{
	/* Left blank intentionally */
}

/** Retrieves amount of iterations the base test implementation should run before
 *  calling global verification routine.
 *
 *  @return A value that depends on initTestIterations() behavior.
 **/
unsigned int TessellationShaderInvarianceRule7Test::getAmountOfIterations()
{
	if (m_test_quads_iterations.size() == 0 || m_test_triangles_iterations.size() == 0)
	{
		initTestIterations();
	}

	return (unsigned int)(m_test_quads_iterations.size() + m_test_triangles_iterations.size());
}

/** Retrieves index of a test iteration that was initialized with user-provided
 *  properties.
 *
 *  @param is_triangles_iteration      true if the seeked test iteration should have
 *                                     been run for 'triangles' primitive mode', false
 *                                     if 'quads' primitive mode run is seeked.
 *  @param inner_tess_levels           Two FP values describing inner tessellation level
 *                                     values the seeked run should have used.
 *  @param outer_tess_levels           Four FP values describing outer tessellation level
 *                                     values the seeked run should have used.
 *  @param vertex_ordering             Vertex ordering mode the seeked run should have used.
 *  @param n_modified_outer_tess_level Tells which outer tessellation level should be
 *                                     excluded from checking.
 *
 *  @return 0xFFFFFFFF if no test iteration was run for user-provided properties,
 *          actual index otherwise.
 *
 **/
unsigned int TessellationShaderInvarianceRule7Test::getTestIterationIndex(
	bool is_triangles_iteration, const float* inner_tess_levels, const float* outer_tess_levels,
	_tessellation_shader_vertex_ordering vertex_ordering, unsigned int n_modified_outer_tess_level)
{
	const float				epsilon = 1e-5f;
	unsigned int			result  = 0xFFFFFFFF;
	const _test_iterations& test_iterations =
		(is_triangles_iteration) ? m_test_triangles_iterations : m_test_quads_iterations;
	const unsigned int n_test_iterations = (unsigned int)test_iterations.size();

	for (unsigned int n_test_iteration = 0; n_test_iteration < n_test_iterations; ++n_test_iteration)
	{
		_test_iteration test_iteration = test_iterations[n_test_iteration];

		if (de::abs(test_iteration.inner_tess_levels[0] - inner_tess_levels[0]) < epsilon &&
			de::abs(test_iteration.inner_tess_levels[1] - inner_tess_levels[1]) < epsilon &&
			test_iteration.vertex_ordering == vertex_ordering &&
			test_iteration.n_modified_outer_tess_level == n_modified_outer_tess_level)
		{
			/* Only compare outer tessellation levels that have not been modified */
			if (((n_modified_outer_tess_level == 0) ||
				 (n_modified_outer_tess_level != 0 &&
				  de::abs(test_iteration.outer_tess_levels[0] - outer_tess_levels[0]) < epsilon)) &&
				((n_modified_outer_tess_level == 1) ||
				 (n_modified_outer_tess_level != 1 &&
				  de::abs(test_iteration.outer_tess_levels[1] - outer_tess_levels[1]) < epsilon)) &&
				((n_modified_outer_tess_level == 2) ||
				 (n_modified_outer_tess_level != 2 &&
				  de::abs(test_iteration.outer_tess_levels[2] - outer_tess_levels[2]) < epsilon)) &&
				((n_modified_outer_tess_level == 3) ||
				 (n_modified_outer_tess_level != 3 &&
				  de::abs(test_iteration.outer_tess_levels[3] - outer_tess_levels[3]) < epsilon)))
			{
				result = n_test_iteration;

				break;
			}
		}
	} /* for (all test iterations) */

	return result;
}

/** Retrieves _test_iteration instance specific for user-specified iteration index.
 *
 *  @param n_iteration Iteration index to retrieve _test_iteration instance for.
 *
 * @return Iteration-specific _test_iteration instance.
 *
 **/
TessellationShaderInvarianceRule7Test::_test_iteration& TessellationShaderInvarianceRule7Test::getTestForIteration(
	unsigned int n_iteration)
{
	unsigned int	 n_triangles_tests = (unsigned int)m_test_triangles_iterations.size();
	_test_iteration& test_iteration	= (n_iteration < n_triangles_tests) ?
										  m_test_triangles_iterations[n_iteration] :
										  m_test_quads_iterations[n_iteration - n_triangles_tests];

	return test_iteration;
}

/** Retrieves iteration-specific tessellation properties.
 *
 *  @param n_iteration            Iteration index to retrieve the properties for.
 *  @param out_inner_tess_levels  Deref will be used to store iteration-specific inner
 *                                tessellation level values. Must not be NULL.
 *  @param out_outer_tess_levels  Deref will be used to store iteration-specific outer
 *                                tessellation level values. Must not be NULL.
 *  @param out_point_mode         Deref will be used to store iteration-specific flag
 *                                telling whether point mode should be enabled for given pass.
 *                                Must not be NULL.
 *  @param out_primitive_mode     Deref will be used to store iteration-specific primitive
 *                                mode. Must not be NULL.
 *  @param out_vertex_ordering    Deref will be used to store iteration-specific vertex
 *                                ordering. Must not be NULL.
 *  @param out_result_buffer_size Deref will be used to store amount of bytes XFB buffer object
 *                                storage should offer for the draw call to succeed. Can
 *                                be NULL.
 **/
void TessellationShaderInvarianceRule7Test::getIterationProperties(
	unsigned int n_iteration, float* out_inner_tess_levels, float* out_outer_tess_levels, bool* out_point_mode,
	_tessellation_primitive_mode* out_primitive_mode, _tessellation_shader_vertex_ordering* out_vertex_ordering,
	unsigned int* out_result_buffer_size)
{
	DE_ASSERT(m_test_triangles_iterations.size() + m_test_quads_iterations.size() > n_iteration);

	_test_iteration& test_iteration = getTestForIteration(n_iteration);

	memcpy(out_inner_tess_levels, test_iteration.inner_tess_levels, sizeof(test_iteration.inner_tess_levels));
	memcpy(out_outer_tess_levels, test_iteration.outer_tess_levels, sizeof(test_iteration.outer_tess_levels));

	*out_point_mode		 = false;
	*out_primitive_mode  = test_iteration.primitive_mode;
	*out_vertex_ordering = test_iteration.vertex_ordering;

	if (out_result_buffer_size != DE_NULL)
	{
		*out_result_buffer_size = m_utils_ptr->getAmountOfVerticesGeneratedByTessellator(
			*out_primitive_mode, out_inner_tess_levels, out_outer_tess_levels, TESSELLATION_SHADER_VERTEX_SPACING_EQUAL,
			*out_point_mode);
		test_iteration.n_vertices = *out_result_buffer_size;
		*out_result_buffer_size =
			static_cast<unsigned int>(*out_result_buffer_size * 3 /* components */ * sizeof(float));

		DE_ASSERT(*out_result_buffer_size != 0);
	}
}

/** Retrieves iteration-specific tessellation evaluation shader code.
 *
 *  @param n_iteration Iteration index, for which the source code is being obtained.
 *
 *  @return Requested source code.
 **/
std::string TessellationShaderInvarianceRule7Test::getTECode(unsigned int n_iteration)
{
	DE_ASSERT(m_test_triangles_iterations.size() + m_test_quads_iterations.size() > n_iteration);

	const _test_iteration& test_iteration = getTestForIteration(n_iteration);

	return TessellationShaderUtils::getGenericTECode(TESSELLATION_SHADER_VERTEX_SPACING_EQUAL,
													 test_iteration.primitive_mode, test_iteration.vertex_ordering,
													 false); /* point mode */
}

/** Initializes test iterations for the test. The following modes and inner/outer tess level
 *  configurations are used to form the test set:
 *
 *  - All inner/outer tessellation level combinations as returned by
 *    TessellationShaderUtils::getTessellationLevelSetForPrimitiveMode()
 *    times 3 (for triangles) or 4 (for quads). For each combination,
 *    the test will capture tessellation coordinates multiple times, each
 *    time changing a different outer tessellation level value and leaving
 *    the rest intact.
 *  - All primitive modes;
 *  - All vertex spacing modes;
 *
 *  All permutations are used to generate the test set.
 **/
void TessellationShaderInvarianceRule7Test::initTestIterations()
{
	DE_ASSERT(m_test_quads_iterations.size() == 0 && m_test_triangles_iterations.size() == 0);

	/* Retrieve GL_MAX_TESS_GEN_LEVEL_EXT value */
	const glw::Functions& gl						  = m_context.getRenderContext().getFunctions();
	glw::GLint			  gl_max_tess_gen_level_value = 0;

	gl.getIntegerv(m_glExtTokens.MAX_TESS_GEN_LEVEL, &gl_max_tess_gen_level_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_TESS_GEN_LEVEL_EXT pname");

	/* Iterate through all primitive and vertex spacing modes relevant to the test */
	_tessellation_primitive_mode primitive_modes[] = { TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS,
													   TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES };
	_tessellation_shader_vertex_ordering vo_modes[] = {
		TESSELLATION_SHADER_VERTEX_ORDERING_CCW, TESSELLATION_SHADER_VERTEX_ORDERING_CW,
	};

	const unsigned int n_primitive_modes = sizeof(primitive_modes) / sizeof(primitive_modes[0]);
	const unsigned int n_vo_modes		 = sizeof(vo_modes) / sizeof(vo_modes[0]);

	for (unsigned int n_primitive_mode = 0; n_primitive_mode < n_primitive_modes; ++n_primitive_mode)
	{
		_tessellation_primitive_mode primitive_mode = primitive_modes[n_primitive_mode];
		const unsigned int			 n_relevant_outer_tess_levels =
			(primitive_mode == TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS) ? 4 : 3;

		for (unsigned int n_vo_mode = 0; n_vo_mode < n_vo_modes; ++n_vo_mode)
		{
			_tessellation_shader_vertex_ordering vertex_ordering = vo_modes[n_vo_mode];

			/* Retrieve inner/outer tessellation level combinations we want the tests to be run for */
			_tessellation_levels_set levels_set;

			levels_set = TessellationShaderUtils::getTessellationLevelSetForPrimitiveMode(
				primitive_mode, gl_max_tess_gen_level_value,
				TESSELLATION_LEVEL_SET_FILTER_ALL_LEVELS_USE_THE_SAME_VALUE);

			/* Create test descriptor for all inner/outer level configurations we received from the utils function. */
			for (_tessellation_levels_set_const_iterator levels_set_iterator = levels_set.begin();
				 levels_set_iterator != levels_set.end(); levels_set_iterator++)
			{
				const _tessellation_levels& levels = *levels_set_iterator;

				for (unsigned int n_outer_level_to_change = 0;
					 n_outer_level_to_change < n_relevant_outer_tess_levels + 1 /* base iteration */;
					 ++n_outer_level_to_change)
				{
					/* Create a test descriptor for all the parameters we now have */
					_test_iteration test;

					memcpy(test.inner_tess_levels, levels.inner, sizeof(test.inner_tess_levels));
					memcpy(test.outer_tess_levels, levels.outer, sizeof(test.outer_tess_levels));

					test.primitive_mode  = primitive_mode;
					test.vertex_ordering = vertex_ordering;

					/* Change iteration-specific outer tessellation level to a different value, but only
					 * if we're not preparing a base iteration*/
					if (n_outer_level_to_change != n_relevant_outer_tess_levels)
					{
						test.n_modified_outer_tess_level				= n_outer_level_to_change;
						test.outer_tess_levels[n_outer_level_to_change] = (float)(gl_max_tess_gen_level_value) / 3.0f;
					}
					else
					{
						test.is_base_iteration = true;
					}

					if (primitive_mode == TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES)
					{
						m_test_triangles_iterations.push_back(test);
					}
					else
					{
						m_test_quads_iterations.push_back(test);
					}
				}
			} /* for (all levels set entries) */
		}	 /* for (all vertex spacing modes) */
	}		  /* for (all primitive modes) */
}

/** Tells whether a triangle is included in user-provided set of triangles.
 *  The triangle is expected to use an undefined vertex ordering.
 *
 *  @param base_triangle_data     9 FP values defining 3 vertices of a triangle.
 *  @param vertex_data            Vertex stream. It is expected these vertices
 *                                form triangles. It is also assumed each vertex
 *                                is expressed with 3 components.
 *  @param vertex_data_n_vertices Amount of vertices that can be found in @param
 *                                vertex_data
 *
 *  @return true if the triangle was found in user-provided triangle set,
 *          false otherwise.
 *
 **/
bool TessellationShaderInvarianceRule7Test::isTriangleDefinedInVertexDataSet(const float* base_triangle_data,
																			 const float* vertex_data,
																			 unsigned int vertex_data_n_vertices)
{
	bool result = false;

	for (unsigned int n_triangle = 0; n_triangle < vertex_data_n_vertices / 3 /* vertices per triangle */; n_triangle++)
	{
		const float* current_triangle_data = vertex_data +
											 n_triangle * 3 * /* vertices per triangle */
												 3;			  /* components */

		if (TessellationShaderUtils::isTriangleDefined(current_triangle_data, base_triangle_data))
		{
			result = true;

			break;
		}
	} /* for (all vertices) */

	return result;
}

/** Verifies result data. Accesses data generated by all iterations.
 *
 *  Throws TestError exception if an error occurs.
 *
 *  @param all_iterations_data An array of pointers to buffers, holding gl_TessCoord
 *                             data generated by subsequent iterations.
 **/
void TessellationShaderInvarianceRule7Test::verifyResultData(const void** all_iterations_data)
{
	const float epsilon = 1e-5f;

	/* Run two separate iterations:
	 *
	 * a) triangles
	 * b) quads
	 */
	for (unsigned int n_iteration = 0; n_iteration < 2 /* triangles, quads */; ++n_iteration)
	{
		bool			   is_triangles_iteration = (n_iteration == 0);
		const unsigned int n_base_iteration =
			(n_iteration == 0) ? 0 : (unsigned int)m_test_triangles_iterations.size();
		const unsigned int n_relevant_outer_tess_levels = (is_triangles_iteration) ? 3 : 4;

		_tessellation_primitive_mode primitive_mode = (n_iteration == 0) ?
														  TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES :
														  TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS;

		const _test_iterations& test_iterations =
			(n_iteration == 0) ? m_test_triangles_iterations : m_test_quads_iterations;

		DE_ASSERT(test_iterations.size() != 0);

		/* Find a base iteration first */
		for (unsigned int n_base_test_iteration = 0; n_base_test_iteration < test_iterations.size();
			 n_base_test_iteration++)
		{
			const _test_iteration& base_iteration = test_iterations[n_base_test_iteration];
			std::vector<int>	   ref_iteration_indices;

			if (!base_iteration.is_base_iteration)
			{
				continue;
			}

			/* Retrieve reference test iterations */
			for (unsigned int n_reference_iteration = 0; n_reference_iteration < n_relevant_outer_tess_levels;
				 ++n_reference_iteration)
			{
				const unsigned int n_modified_outer_tess_level =
					(base_iteration.n_modified_outer_tess_level + n_reference_iteration + 1) %
					n_relevant_outer_tess_levels;
				const unsigned int ref_iteration_index = getTestIterationIndex(
					is_triangles_iteration, base_iteration.inner_tess_levels, base_iteration.outer_tess_levels,
					base_iteration.vertex_ordering, n_modified_outer_tess_level);

				DE_ASSERT(ref_iteration_index != 0xFFFFFFFF);
				DE_ASSERT(ref_iteration_index != n_base_test_iteration);

				ref_iteration_indices.push_back(ref_iteration_index);
			}

			/* We can now start comparing base data with the information generated for
			 * reference iterations. */
			for (std::vector<int>::const_iterator ref_iteration_iterator = ref_iteration_indices.begin();
				 ref_iteration_iterator != ref_iteration_indices.end(); ref_iteration_iterator++)
			{
				const int&			   n_ref_test_iteration = *ref_iteration_iterator;
				const _test_iteration& ref_iteration		= test_iterations[n_ref_test_iteration];

				/* Now move through all triangles generated for base test iteration. Focus on the ones
				 * that connect the outer edge with one of the inner ones */
				const float* base_iteration_vertex_data =
					(const float*)all_iterations_data[n_base_iteration + n_base_test_iteration];
				const float* ref_iteration_vertex_data =
					(const float*)all_iterations_data[n_base_iteration + n_ref_test_iteration];

				for (unsigned int n_base_triangle = 0;
					 n_base_triangle < base_iteration.n_vertices / 3; /* vertices per triangle */
					 ++n_base_triangle)
				{
					const float* base_triangle_data =
						base_iteration_vertex_data + n_base_triangle * 3 /* vertices */ * 3; /* components */

					/* Is that the triangle type we're after? */
					const float* base_triangle_vertex1 = base_triangle_data;
					const float* base_triangle_vertex2 = base_triangle_vertex1 + 3; /* components */
					const float* base_triangle_vertex3 = base_triangle_vertex2 + 3; /* components */
					bool		 is_base_triangle_vertex1_outer =
						TessellationShaderUtils::isOuterEdgeVertex(primitive_mode, base_triangle_vertex1);
					bool is_base_triangle_vertex2_outer =
						TessellationShaderUtils::isOuterEdgeVertex(primitive_mode, base_triangle_vertex2);
					bool is_base_triangle_vertex3_outer =
						TessellationShaderUtils::isOuterEdgeVertex(primitive_mode, base_triangle_vertex3);
					unsigned int n_outer_edge_vertices_found = 0;

					n_outer_edge_vertices_found += (is_base_triangle_vertex1_outer == true);
					n_outer_edge_vertices_found += (is_base_triangle_vertex2_outer == true);
					n_outer_edge_vertices_found += (is_base_triangle_vertex3_outer == true);

					if (n_outer_edge_vertices_found == 0)
					{
						/* This is an inner triangle, not really of our interest */
						continue;
					}

					/* Which outer tessellation level describes the base data edge? */
					unsigned int n_base_tess_level = 0;

					if (primitive_mode == TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES)
					{
						if ((!is_base_triangle_vertex1_outer ||
							 (is_base_triangle_vertex1_outer && base_triangle_vertex1[0] == 0.0f)) &&
							(!is_base_triangle_vertex2_outer ||
							 (is_base_triangle_vertex2_outer && base_triangle_vertex2[0] == 0.0f)) &&
							(!is_base_triangle_vertex3_outer ||
							 (is_base_triangle_vertex3_outer && base_triangle_vertex3[0] == 0.0f)))
						{
							n_base_tess_level = 0;
						}
						else if ((!is_base_triangle_vertex1_outer ||
								  (is_base_triangle_vertex1_outer && base_triangle_vertex1[1] == 0.0f)) &&
								 (!is_base_triangle_vertex2_outer ||
								  (is_base_triangle_vertex2_outer && base_triangle_vertex2[1] == 0.0f)) &&
								 (!is_base_triangle_vertex3_outer ||
								  (is_base_triangle_vertex3_outer && base_triangle_vertex3[1] == 0.0f)))
						{
							n_base_tess_level = 1;
						}
						else
						{
							DE_ASSERT((!is_base_triangle_vertex1_outer ||
									   (is_base_triangle_vertex1_outer && base_triangle_vertex1[2] == 0.0f)) &&
									  (!is_base_triangle_vertex2_outer ||
									   (is_base_triangle_vertex2_outer && base_triangle_vertex2[2] == 0.0f)) &&
									  (!is_base_triangle_vertex3_outer ||
									   (is_base_triangle_vertex3_outer && base_triangle_vertex3[2] == 0.0f)));

							n_base_tess_level = 2;
						}
					} /* if (primitive_mode == TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES) */
					else
					{
						DE_ASSERT(primitive_mode == TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS);

						std::size_t				  n_outer_edge_vertices = 0;
						std::vector<const float*> outer_edge_vertices;

						if (is_base_triangle_vertex1_outer)
						{
							outer_edge_vertices.push_back(base_triangle_vertex1);
						}

						if (is_base_triangle_vertex2_outer)
						{
							outer_edge_vertices.push_back(base_triangle_vertex2);
						}

						if (is_base_triangle_vertex3_outer)
						{
							outer_edge_vertices.push_back(base_triangle_vertex3);
						}

						n_outer_edge_vertices = outer_edge_vertices.size();

						DE_ASSERT(n_outer_edge_vertices >= 1 && n_outer_edge_vertices <= 2);

						bool is_top_outer_edge	= true;
						bool is_right_outer_edge  = true;
						bool is_bottom_outer_edge = true;
						bool is_left_outer_edge   = true;

						/* Find which outer edges the vertices don't belong to. If one is in a corner,
						 * the other will clarify to which edge both vertices belong. */
						for (unsigned int n_vertex = 0; n_vertex < n_outer_edge_vertices; ++n_vertex)
						{
							/* Y < 1, not top outer edge */
							if (de::abs(outer_edge_vertices[n_vertex][1] - 1.0f) > epsilon)
							{
								is_top_outer_edge = false;
							}

							/* X < 1, not right outer edge */
							if (de::abs(outer_edge_vertices[n_vertex][0] - 1.0f) > epsilon)
							{
								is_right_outer_edge = false;
							}

							/* Y > 0, not bottom outer edge */
							if (de::abs(outer_edge_vertices[n_vertex][1]) > epsilon)
							{
								is_bottom_outer_edge = false;
							}

							/* X > 0, not left outer edge */
							if (de::abs(outer_edge_vertices[n_vertex][0]) > epsilon)
							{
								is_left_outer_edge = false;
							}
						}

						if (n_outer_edge_vertices == 1)
						{
							/* A single vertex with corner-coordinates belongs to two edges. Choose one */
							bool x_is_0 = de::abs(outer_edge_vertices[0][0]) < epsilon;
							bool x_is_1 = de::abs(outer_edge_vertices[0][0] - 1.0f) < epsilon;
							bool y_is_0 = de::abs(outer_edge_vertices[0][1]) < epsilon;
							bool y_is_1 = de::abs(outer_edge_vertices[0][1] - 1.0f) < epsilon;

							if (x_is_0 && y_is_0)
							{
								/* bottom edge */
								DE_ASSERT(is_left_outer_edge && is_bottom_outer_edge);
								is_left_outer_edge = false;
							}
							else if (x_is_0 && y_is_1)
							{
								/* left edge */
								DE_ASSERT(is_left_outer_edge && is_top_outer_edge);
								is_top_outer_edge = false;
							}
							else if (x_is_1 && y_is_0)
							{
								/* right edge */
								DE_ASSERT(is_right_outer_edge && is_bottom_outer_edge);
								is_bottom_outer_edge = false;
							}
							else if (x_is_1 && y_is_1)
							{
								/* top edge */
								DE_ASSERT(is_right_outer_edge && is_top_outer_edge);
								is_right_outer_edge = false;
							}
							else
							{
								/* Not a corner vertex, only one of the edge-flags is set */
							}
						}

						/* Sanity checks */
						DE_UNREF(is_top_outer_edge);
						DE_ASSERT((is_left_outer_edge && !is_top_outer_edge && !is_bottom_outer_edge &&
								   !is_right_outer_edge) ||
								  (!is_left_outer_edge && is_top_outer_edge && !is_bottom_outer_edge &&
								   !is_right_outer_edge) ||
								  (!is_left_outer_edge && !is_top_outer_edge && is_bottom_outer_edge &&
								   !is_right_outer_edge) ||
								  (!is_left_outer_edge && !is_top_outer_edge && !is_bottom_outer_edge &&
								   is_right_outer_edge));

						/* We have all the data needed to determine which tessellation level describes
						 * subdivision of the edge that the triangle touches */
						if (is_left_outer_edge)
						{
							n_base_tess_level = 0;
						}
						else if (is_bottom_outer_edge)
						{
							n_base_tess_level = 1;
						}
						else if (is_right_outer_edge)
						{
							n_base_tess_level = 2;
						}
						else
						{
							n_base_tess_level = 3;
						}
					}

					/* We shouldn't perform the check if the edge we're processing was described
					 * by a different outer tessellation level in the reference data set */
					if (n_base_tess_level == ref_iteration.n_modified_outer_tess_level)
					{
						continue;
					}

					/* This triangle should be present in both vertex data sets */
					if (!isTriangleDefinedInVertexDataSet(base_triangle_data, ref_iteration_vertex_data,
														  ref_iteration.n_vertices))
					{
						const char* primitive_mode_str = (is_triangles_iteration) ? "triangles" : "quads";

						m_testCtx.getLog()
							<< tcu::TestLog::Message << "For primitive mode [" << primitive_mode_str << "] "
							<< ", inner tessellation levels:"
							<< "[" << base_iteration.inner_tess_levels[0] << ", " << base_iteration.inner_tess_levels[1]
							<< "], outer tessellation levels:"
							<< "[" << base_iteration.outer_tess_levels[0] << ", " << base_iteration.outer_tess_levels[1]
							<< ", " << base_iteration.outer_tess_levels[2] << ", "
							<< base_iteration.outer_tess_levels[3] << "], a triangle connecting inner & outer edges:"
							<< "[" << base_triangle_vertex1[0] << ", " << base_triangle_vertex1[1] << ", "
							<< base_triangle_vertex1[2] << "]x"
							<< "[" << base_triangle_vertex2[0] << ", " << base_triangle_vertex2[1] << ", "
							<< base_triangle_vertex2[2] << "]x"
							<< "[" << base_triangle_vertex3[0] << ", " << base_triangle_vertex3[1] << ", "
							<< base_triangle_vertex3[2] << "] was not found for runs using CW and CCW vertex ordering, "
														   "which is against the extension specification's rule 7."
							<< tcu::TestLog::EndMessage;

						TCU_FAIL("Implementation is not conformant with Tessellation Rule 7");
					}
				} /* for (all triangles generated for base test iteration) */
			}	 /* for (all reference iterations) */
		}		  /* for (all base test iterations) */
	}			  /* for (both primitive types) */
}

} /* namespace glcts */