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

namespace glcts
{
/* Shared shaders' code */
const char* const GeometryShaderProgramResourceTest::m_common_shader_code_definitions_body =
	"// uniforms\n"
	"uniform mat4 uni_model_view_projection; // not referenced in GS\n"
	"uniform vec4 uni_colors_white;          // referenced in GS\n"
	"\n"
	"// uniforms blocks\n"
	"uniform Matrices\n"
	"{\n"
	"    mat4 model;\n"
	"    mat4 view;\n"
	"    mat4 projection;\n"
	"} uni_matrices; // not referenced at all\n"
	"\n"
	"uniform Colors\n"
	"{\n"
	"    vec4 red;\n"
	"    vec4 green;\n"
	"    vec4 blue;\n"
	"} uni_colors; // referenced in GS\n"
	"\n";

const char* const GeometryShaderProgramResourceTest::m_common_shader_code_definitions_atomic_counter_body =
	"// atomic counter buffers\n"
	"layout (binding = 0) uniform atomic_uint uni_atom_horizontal; // not referenced in GS\n"
	"layout (binding = 1) uniform atomic_uint uni_atom_vertical;   // referenced in GS\n"
	"\n";

const char* const GeometryShaderProgramResourceTest::m_common_shader_code_definitions_ssbo_body =
	"// ssbos\n"
	"buffer Positions\n"
	"{\n"
	"    vec4 position[4]; // referenced in GS\n"
	"} storage_positions;  // referenced in GS\n"
	"\n"
	"buffer Ids\n"
	"{\n"
	"    int ids[4]; // not referenced in GS\n"
	"} storage_ids;  // not referenced in GS\n"
	"\n";

/* Vertex shader */
const char* const GeometryShaderProgramResourceTest::m_vertex_shader_code_preamble = "${VERSION}\n"
																					 "\n"
																					 "precision highp float;\n"
																					 "\n"
																					 "// uniforms included here\n";

const char* const GeometryShaderProgramResourceTest::m_vertex_shader_code_body =
	"// attributes\n"
	"in vec4 vs_in_position; // not referenced in GS\n"
	"in vec4 vs_in_color;    // not referenced in GS\n"
	"\n"
	"// output\n"
	"out vec4 vs_out_color; // referenced in GS\n"
	"\n"
	"void main()\n"
	"{\n"
	"    gl_Position  = uni_model_view_projection * vs_in_position;\n"
	"    vs_out_color = vs_in_color;\n";

const char* const GeometryShaderProgramResourceTest::m_vertex_shader_code_atomic_counter_body =
	"    // write atomic counters\n"
	"    if (0.0 <= gl_Position.x)\n"
	"    {\n"
	"        atomicCounterIncrement(uni_atom_vertical);\n"
	"    }\n"
	"\n"
	"    if (0.0 <= gl_Position.y)\n"
	"    {\n"
	"        atomicCounterIncrement(uni_atom_horizontal);\n"
	"    }\n";

const char* const GeometryShaderProgramResourceTest::m_vertex_shader_code_ssbo_body =
	"    // write shader storage buffers\n"
	"    storage_positions.position[gl_VertexID] = gl_Position;\n"
	"    storage_ids.ids[gl_VertexID]            = gl_VertexID;\n";

/* Geometry shader */
const char* const GeometryShaderProgramResourceTest::m_geometry_shader_code_preamble =
	"${VERSION}\n"
	"\n"
	"${GEOMETRY_SHADER_REQUIRE}\n"
	"\n"
	"precision highp float;\n"
	"\n"
	"layout (points)                           in;\n"
	"layout (triangle_strip, max_vertices = 6) out;\n"
	"\n"
	"// uniforms included here\n";

const char* const GeometryShaderProgramResourceTest::m_geometry_shader_code_body =
	"// input from vs + gl_Position\n"
	"in vec4 vs_out_color[1];\n"
	"\n"
	"out vec4 gs_out_color;\n"
	"\n"
	"void main()\n"
	"{\n"
	"    // access uniform\n"
	"    gl_Position = vec4(0, 0, 0, 0);\n"
	"    gs_out_color = uni_colors_white;\n"
	"    EmitVertex();\n"
	"\n"
	"    // access uniform block\n"
	"    gl_Position = gl_in[0].gl_Position + vec4(-0.1, 0.1, 0, 0);\n"
	"    gs_out_color = vs_out_color[0] + uni_colors.red;\n"
	"    EmitVertex();\n"
	"\n"
	"    gl_Position = gl_in[0].gl_Position + vec4(-0.1, -0.1, 0, 0);\n"
	"    gs_out_color = vs_out_color[0] + uni_colors.green;\n"
	"    EmitVertex();\n"
	"\n"
	"    gl_Position = gl_in[0].gl_Position + vec4(0.1, -0.1, 0, 0);\n"
	"    gs_out_color = vs_out_color[0] + uni_colors.blue;\n"
	"    EmitVertex();\n";

const char* const GeometryShaderProgramResourceTest::m_geometry_shader_code_atomic_counter_body =
	"    // access atomic counter\n"
	"    gl_Position = vec4(0, 0, 0, 0);\n"
	"    uint  counter = atomicCounter(uni_atom_vertical);\n"
	"    gs_out_color     = vec4(counter / 255u);\n"
	"    EmitVertex();\n";

const char* const GeometryShaderProgramResourceTest::m_geometry_shader_code_ssbo_body =
	"    // access shader storage buffers\n"
	"    gl_Position = storage_positions.position[0] + vec4(0.1, 0.1, 0, 0);\n"
	"    gs_out_color     = vec4(1.0);\n"
	"    EmitVertex();\n";

/* Fragment shader */
const char* const GeometryShaderProgramResourceTest::m_fragment_shader_code =
	"${VERSION}\n"
	"\n"
	"precision highp float;\n"
	"\n"
	"// input from gs\n"
	"in vec4 gs_out_color;\n"
	"layout(location = 0) out vec4 fs_out_color;\n"
	"\n"
	"void main()\n"
	"{\n"
	"    fs_out_color = gs_out_color;\n"
	"}\n"
	"\n";

/** Constructor
 *
 * @param context     Test context
 * @param name        Test case's name
 * @param description Test case's desricption
 **/
GeometryShaderProgramResourceTest::GeometryShaderProgramResourceTest(Context& context, const ExtParameters& extParams,
																	 const char* name, const char* description)
	: TestCaseBase(context, extParams, name, description)
	, m_fragment_shader_id(0)
	, m_geometry_shader_id(0)
	, m_vertex_shader_id(0)
	, m_program_object_id(0)
	, m_atomic_counters_supported(false)
	, m_ssbos_supported(false)
{
	/* Nothing to be done here */
}

/** Initializes GLES objects used during the test.
 *
 **/
void GeometryShaderProgramResourceTest::initTest()
{
	/* Check if geometry_shader extension is supported */
	if (!m_is_geometry_shader_extension_supported)
	{
		throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
	}

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

	glw::GLint maxVSAtomicCounters = 0;
	gl.getIntegerv(GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS, &maxVSAtomicCounters);

	glw::GLint maxGSAtomicCounters = 0;
	gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS, &maxGSAtomicCounters);

	m_atomic_counters_supported = maxVSAtomicCounters >= 2 && maxGSAtomicCounters >= 1;

	glw::GLint maxVSStorageBlocks = 0;
	gl.getIntegerv(GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS, &maxVSStorageBlocks);

	glw::GLint maxGSStorageBlocks = 0;
	gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_SHADER_STORAGE_BLOCKS, &maxGSStorageBlocks);

	m_ssbos_supported = maxVSStorageBlocks >= 2 && maxGSStorageBlocks >= 1;

	glw::GLuint nCodeParts = 0;
	const char* vertex_shader_code_parts[8];
	const char* geometry_shader_code_parts[8];

	/* Vertex & geometry shaders */
	if (m_atomic_counters_supported && m_ssbos_supported)
	{
		vertex_shader_code_parts[0] = m_vertex_shader_code_preamble;
		vertex_shader_code_parts[1] = m_common_shader_code_definitions_body;
		vertex_shader_code_parts[2] = m_common_shader_code_definitions_atomic_counter_body;
		vertex_shader_code_parts[3] = m_common_shader_code_definitions_ssbo_body;
		vertex_shader_code_parts[4] = m_vertex_shader_code_body;
		vertex_shader_code_parts[5] = m_vertex_shader_code_atomic_counter_body;
		vertex_shader_code_parts[6] = m_vertex_shader_code_ssbo_body;
		vertex_shader_code_parts[7] = "}\n";

		geometry_shader_code_parts[0] = m_geometry_shader_code_preamble;
		geometry_shader_code_parts[1] = m_common_shader_code_definitions_body;
		geometry_shader_code_parts[2] = m_common_shader_code_definitions_atomic_counter_body;
		geometry_shader_code_parts[3] = m_common_shader_code_definitions_ssbo_body;
		geometry_shader_code_parts[4] = m_geometry_shader_code_body;
		geometry_shader_code_parts[5] = m_geometry_shader_code_atomic_counter_body;
		geometry_shader_code_parts[6] = m_geometry_shader_code_ssbo_body;
		geometry_shader_code_parts[7] = "}\n";

		nCodeParts = 8;
	}
	else if (m_atomic_counters_supported)
	{
		vertex_shader_code_parts[0] = m_vertex_shader_code_preamble;
		vertex_shader_code_parts[1] = m_common_shader_code_definitions_body;
		vertex_shader_code_parts[2] = m_common_shader_code_definitions_atomic_counter_body;
		vertex_shader_code_parts[3] = m_vertex_shader_code_body;
		vertex_shader_code_parts[4] = m_vertex_shader_code_atomic_counter_body;
		vertex_shader_code_parts[5] = "}\n";

		geometry_shader_code_parts[0] = m_geometry_shader_code_preamble;
		geometry_shader_code_parts[1] = m_common_shader_code_definitions_body;
		geometry_shader_code_parts[2] = m_common_shader_code_definitions_atomic_counter_body;
		geometry_shader_code_parts[3] = m_geometry_shader_code_body;
		geometry_shader_code_parts[4] = m_geometry_shader_code_atomic_counter_body;
		geometry_shader_code_parts[5] = "}\n";

		nCodeParts = 6;
	}
	else if (m_ssbos_supported)
	{
		vertex_shader_code_parts[0] = m_vertex_shader_code_preamble;
		vertex_shader_code_parts[1] = m_common_shader_code_definitions_body;
		vertex_shader_code_parts[2] = m_common_shader_code_definitions_ssbo_body;
		vertex_shader_code_parts[3] = m_vertex_shader_code_body;
		vertex_shader_code_parts[4] = m_vertex_shader_code_ssbo_body;
		vertex_shader_code_parts[5] = "}\n";

		geometry_shader_code_parts[0] = m_geometry_shader_code_preamble;
		geometry_shader_code_parts[1] = m_common_shader_code_definitions_body;
		geometry_shader_code_parts[2] = m_common_shader_code_definitions_ssbo_body;
		geometry_shader_code_parts[3] = m_geometry_shader_code_body;
		geometry_shader_code_parts[4] = m_geometry_shader_code_ssbo_body;
		geometry_shader_code_parts[5] = "}\n";

		nCodeParts = 6;
	}
	else
	{
		vertex_shader_code_parts[0] = m_vertex_shader_code_preamble;
		vertex_shader_code_parts[1] = m_common_shader_code_definitions_body;
		vertex_shader_code_parts[2] = m_vertex_shader_code_body;
		vertex_shader_code_parts[3] = "}\n";

		geometry_shader_code_parts[0] = m_geometry_shader_code_preamble;
		geometry_shader_code_parts[1] = m_common_shader_code_definitions_body;
		geometry_shader_code_parts[2] = m_geometry_shader_code_body;
		geometry_shader_code_parts[3] = "}\n";

		nCodeParts = 4;
	}

	/* Create shader objects */
	m_fragment_shader_id = gl.createShader(GL_FRAGMENT_SHADER);
	m_geometry_shader_id = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
	m_vertex_shader_id   = gl.createShader(GL_VERTEX_SHADER);

	/* Create program object */
	m_program_object_id = gl.createProgram();

	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create program object");

	/* Build program object */
	if (true !=
		buildProgram(m_program_object_id, m_fragment_shader_id, 1,				 /* Fragment shader parts number */
					 &m_fragment_shader_code, m_geometry_shader_id, nCodeParts,  /* Geometry shader parts number */
					 geometry_shader_code_parts, m_vertex_shader_id, nCodeParts, /* Vertex shader parts number */
					 vertex_shader_code_parts))
	{
		TCU_FAIL("Could not create program from valid vertex/geometry/fragment shader");
	}
}

/** Executes the test.
 *  Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
 *  @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again.
 *  Note the function throws exception should an error occur!
 **/
tcu::TestCase::IterateResult GeometryShaderProgramResourceTest::iterate()
{
	initTest();

	/* Results */
	bool result = true;

	/* Results of checks, names come from shaders */
	bool is_gl_fs_out_color_program_output_referenced		  = false;
	bool is_ids_ids_buffer_variable_referenced				  = false;
	bool is_positions_position_buffer_variable_referenced	 = false;
	bool is_storage_ids_shader_storage_block_referenced		  = false;
	bool is_storage_positions_shader_storage_block_referenced = false;
	bool is_uni_atom_horizontal_uniform_referenced			  = false;
	bool is_uni_atom_vertical_uniform_referenced			  = false;
	bool is_uni_colors_uniform_referenced					  = false;
	bool is_uni_colors_white_uniform_referenced				  = false;
	bool is_uni_matrices_uniform_referenced					  = false;
	bool is_uni_model_view_projection_uniform_referenced	  = false;
	bool is_vs_in_color_program_input_referenced			  = false;
	bool is_vs_in_position_program_input_referenced			  = false;

	/* Check whether uniform variables are referenced */
	is_uni_model_view_projection_uniform_referenced =
		checkIfResourceIsReferenced(m_program_object_id, GL_UNIFORM, "uni_model_view_projection");
	is_uni_colors_white_uniform_referenced =
		checkIfResourceIsReferenced(m_program_object_id, GL_UNIFORM, "uni_colors_white");

	/* For: uniform Matrices {} uni_matrices; uniform block name is: Matrices */
	is_uni_matrices_uniform_referenced = checkIfResourceIsReferenced(m_program_object_id, GL_UNIFORM_BLOCK, "Matrices");
	is_uni_colors_uniform_referenced   = checkIfResourceIsReferenced(m_program_object_id, GL_UNIFORM_BLOCK, "Colors");

	/* For: buffer Positions {} storage_positions; storage block name is: Positions */
	if (m_ssbos_supported)
	{
		is_storage_positions_shader_storage_block_referenced =
			checkIfResourceIsReferenced(m_program_object_id, GL_SHADER_STORAGE_BLOCK, "Positions");
		is_storage_ids_shader_storage_block_referenced =
			checkIfResourceIsReferenced(m_program_object_id, GL_SHADER_STORAGE_BLOCK, "Ids");

		is_positions_position_buffer_variable_referenced =
			checkIfResourceIsReferenced(m_program_object_id, GL_BUFFER_VARIABLE, "Positions.position");
		is_ids_ids_buffer_variable_referenced =
			checkIfResourceIsReferenced(m_program_object_id, GL_BUFFER_VARIABLE, "Ids.ids");
	}

	/* Check whether input attributes are referenced */
	is_vs_in_position_program_input_referenced =
		checkIfResourceIsReferenced(m_program_object_id, GL_PROGRAM_INPUT, "vs_in_position");
	is_vs_in_color_program_input_referenced =
		checkIfResourceIsReferenced(m_program_object_id, GL_PROGRAM_INPUT, "vs_in_color");

	/* Check whether output attributes are referenced */
	is_gl_fs_out_color_program_output_referenced =
		checkIfResourceIsReferenced(m_program_object_id, GL_PROGRAM_OUTPUT, "fs_out_color");

	/*
	 *     For the ATOMIC_COUNTER_BUFFER interface, the list of active buffer binding
	 *     points is built by identifying each unique binding point associated with
	 *     one or more active atomic counter uniform variables.  Active atomic
	 *     counter buffers do not have an associated name string.
	 */
	if (m_atomic_counters_supported)
	{
		const glw::Functions& gl = m_context.getRenderContext().getFunctions();

		/* First get corresponding uniform indices */
		glw::GLuint atom_horizontal_uniform_indx =
			gl.getProgramResourceIndex(m_program_object_id, GL_UNIFORM, "uni_atom_horizontal");
		glw::GLuint atom_vertical_uniform_indx =
			gl.getProgramResourceIndex(m_program_object_id, GL_UNIFORM, "uni_atom_vertical");

		/* Then get atomic buffer indices */
		glw::GLuint atom_horizontal_uniform_buffer_indx = GL_INVALID_INDEX;
		glw::GLuint atom_vertical_uniform_buffer_indx   = GL_INVALID_INDEX;

		/* Data for getProgramResourceiv */
		glw::GLint  params[] = { 0 };
		glw::GLenum props[]  = { GL_ATOMIC_COUNTER_BUFFER_INDEX };

		/* Get property value */
		gl.getProgramResourceiv(m_program_object_id, GL_UNIFORM, atom_horizontal_uniform_indx, 1, /* propCount */
								props, 1,														  /* bufSize */
								0,																  /* length */
								params);
		atom_horizontal_uniform_buffer_indx = params[0];

		gl.getProgramResourceiv(m_program_object_id, GL_UNIFORM, atom_vertical_uniform_indx, 1, /* propCount */
								props, 1,														/* bufSize */
								0,																/* length */
								params);
		atom_vertical_uniform_buffer_indx = params[0];

		/* Check whether atomic counters are referenced using the atomic buffer indices */
		is_uni_atom_horizontal_uniform_referenced = checkIfResourceAtIndexIsReferenced(
			m_program_object_id, GL_ATOMIC_COUNTER_BUFFER, atom_horizontal_uniform_buffer_indx);
		is_uni_atom_vertical_uniform_referenced = checkIfResourceAtIndexIsReferenced(
			m_program_object_id, GL_ATOMIC_COUNTER_BUFFER, atom_vertical_uniform_buffer_indx);
	}

	/* Verify results: referenced properties */
	if (true != is_uni_colors_white_uniform_referenced)
	{
		m_testCtx.getLog() << tcu::TestLog::Message
						   << "Wrong value of property GL_REFERENCED_BY_GEOMETRY_SHADER_EXT for GL_UNIFORM"
						   << tcu::TestLog::EndMessage;

		result = false;
	}

	if (true != is_uni_colors_uniform_referenced)
	{
		m_testCtx.getLog() << tcu::TestLog::Message
						   << "Wrong value of property GL_REFERENCED_BY_GEOMETRY_SHADER_EXT for GL_UNIFORM_BLOCK"
						   << tcu::TestLog::EndMessage;

		result = false;
	}

	if (true != is_uni_atom_vertical_uniform_referenced && m_atomic_counters_supported)
	{
		m_testCtx.getLog()
			<< tcu::TestLog::Message
			<< "Wrong value of property GL_REFERENCED_BY_GEOMETRY_SHADER_EXT for GL_ATOMIC_COUNTER_BUFFER"
			<< tcu::TestLog::EndMessage;

		result = false;
	}

	if (false != is_uni_atom_horizontal_uniform_referenced && m_atomic_counters_supported)
	{
		m_testCtx.getLog()
			<< tcu::TestLog::Message
			<< "Wrong value of property GL_REFERENCED_BY_GEOMETRY_SHADER_EXT for GL_ATOMIC_COUNTER_BUFFER"
			<< tcu::TestLog::EndMessage;

		result = false;
	}

	if (true != is_storage_positions_shader_storage_block_referenced && m_ssbos_supported)
	{
		m_testCtx.getLog() << tcu::TestLog::Message
						   << "Wrong value of property GL_REFERENCED_BY_GEOMETRY_SHADER_EXT for GL_SHADER_STORAGE_BLOCK"
						   << tcu::TestLog::EndMessage;

		result = false;
	}

	if (false != is_storage_ids_shader_storage_block_referenced && m_ssbos_supported)
	{
		m_testCtx.getLog() << tcu::TestLog::Message
						   << "Wrong value of property GL_REFERENCED_BY_GEOMETRY_SHADER_EXT for GL_SHADER_STORAGE_BLOCK"
						   << tcu::TestLog::EndMessage;

		result = false;
	}

	if (true != is_positions_position_buffer_variable_referenced && m_ssbos_supported)
	{
		m_testCtx.getLog() << tcu::TestLog::Message
						   << "Wrong value of property GL_REFERENCED_BY_GEOMETRY_SHADER_EXT for GL_BUFFER_VARIABLE"
						   << tcu::TestLog::EndMessage;

		result = false;
	}

	if (false != is_ids_ids_buffer_variable_referenced && m_ssbos_supported)
	{
		m_testCtx.getLog() << tcu::TestLog::Message
						   << "Wrong value of property GL_REFERENCED_BY_GEOMETRY_SHADER_EXT for GL_BUFFER_VARIABLE"
						   << tcu::TestLog::EndMessage;

		result = false;
	}

	/* Verify results: properties that are not referenced */
	if (false != is_uni_model_view_projection_uniform_referenced)
	{
		m_testCtx.getLog() << tcu::TestLog::Message
						   << "Wrong value of property GL_REFERENCED_BY_GEOMETRY_SHADER_EXT for GL_UNIFORM"
						   << tcu::TestLog::EndMessage;

		result = false;
	}

	if (false != is_uni_matrices_uniform_referenced)
	{
		m_testCtx.getLog() << tcu::TestLog::Message
						   << "Wrong value of property GL_REFERENCED_BY_GEOMETRY_SHADER_EXT for GL_UNIFORM_BLOCK"
						   << tcu::TestLog::EndMessage;

		result = false;
	}

	if (false != is_vs_in_position_program_input_referenced)
	{
		m_testCtx.getLog() << tcu::TestLog::Message
						   << "Wrong value of property GL_REFERENCED_BY_GEOMETRY_SHADER_EXT for GL_PROGRAM_INPUT"
						   << tcu::TestLog::EndMessage;

		result = false;
	}

	if (false != is_vs_in_color_program_input_referenced)
	{
		m_testCtx.getLog() << tcu::TestLog::Message
						   << "Wrong value of property GL_REFERENCED_BY_GEOMETRY_SHADER_EXT for GL_PROGRAM_INPUT"
						   << tcu::TestLog::EndMessage;

		result = false;
	}

	if (false != is_gl_fs_out_color_program_output_referenced)
	{
		m_testCtx.getLog() << tcu::TestLog::Message
						   << "Wrong value of property GL_REFERENCED_BY_GEOMETRY_SHADER_EXT for GL_PROGRAM_OUTPUT"
						   << tcu::TestLog::EndMessage;

		result = false;
	}

	/* Set test result */
	if (true == result)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
	}

	/* Done */
	return STOP;
}

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

	/* Reset OpenGL ES state */
	gl.useProgram(0);

	/* Delete program objects and shader objects */
	if (m_program_object_id != 0)
	{
		gl.deleteProgram(m_program_object_id);
	}

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

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

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

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

/** Queries property GL_REFERENCED_BY_GEOMETRY_SHADER_EXT for resource at specified index in specific interface.
 *  Program object must be linked.
 *
 *  @param program_object_id Program which will be inspected;
 *  @param interface         Queried interface;
 *  @param index             Resource's index.
 *
 *  @return  true            Property value is 1
 *           false           Property value is 0
 **/
bool GeometryShaderProgramResourceTest::checkIfResourceAtIndexIsReferenced(glw::GLuint program_object_id,
																		   glw::GLenum interface,
																		   glw::GLuint index) const
{
	(void)program_object_id;

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

	/* Data for getProgramResourceiv */
	glw::GLint  params[] = { 0 };
	glw::GLenum props[]  = { m_glExtTokens.REFERENCED_BY_GEOMETRY_SHADER };

	/* Get property value */
	gl.getProgramResourceiv(m_program_object_id, interface, index, 1, /* propCount */
							props, 1,								  /* bufSize */
							0,										  /* length */
							params);

	/**
	 *     The value one is written to <params> if an active
	 *     variable is referenced by the corresponding shader, or if an active
	 *     uniform block, shader storage block, or atomic counter buffer contains
	 *     at least one variable referenced by the corresponding shader.  Otherwise,
	 *     the value zero is written to <params>.
	 **/
	if (1 == params[0])
	{
		return true;
	}
	else
	{
		return false;
	}
}

/** Queries property GL_REFERENCED_BY_GEOMETRY_SHADER_EXT for resource with specified name in specific interface.
 *  Program object must be linked.
 *
 *  @param program_object_id Program which will be inspected
 *  @param interface         Queried interface
 *  @param name              Resource's name
 *
 *  @return  true            Property value is 1
 *           false           Property value is 0, or resource is not available
 **/
bool GeometryShaderProgramResourceTest::checkIfResourceIsReferenced(glw::GLuint program_object_id,
																	glw::GLenum interface, const char* name) const
{
	/* GL */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Resource index */
	glw::GLuint index = GL_INVALID_INDEX;

	/* Get resource's index by name */
	index = gl.getProgramResourceIndex(program_object_id, interface, name);

	/**
	 *     Otherwise, <name> is considered not to be the name
	 *     of an active resource, and INVALID_INDEX is returned.
	 **/
	if (GL_INVALID_INDEX == index)
	{
		return false;
	}

	/* Get property by index */
	return checkIfResourceAtIndexIsReferenced(program_object_id, interface, index);
}

} /* glcts */