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

namespace glcts
{

/** Constructor
 *
 * @param context Test context
 **/
TessellationShaderQuadsTests::TessellationShaderQuadsTests(glcts::Context& context, const ExtParameters& extParams)
	: TestCaseGroupBase(context, extParams, "tessellation_shader_quads_tessellation",
						"Verifies quad tessellation functionality")
{
	/* No implementation needed */
}

/**
 * Initializes test groups for geometry shader tests
 **/
void TessellationShaderQuadsTests::init(void)
{
	addChild(new glcts::TessellationShaderQuadsDegenerateCase(m_context, m_extParams));
	addChild(new glcts::TessellationShaderQuadsInnerTessellationLevelRounding(m_context, m_extParams));
}

/** Constructor
 *
 * @param context Test context
 **/
TessellationShaderQuadsDegenerateCase::TessellationShaderQuadsDegenerateCase(Context&			  context,
																			 const ExtParameters& extParams)
	: TestCaseBase(context, extParams, "degenerate_case",
				   "Verifies that only a single triangle pair covering the outer rectangle"
				   " is generated, if both clamped inner and outer tessellation levels are "
				   "set to one.")
	, m_vao_id(0)
	, m_utils(DE_NULL)
{
	/* Left blank on purpose */
}

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

	/* Call base class' deinit() */
	TestCaseBase::deinit();

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

	/* Deinitialize utils instance */
	if (m_utils != DE_NULL)
	{
		delete m_utils;

		m_utils = DE_NULL;
	}

	/* Delete vertex array object */
	if (m_vao_id != 0)
	{
		gl.deleteVertexArrays(1, &m_vao_id);

		m_vao_id = 0;
	}
}

/** Initializes ES objects necessary to run the test. */
void TessellationShaderQuadsDegenerateCase::initTest()
{
	/* Skip if required extensions are not supported. */
	if (!m_is_tessellation_shader_supported)
	{
		throw tcu::NotSupportedError(TESSELLATION_SHADER_EXTENSION_NOT_SUPPORTED);
	}

	/* Initialize Utils instance */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	m_utils = new TessellationShaderUtils(gl, this);

	/* Initialize vertex array object */
	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!");

	/* Retrieve GL_MAX_TESS_GEN_LEVEL_EXT value */
	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() call failed for GL_MAX_TESS_GEN_LEVEL_EXT pname");

	/* Initialize all test runs */
	const glw::GLint   tess_levels[] = { -gl_max_tess_gen_level_value / 2, -1, 1 };
	const unsigned int n_tess_levels = sizeof(tess_levels) / sizeof(tess_levels[0]);

	const _tessellation_shader_vertex_spacing vs_modes[] = {
		/* NOTE: We do not check "fractional even" vertex spacing since it will always
		 *       clamp to 2 which is out of scope for this test.
		 */
		TESSELLATION_SHADER_VERTEX_SPACING_DEFAULT,
		TESSELLATION_SHADER_VERTEX_SPACING_EQUAL, TESSELLATION_SHADER_VERTEX_SPACING_FRACTIONAL_ODD
	};
	const unsigned int n_vs_modes = sizeof(vs_modes) / sizeof(vs_modes[0]);

	/* Iterate through all vertex spacing modes */
	bool has_failed = false;

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

		/* Iterate through all values that should be used for irrelevant tessellation levels */
		for (unsigned int n_tess_level = 0; n_tess_level < n_tess_levels; ++n_tess_level)
		{
			const glw::GLint tess_level = tess_levels[n_tess_level];

			/* Set up the run descriptor.
			 *
			 * Round outer tesellation levels to 1 if necessary, since otherwise no geometry will
			 * be generated.
			 **/
			_run run;

			run.inner[0]	   = (float)tess_level;
			run.inner[1]	   = (float)tess_level;
			run.outer[0]	   = (float)((tess_level < 0) ? 1 : tess_level);
			run.outer[1]	   = (float)((tess_level < 0) ? 1 : tess_level);
			run.outer[2]	   = (float)((tess_level < 0) ? 1 : tess_level);
			run.outer[3]	   = (float)((tess_level < 0) ? 1 : tess_level);
			run.vertex_spacing = vs_mode;

			/* Retrieve vertex data for both passes */
			run.n_vertices = m_utils->getAmountOfVerticesGeneratedByTessellator(
				TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS, run.inner, run.outer, run.vertex_spacing,
				false); /* is_point_mode_enabled */

			if (run.n_vertices == 0)
			{
				std::string vs_mode_string = TessellationShaderUtils::getESTokenForVertexSpacingMode(vs_mode);

				m_testCtx.getLog() << tcu::TestLog::Message << "No vertices were generated by tessellator for: "
															   "inner tess levels:"
															   "["
								   << run.inner[0] << ", " << run.inner[1] << "]"
																			  ", outer tess levels:"
																			  "["
								   << run.outer[0] << ", " << run.outer[1] << ", " << run.outer[2] << ", "
								   << run.outer[3] << "]"
													  ", primitive mode: quads, "
													  "vertex spacing: "
								   << vs_mode_string << tcu::TestLog::EndMessage;

				has_failed = true;
			}
			else
			{
				/* Retrieve the data buffers */
				run.data = m_utils->getDataGeneratedByTessellator(run.inner, false, /* is_point_mode_enabled */
																  TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS,
																  TESSELLATION_SHADER_VERTEX_ORDERING_CCW,
																  run.vertex_spacing, run.outer);
			}

			/* Store the run data */
			m_runs.push_back(run);
		} /* for (all tessellation levels) */
	}	 /* for (all vertex spacing modes) */

	if (has_failed)
	{
		TCU_FAIL("Zero vertices were generated by tessellator for at least one run which is not "
				 "a correct behavior");
	}
}

/** 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 TessellationShaderQuadsDegenerateCase::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 the test */
	initTest();

	/* Iterate through all runs */

	/* The test fails if any of the runs did not generate exactly 6 coordinates */
	for (_runs_const_iterator run_iterator = m_runs.begin(); run_iterator != m_runs.end(); run_iterator++)
	{
		const _run& run = *run_iterator;

		if (run.n_vertices != (2 /* triangles */ * 3 /* vertices */))
		{
			std::string vs_mode_string = TessellationShaderUtils::getESTokenForVertexSpacingMode(run.vertex_spacing);

			m_testCtx.getLog() << tcu::TestLog::Message << "Invalid number of coordinates (" << run.n_vertices
							   << ", instead of 6)"
								  " was generated for the following tessellation configuration: "
								  "primitive mode:quads, "
								  "vertex spacing mode:"
							   << vs_mode_string << " inner tessellation levels:" << run.inner[0] << ", "
							   << run.inner[1] << " outer tessellation levels:" << run.outer[0] << ", " << run.outer[1]
							   << ", " << run.outer[2] << ", " << run.outer[3] << tcu::TestLog::EndMessage;

			TCU_FAIL("Invalid number of coordinates was generated for at least one run");
		}
	} /* for (all runs) */

	/* All runs should generate exactly the same set of triangles.
	 *
	 * Note: we must not assume any specific vertex ordering, so we cannot
	 *       just do a plain memcmp() here.
	 */
	const _run& base_run = *m_runs.begin();

	for (unsigned int n_triangle = 0; n_triangle < base_run.n_vertices / 3 /* vertices per triangle */; n_triangle++)
	{
		const float* base_triangle_data = (const float*)(&base_run.data[0]) +
										  3		  /* vertices per triangle */
											  * 3 /* components */
											  * n_triangle;

		for (_runs_const_iterator ref_run_iterator = m_runs.begin() + 1; ref_run_iterator != m_runs.end();
			 ref_run_iterator++)
		{
			const _run& ref_run = *ref_run_iterator;

			const float* ref_triangle_data1 = (const float*)(&ref_run.data[0]);
			const float* ref_triangle_data2 =
				(const float*)(&ref_run.data[0]) + 3 /* vertices per triangle */ * 3 /* components */;

			if (!TessellationShaderUtils::isTriangleDefined(base_triangle_data, ref_triangle_data1) &&
				!TessellationShaderUtils::isTriangleDefined(base_triangle_data, ref_triangle_data2))
			{
				std::string base_vs_mode_string =
					TessellationShaderUtils::getESTokenForVertexSpacingMode(base_run.vertex_spacing);
				std::string ref_vs_mode_string =
					TessellationShaderUtils::getESTokenForVertexSpacingMode(ref_run.vertex_spacing);

				m_testCtx.getLog() << tcu::TestLog::Message
								   << "Reference run does not contain a triangle found in a base run"
									  " generated for the following tessellation configuration: "
									  "primitive mode:quads, "
									  "base vertex spacing mode:"
								   << base_vs_mode_string << " base inner tessellation levels:" << base_run.inner[0]
								   << ", " << base_run.inner[1]
								   << " base outer tessellation levels:" << base_run.outer[0] << ", "
								   << base_run.outer[1] << ", " << base_run.outer[2] << ", " << base_run.outer[3]
								   << "reference vertex spacing mode:" << ref_vs_mode_string
								   << " reference inner tessellation levels:" << ref_run.inner[0] << ", "
								   << ref_run.inner[1] << " reference outer tessellation levels:" << ref_run.outer[0]
								   << ", " << ref_run.outer[1] << ", " << ref_run.outer[2] << ", " << ref_run.outer[3]
								   << tcu::TestLog::EndMessage;

				TCU_FAIL("Reference run does not contain a triangle found in a base run");
			}
		} /* for (all reference runs) */
	}	 /* for (all triangles) */

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

/** Constructor
 *
 * @param context Test context
 **/
TessellationShaderQuadsInnerTessellationLevelRounding::TessellationShaderQuadsInnerTessellationLevelRounding(
	Context& context, const ExtParameters& extParams)
	: TestCaseBase(context, extParams, "inner_tessellation_level_rounding",
				   "Verifies that either inner tessellation level is rounded to 2 or 3,"
				   " when the tessellator is run in quads primitive mode and "
				   "corresponding inner tessellation level is set to 1.")
	, m_vao_id(0)
	, m_utils(DE_NULL)
{
	/* Left blank on purpose */
}

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

	/* Call base class' deinit() */
	TestCaseBase::deinit();

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

	/* Deinitialize utils instance */
	if (m_utils != DE_NULL)
	{
		delete m_utils;

		m_utils = DE_NULL;
	}

	/* Delete vertex array object */
	if (m_vao_id != 0)
	{
		gl.deleteVertexArrays(1, &m_vao_id);

		m_vao_id = 0;
	}
}

/** Takes a vertex data set and returns a vector of unique vec2s found in the set.
 *
 *  @param raw_data            Vertex data set to process.
 *  @param n_raw_data_vertices Amount of 3-component vertices found under @param raw_data.
 *
 *  @return As per description.
 **/
std::vector<_vec2> TessellationShaderQuadsInnerTessellationLevelRounding::getUniqueTessCoordinatesFromVertexDataSet(
	const float* raw_data, const unsigned int n_raw_data_vertices)
{
	std::vector<_vec2> result;

	for (unsigned int n_vertex = 0; n_vertex < n_raw_data_vertices; n_vertex += 2)
	{
		const float* vertex_data = raw_data + n_vertex * 3 /* components */;
		_vec2		 vertex(vertex_data[0], vertex_data[1]);

		if (std::find(result.begin(), result.end(), vertex) == result.end())
		{
			result.push_back(vertex);
		}

	} /* for (all vertices) */

	return result;
}

/** Initializes ES objects necessary to run the test. */
void TessellationShaderQuadsInnerTessellationLevelRounding::initTest()
{
	/* Skip if required extensions are not supported. */
	if (!m_is_tessellation_shader_supported)
	{
		throw tcu::NotSupportedError(TESSELLATION_SHADER_EXTENSION_NOT_SUPPORTED);
	}

	/* Initialize Utils instance */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	m_utils = new TessellationShaderUtils(gl, this);

	/* Initialize vertex array object */
	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!");

	/* Retrieve GL_MAX_TESS_GEN_LEVEL_EXT value */
	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() call failed for GL_MAX_TESS_GEN_LEVEL_EXT pname");

	/* Initialize all test runs */
	const glw::GLint tess_levels[] = { 2, gl_max_tess_gen_level_value / 2, gl_max_tess_gen_level_value };

	const glw::GLint tess_levels_odd[] = { 2 + 1, gl_max_tess_gen_level_value / 2 + 1,
										   gl_max_tess_gen_level_value - 1 };
	const unsigned int n_tess_levels = sizeof(tess_levels) / sizeof(tess_levels[0]);

	const _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_vs_modes = sizeof(vs_modes) / sizeof(vs_modes[0]);

	/* Iterate through all vertex spacing modes */
	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];

		/* Iterate through all values that should be used for irrelevant tessellation levels */
		for (unsigned int n_tess_level = 0; n_tess_level < n_tess_levels; ++n_tess_level)
		{
			/* We need to test two cases in this test:
			 *
			 * a) inner[0] is set to 1 for set A and, for set B, to the value we're expecting the level to
			 *    round, given the vertex spacing mode. inner[1] is irrelevant.
			 * b) inner[0] is irrelevant. inner[1] is set to 1 for set A and, for set B, to the value we're
			 *    expecting the level to round, given the vertex spacing mode.
			 */
			for (unsigned int n_inner_tess_level_combination = 0;
				 n_inner_tess_level_combination < 2; /* inner[0], inner[1] */
				 ++n_inner_tess_level_combination)
			{
				/* Set up the run descriptor */
				glw::GLint tess_level = (vs_mode == TESSELLATION_SHADER_VERTEX_SPACING_FRACTIONAL_ODD) ?
											tess_levels_odd[n_tess_level] :
											tess_levels[n_tess_level];
				_run run;

				/* Determine inner tessellation level values for two cases */
				switch (n_inner_tess_level_combination)
				{
				case 0:
				{
					run.set1_inner[0] = 1.0f;
					run.set1_inner[1] = (glw::GLfloat)tess_level;
					run.set2_inner[1] = (glw::GLfloat)tess_level;

					TessellationShaderUtils::getTessellationLevelAfterVertexSpacing(
						vs_mode, run.set1_inner[0] + 1.0f /* epsilon */, gl_max_tess_gen_level_value,
						DE_NULL, /* out_clamped */
						run.set2_inner);
					break;
				} /* case 0: */

				case 1:
				{
					run.set1_inner[0] = (glw::GLfloat)tess_level;
					run.set1_inner[1] = 1.0f;
					run.set2_inner[0] = (glw::GLfloat)tess_level;

					TessellationShaderUtils::getTessellationLevelAfterVertexSpacing(
						vs_mode, run.set1_inner[1] + 1.0f /* epsilon */, gl_max_tess_gen_level_value,
						DE_NULL, /* out_clamped */
						run.set2_inner + 1);
					break;
				} /* case 1: */

				default:
					TCU_FAIL("Invalid inner tessellation level combination index");
				} /* switch (n_inner_tess_level_combination) */

				/* Configure outer tessellation level values */
				run.set1_outer[0] = (glw::GLfloat)tess_level;
				run.set2_outer[0] = (glw::GLfloat)tess_level;
				run.set1_outer[1] = (glw::GLfloat)tess_level;
				run.set2_outer[1] = (glw::GLfloat)tess_level;
				run.set1_outer[2] = (glw::GLfloat)tess_level;
				run.set2_outer[2] = (glw::GLfloat)tess_level;
				run.set1_outer[3] = (glw::GLfloat)tess_level;
				run.set2_outer[3] = (glw::GLfloat)tess_level;

				/* Set up remaining run properties */
				run.vertex_spacing = vs_mode;

				/* Retrieve vertex data for both passes */
				glw::GLint n_set1_vertices = 0;
				glw::GLint n_set2_vertices = 0;

				n_set1_vertices = m_utils->getAmountOfVerticesGeneratedByTessellator(
					TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS, run.set1_inner, run.set1_outer, run.vertex_spacing,
					false); /* is_point_mode_enabled */
				n_set2_vertices = m_utils->getAmountOfVerticesGeneratedByTessellator(
					TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS, run.set2_inner, run.set2_outer, run.vertex_spacing,
					false); /* is_point_mode_enabled */

				if (n_set1_vertices == 0)
				{
					std::string vs_mode_string = TessellationShaderUtils::getESTokenForVertexSpacingMode(vs_mode);

					m_testCtx.getLog() << tcu::TestLog::Message << "No vertices were generated by tessellator for: "
																   "inner tess levels:"
																   "["
									   << run.set1_inner[0] << ", " << run.set1_inner[1] << "]"
																							", outer tess levels:"
																							"["
									   << run.set1_outer[0] << ", " << run.set1_outer[1] << ", " << run.set1_outer[2]
									   << ", " << run.set1_outer[3] << "]"
																	   ", primitive mode: quads, "
																	   "vertex spacing: "
									   << vs_mode_string << tcu::TestLog::EndMessage;

					TCU_FAIL("Zero vertices were generated by tessellator for first test pass");
				}

				if (n_set2_vertices == 0)
				{
					std::string vs_mode_string = TessellationShaderUtils::getESTokenForVertexSpacingMode(vs_mode);

					m_testCtx.getLog() << tcu::TestLog::Message << "No vertices were generated by tessellator for: "
																   "inner tess levels:"
																   "["
									   << run.set2_inner[0] << ", " << run.set2_inner[1] << "]"
																							", outer tess levels:"
																							"["
									   << run.set2_outer[0] << ", " << run.set2_outer[1] << ", " << run.set2_outer[2]
									   << ", " << run.set2_outer[3] << "]"
																	   ", primitive mode: quads, "
																	   "vertex spacing: "
									   << vs_mode_string << tcu::TestLog::EndMessage;

					TCU_FAIL("Zero vertices were generated by tessellator for second test pass");
				}

				if (n_set1_vertices != n_set2_vertices)
				{
					std::string vs_mode_string = TessellationShaderUtils::getESTokenForVertexSpacingMode(vs_mode);

					m_testCtx.getLog() << tcu::TestLog::Message
									   << "Amount of vertices generated by the tessellator differs"
										  " for the following inner/outer configs: "
										  "inner tess levels:"
										  "["
									   << run.set1_inner[0] << ", " << run.set1_inner[1] << "]"
																							", outer tess levels:"
																							"["
									   << run.set1_outer[0] << ", " << run.set1_outer[1] << ", " << run.set1_outer[2]
									   << ", " << run.set1_outer[3] << "]"
																	   " and inner tess levels:"
																	   "["
									   << run.set2_inner[0] << ", " << run.set2_inner[1] << "]"
																							", outer tess levels:"
																							"["
									   << run.set2_outer[0] << ", " << run.set2_outer[1] << ", " << run.set2_outer[2]
									   << ", " << run.set2_outer[3] << "]"
																	   ", primitive mode: quads, vertex spacing: "
									   << vs_mode_string << tcu::TestLog::EndMessage;

					TCU_FAIL("Amount of vertices generated by tessellator differs between base and references passes");
				}

				/* Store the amount of vertices in run properties */
				run.n_vertices = n_set1_vertices;

				/* Retrieve the data buffers */
				run.set1_data = m_utils->getDataGeneratedByTessellator(
					run.set1_inner, false, /* is_point_mode_enabled */
					TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS, TESSELLATION_SHADER_VERTEX_ORDERING_CCW,
					run.vertex_spacing, run.set1_outer);
				run.set2_data = m_utils->getDataGeneratedByTessellator(
					run.set2_inner, false, /* is_point_mode_enabled */
					TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS, TESSELLATION_SHADER_VERTEX_ORDERING_CCW,
					run.vertex_spacing, run.set2_outer);

				/* Store the run data */
				m_runs.push_back(run);
			} /* for (all inner tess level combinations) */
		}	 /* for (all sets) */
	}		  /* for (all vertex spacing modes) */
}

/** 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 TessellationShaderQuadsInnerTessellationLevelRounding::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 the test */
	initTest();

	/* Iterate through all runs */

	for (_runs_const_iterator run_iterator = m_runs.begin(); run_iterator != m_runs.end(); run_iterator++)
	{
		const _run& run = *run_iterator;

		if (run.vertex_spacing != TESSELLATION_SHADER_VERTEX_SPACING_FRACTIONAL_ODD)
		{
			/* Make sure the vertex data generated for two passes matches */
			const glw::GLint n_triangles = run.n_vertices / 3 /* vertices per triangle */;

			std::vector<bool> triangleMatched;
			triangleMatched.assign(n_triangles, false);

			for (int n_triangle = 0; n_triangle < n_triangles; ++n_triangle)
			{
				const float* triangle_a = (const float*)(&run.set1_data[0]) +
										  n_triangle * 3 /* vertices */
											  * 3;		 /* components */
				/* Look up matching triangle */
				bool triangleFound = false;

				for (int n_triangle_b = 0; n_triangle_b < n_triangles; ++n_triangle_b)
				{
					if (!triangleMatched[n_triangle_b])
					{
						const float* triangle_b = (const float*)(&run.set2_data[0]) +
												  n_triangle_b * 3 /* vertices */
													  * 3;		   /* components */

						if (TessellationShaderUtils::isTriangleDefined(triangle_a, triangle_b))
						{
							triangleMatched[n_triangle_b] = true;
							triangleFound				  = true;
							break;
						}
					}
				}

				if (!triangleFound)
				{
					std::string vs_mode_string =
						TessellationShaderUtils::getESTokenForVertexSpacingMode(run.vertex_spacing);

					m_testCtx.getLog() << tcu::TestLog::Message
									   << "The following triangle, generated in the first pass, was not "
										  "generated in the second one. "
										  "First pass' configuration: inner tess levels:"
										  "["
									   << run.set1_inner[0] << ", " << run.set1_inner[1] << "]"
																							", outer tess levels:"
																							"["
									   << run.set1_outer[0] << ", " << run.set1_outer[1] << ", " << run.set1_outer[2]
									   << ", " << run.set1_outer[3]
									   << "]"
										  "; second pass' configuration: inner tess levels:"
										  "["
									   << run.set2_inner[0] << ", " << run.set2_inner[1] << "]"
																							", outer tess levels:"
																							"["
									   << run.set2_outer[0] << ", " << run.set2_outer[1] << ", " << run.set2_outer[2]
									   << ", " << run.set2_outer[3] << "]"
																	   ", primitive mode: quads, vertex spacing: "
									   << vs_mode_string << tcu::TestLog::EndMessage;

					TCU_FAIL("A triangle from first pass' data set was not found in second pass' data set.");
				}
			} /* for (all vertices) */
		}	 /* if (run.vertex_spacing != TESSELLATION_SHADER_VERTEX_SPACING_FRACTIONAL_ODD) */
		else
		{
			/* For Fractional Odd vertex spacing, we cannot apply the above methodology because of the fact
			 * two of the inner edges (the ones subdivided with tessellation level of 1.0) will have been
			 * subdivided differently between two runs, causing the vertex positions to shift, ultimately
			 * leading to isTriangleDefined() failure.
			 *
			 * Hence, we need to take a bit different approach for this case. If you look at a visualization
			 * of a tessellated quad, for which one of the inner tess levels has been set to 1 (let's assume
			 * inner[0] for the sake of discussion), and then looked at a list of points that were generated by the
			 * tessellator, you'll notice that even though it looks like we only have one span of triangles
			 * horizontally, there are actually three. The two outermost spans on each side (the "outer
			 * tessellation regions") are actually degenerate, because they have epsilon spacing allocated to
			 * them.
			 *
			 * Using the theory above, we look for a so-called "marker triangle". In the inner[0] = 1.0 case,
			 * it's one of the two triangles, one edge of which spans horizontally across the whole domain, and
			 * the other two edges touch the outermost edge of the quad. In the inner[1] = 1.0 case, Xs are flipped
			 * with Ys, but the general idea stays the same.
			 *
			 * So for fractional odd vertex spacing, this test verifies that the two marker triangles capping the
			 * opposite ends of the inner quad tessellation region exist.
			 */

			/* Convert arrayed triangle-based representation to a vector storing unique tessellation
			 * coordinates.
			 */
			std::vector<_vec2> set1_tess_coordinates =
				getUniqueTessCoordinatesFromVertexDataSet((const float*)(&run.set1_data[0]), run.n_vertices);

			/* Extract and sort the coordinate components we have from
			 * the minimum to the maximum */
			std::vector<float> set1_tess_coordinates_x_sorted;
			std::vector<float> set1_tess_coordinates_y_sorted;

			for (std::vector<_vec2>::iterator coordinate_iterator = set1_tess_coordinates.begin();
				 coordinate_iterator != set1_tess_coordinates.end(); coordinate_iterator++)
			{
				const _vec2& coordinate = *coordinate_iterator;

				if (std::find(set1_tess_coordinates_x_sorted.begin(), set1_tess_coordinates_x_sorted.end(),
							  coordinate.x) == set1_tess_coordinates_x_sorted.end())
				{
					set1_tess_coordinates_x_sorted.push_back(coordinate.x);
				}

				if (std::find(set1_tess_coordinates_y_sorted.begin(), set1_tess_coordinates_y_sorted.end(),
							  coordinate.y) == set1_tess_coordinates_y_sorted.end())
				{
					set1_tess_coordinates_y_sorted.push_back(coordinate.y);
				}
			} /* for (all tessellation coordinates) */

			std::sort(set1_tess_coordinates_x_sorted.begin(), set1_tess_coordinates_x_sorted.end());
			std::sort(set1_tess_coordinates_y_sorted.begin(), set1_tess_coordinates_y_sorted.end());

			/* Sanity checks */
			DE_ASSERT(set1_tess_coordinates_x_sorted.size() > 2);
			DE_ASSERT(set1_tess_coordinates_y_sorted.size() > 2);

			/* NOTE: This code could have been merged for both cases at the expense of code readability. */
			if (run.set1_inner[0] == 1.0f)
			{
				/* Look for the second horizontal line segment, starting from top and bottom */
				const float second_y_from_top = set1_tess_coordinates_y_sorted[1];
				const float second_y_from_bottom =
					set1_tess_coordinates_y_sorted[set1_tess_coordinates_y_sorted.size() - 2];

				/* In this particular case, there should be exactly one triangle spanning
				 * from U=0 to U=1 at both these heights, with the third coordinate located
				 * at the "outer" edge.
				 */
				for (int n = 0; n < 2 /* cases */; ++n)
				{
					float y1_y2 = 0.0f;
					float y3	= 0.0f;

					if (n == 0)
					{
						y1_y2 = second_y_from_bottom;
						y3	= 1.0f;
					}
					else
					{
						y1_y2 = second_y_from_top;
						y3	= 0.0f;
					}

					/* Try to find the triangle */
					bool has_found_triangle = false;

					DE_ASSERT((run.n_vertices % 3) == 0);

					for (unsigned int n_triangle = 0; n_triangle < run.n_vertices / 3; ++n_triangle)
					{
						const float* vertex1_data = (const float*)(&run.set1_data[0]) +
													3		/* vertices */
														* 3 /* components */
														* n_triangle;
						const float* vertex2_data = vertex1_data + 3 /* components */;
						const float* vertex3_data = vertex2_data + 3 /* components */;

						/* Make sure at least two Y coordinates are equal to y1_y2. */
						const float* y1_vertex_data = DE_NULL;
						const float* y2_vertex_data = DE_NULL;
						const float* y3_vertex_data = DE_NULL;

						if (vertex1_data[1] == y1_y2)
						{
							if (vertex2_data[1] == y1_y2 && vertex3_data[1] == y3)
							{
								y1_vertex_data = vertex1_data;
								y2_vertex_data = vertex2_data;
								y3_vertex_data = vertex3_data;
							}
							else if (vertex2_data[1] == y3 && vertex3_data[1] == y1_y2)
							{
								y1_vertex_data = vertex1_data;
								y2_vertex_data = vertex3_data;
								y3_vertex_data = vertex2_data;
							}
						}
						else if (vertex2_data[1] == y1_y2 && vertex3_data[1] == y1_y2 && vertex1_data[1] == y3)
						{
							y1_vertex_data = vertex2_data;
							y2_vertex_data = vertex3_data;
							y3_vertex_data = vertex1_data;
						}

						if (y1_vertex_data != DE_NULL && y2_vertex_data != DE_NULL && y3_vertex_data != DE_NULL)
						{
							/* Vertex 1 and 2 should span across whole domain horizontally */
							if ((y1_vertex_data[0] == 0.0f && y2_vertex_data[0] == 1.0f) ||
								(y1_vertex_data[0] == 1.0f && y2_vertex_data[0] == 0.0f))
							{
								has_found_triangle = true;

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

					if (!has_found_triangle)
					{
						TCU_FAIL("Could not find a marker triangle");
					}
				} /* for (both cases) */
			}	 /* if (run.set1_inner[0] == 1.0f) */
			else
			{
				DE_ASSERT(run.set1_inner[1] == 1.0f);

				/* Look for the second vertical line segment, starting from left and right */
				const float second_x_from_left = set1_tess_coordinates_x_sorted[1];
				const float second_x_from_right =
					set1_tess_coordinates_x_sorted[set1_tess_coordinates_x_sorted.size() - 2];

				/* In this particular case, there should be exactly one triangle spanning
				 * from V=0 to V=1 at both these widths, with the third coordinate located
				 * at the "outer" edge.
				 */
				for (int n = 0; n < 2 /* cases */; ++n)
				{
					float x1_x2 = 0.0f;
					float x3	= 0.0f;

					if (n == 0)
					{
						x1_x2 = second_x_from_right;
						x3	= 1.0f;
					}
					else
					{
						x1_x2 = second_x_from_left;
						x3	= 0.0f;
					}

					/* Try to find the triangle */
					bool has_found_triangle = false;

					DE_ASSERT((run.n_vertices % 3) == 0);

					for (unsigned int n_triangle = 0; n_triangle < run.n_vertices / 3; ++n_triangle)
					{
						const float* vertex1_data =
							(const float*)(&run.set1_data[0]) + 3 /* vertices */ * 3 /* components */ * n_triangle;
						const float* vertex2_data = vertex1_data + 3 /* components */;
						const float* vertex3_data = vertex2_data + 3 /* components */;

						/* Make sure at least two X coordinates are equal to x1_x2. */
						const float* x1_vertex_data = DE_NULL;
						const float* x2_vertex_data = DE_NULL;
						const float* x3_vertex_data = DE_NULL;

						if (vertex1_data[0] == x1_x2)
						{
							if (vertex2_data[0] == x1_x2 && vertex3_data[0] == x3)
							{
								x1_vertex_data = vertex1_data;
								x2_vertex_data = vertex2_data;
								x3_vertex_data = vertex3_data;
							}
							else if (vertex2_data[0] == x3 && vertex3_data[0] == x1_x2)
							{
								x1_vertex_data = vertex1_data;
								x2_vertex_data = vertex3_data;
								x3_vertex_data = vertex2_data;
							}
						}
						else if (vertex2_data[0] == x1_x2 && vertex3_data[0] == x1_x2 && vertex1_data[0] == x3)
						{
							x1_vertex_data = vertex2_data;
							x2_vertex_data = vertex3_data;
							x3_vertex_data = vertex1_data;
						}

						if (x1_vertex_data != DE_NULL && x2_vertex_data != DE_NULL && x3_vertex_data != DE_NULL)
						{
							/* Vertex 1 and 2 should span across whole domain vertically */
							if ((x1_vertex_data[1] == 0.0f && x2_vertex_data[1] == 1.0f) ||
								(x1_vertex_data[1] == 1.0f && x2_vertex_data[1] == 0.0f))
							{
								has_found_triangle = true;

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

					if (!has_found_triangle)
					{
						TCU_FAIL("Could not find a marker triangle (implies invalid quad tessellation for the case "
								 "considered)");
					}
				} /* for (both cases) */
			}
		}
	} /* for (all runs) */

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

} /* namespace glcts */