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

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

 #include "esextcGeometryShaderLayeredRenderingFBONoAttachment.hpp"

 #include "gluDefs.hpp"
 #include "tcuTestLog.hpp"

 namespace glcts
 {
 /* Fragment shader code */
 const char* GeometryShaderLayeredRenderingFBONoAttachment::m_fs_code =
 	"${VERSION}\n"
 	"\n"
 	"${GEOMETRY_SHADER_REQUIRE}\n"
 	"\n"
 	"precision highp float;\n"
 	"\n"
 	"layout(rgba32i, binding = 0) writeonly uniform highp iimage2DArray array_image;\n"
 	"\n"
 	"     in  vec2 uv;\n"
 	"flat in  int  layer_id;\n"
 	"out vec4 color;\n"
 	"\n"
 	"void main()\n"
 	"{\n"
 	"    imageStore(array_image, ivec3( int(128.0 * uv.x), int(128.0 * uv.y), layer_id ), ivec4(0, 255, 0, 0) );\n"
 	"}\n";

 /* Geometry shader code */
 const char* GeometryShaderLayeredRenderingFBONoAttachment::m_gs_code = "${VERSION}\n"
 																	   "\n"
 																	   "${GEOMETRY_SHADER_REQUIRE}\n"
 																	   "\n"
 																	   "precision highp float;\n"
 																	   "\n"
 																	   "layout(points)                          in;\n"
 																	   "layout(triangle_strip, max_vertices=16) out;\n"
 																	   "\n"
 																	   "     out vec2 uv;\n"
 																	   "flat out int  layer_id;\n"
 																	   "\n"
 																	   "void main()\n"
 																	   "{\n"
 																	   "    for (int n = 0; n < 4; ++n)\n"
 																	   "    {\n"
 																	   "        gl_Position = vec4(1, -1, 0, 1);\n"
 																	   "        gl_Layer    = n;\n"
 																	   "        layer_id    = n;\n"
 																	   "        uv          = vec2(1, 0);\n"
 																	   "        EmitVertex();\n"
 																	   "\n"
 																	   "        gl_Position = vec4(1,  1, 0, 1);\n"
 																	   "        gl_Layer    = n;\n"
 																	   "        layer_id    = n;\n"
 																	   "        uv          = vec2(1, 1);\n"
 																	   "        EmitVertex();\n"
 																	   "\n"
 																	   "        gl_Position = vec4(-1, -1, 0, 1);\n"
 																	   "        gl_Layer    = n;\n"
 																	   "        layer_id    = n;\n"
 																	   "        uv          = vec2(0, 0);\n"
 																	   "        EmitVertex();\n"
 																	   "\n"
 																	   "        gl_Position = vec4(-1,  1, 0, 1);\n"
 																	   "        gl_Layer    = n;\n"
 																	   "        layer_id    = n;\n"
 																	   "        uv          = vec2(0, 1);\n"
 																	   "        EmitVertex();\n"
 																	   "\n"
 																	   "        EndPrimitive();\n"
 																	   "    }\n"
 																	   "}\n";

 /* Vertex shader code */
 const char* GeometryShaderLayeredRenderingFBONoAttachment::m_vs_code = "${VERSION}\n"
 																	   "\n"
 																	   "${GEOMETRY_SHADER_REQUIRE}\n"
 																	   "\n"
 																	   "precision highp float;\n"
 																	   "\n"
 																	   "void main()\n"
 																	   "{\n"
 																	   "}\n";

 /* Constants */
 const glw::GLint GeometryShaderLayeredRenderingFBONoAttachment::m_height			   = 128;
 const glw::GLint GeometryShaderLayeredRenderingFBONoAttachment::m_width				   = 128;
 const int		 GeometryShaderLayeredRenderingFBONoAttachment::m_n_layers			   = 4;
 const glw::GLint GeometryShaderLayeredRenderingFBONoAttachment::m_n_texture_components = 4;

 /** Constructor
  *
  * @param context       Test context
  * @param name          Test case's name
  * @param description   Test case's description
  **/
 GeometryShaderLayeredRenderingFBONoAttachment::GeometryShaderLayeredRenderingFBONoAttachment(
 	Context& context, const ExtParameters& extParams, const char* name, const char* description)
 	: TestCaseBase(context, extParams, name, description)
 	, m_fbo_id(0)
 	, m_fs_id(0)
 	, m_gs_id(0)
 	, m_po_id(0)
 	, m_to_id(0)
 	, m_vao_id(0)
 	, m_vs_id(0)
 	, m_all_layers_data(DE_NULL)
 	, m_layer_data(DE_NULL)
 {
 	/* Nothing to be done here */
 }

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

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

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

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

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

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

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

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

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

 	if (m_all_layers_data != DE_NULL)
 	{
 		delete[] m_all_layers_data;
 		m_all_layers_data = DE_NULL;
 	}

 	if (m_layer_data != DE_NULL)
 	{
 		delete[] m_layer_data;
 		m_layer_data = DE_NULL;
 	}

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

 /** 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 GeometryShaderLayeredRenderingFBONoAttachment::iterate(void)
 {
 	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

 	/* Check if required extensions are supported */
 	if (!m_is_geometry_shader_extension_supported)
 	{
 		throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
 	}

 	if (!m_is_framebuffer_no_attachments_supported)
 	{
 		throw tcu::NotSupportedError("framebuffer_no_attachment, is not supported", "", __FILE__, __LINE__);
 	}

 	if (!m_is_shader_image_load_store_supported)
 	{
 		throw tcu::NotSupportedError("shader_image_load_store, is not supported", "", __FILE__, __LINE__);
 	}

 	/* Generate and bind a framebuffer object */
 	gl.genFramebuffers(1, &m_fbo_id);
 	gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fbo_id);

 	/* Get the default number of layers of a newly created framebuffer object */
 	glw::GLint nLayers = -1;

 	gl.getFramebufferParameteriv(GL_DRAW_FRAMEBUFFER, m_glExtTokens.FRAMEBUFFER_DEFAULT_LAYERS, &nLayers);

 	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not query a framebuffer object for the number of default layers!");

 	/* check 14.2 test condition - if default number of layer equals 0 */
 	if (nLayers != 0)
 	{
 		m_testCtx.getLog() << tcu::TestLog::Message << "Number of default layers should be equal to 0 but is "
 						   << nLayers << tcu::TestLog::EndMessage;

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

 	/* Set the default resolution to 128x128 */
 	glw::GLint width  = 0;
 	glw::GLint height = 0;

 	gl.framebufferParameteri(GL_DRAW_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_WIDTH, m_width);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set the default framebuffer's width!");
 	gl.getFramebufferParameteriv(GL_DRAW_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_WIDTH, &width);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not get the default framebuffer's width!");
 	gl.framebufferParameteri(GL_DRAW_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_HEIGHT, m_height);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set the default framebuffer's height!");
 	gl.getFramebufferParameteriv(GL_DRAW_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_HEIGHT, &height);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not get the default framebuffer's height!");

 	if (m_width != width || m_height != height)
 	{
 		m_testCtx.getLog() << tcu::TestLog::Message << "Framebuffer's default width/height is not equal to" << m_width
 						   << "\\" << m_height << " but is " << width << "\\" << height << tcu::TestLog::EndMessage;

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

 	/* Configure program object to be used for functional part of the test */
 	m_po_id = gl.createProgram();

 	m_vs_id = gl.createShader(GL_VERTEX_SHADER);
 	m_gs_id = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
 	m_fs_id = gl.createShader(GL_FRAGMENT_SHADER);

 	if (!buildProgram(m_po_id, m_fs_id, 1 /* part */, &m_fs_code, m_gs_id, 1 /* part */, &m_gs_code, m_vs_id,
 					  1 /* part */, &m_vs_code))
 	{
 		TCU_FAIL("Could not create program object from a valid vertex/geometry/fragment shader code!");
 	}

 	/* Configure texture objects and fill them with initial data */
 	m_all_layers_data = new glw::GLint[m_n_layers * m_width * m_height * m_n_texture_components];

 	for (int n = 0; n < m_n_layers * m_width * m_height; ++n)
 	{
 		m_all_layers_data[n * m_n_texture_components + 0] = 255;
 		m_all_layers_data[n * m_n_texture_components + 1] = 0;
 		m_all_layers_data[n * m_n_texture_components + 2] = 0;
 		m_all_layers_data[n * m_n_texture_components + 3] = 0;
 	}

 	gl.genTextures(1, &m_to_id);
 	gl.bindTexture(GL_TEXTURE_2D_ARRAY, m_to_id);
 	gl.texStorage3D(GL_TEXTURE_2D_ARRAY, 1 /* levels */, GL_RGBA32I, m_width, m_height, m_n_layers);
 	gl.texParameterf(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 	gl.texParameterf(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

 	GLU_EXPECT_NO_ERROR(gl.getError(), "Error creating texture objects!");

 	/* Activate the test program object */
 	gl.useProgram(m_po_id);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not use program!");

 	/* Bind texture to image unit */
 	gl.bindImageTexture(0, m_to_id, 0 /* level */, GL_TRUE, 0 /* layer */, GL_WRITE_ONLY, GL_RGBA32I);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not bind texture to image unit!");

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

 	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a vertex array object!");

 	/* Set up the viewport */
 	gl.viewport(0 /* x */, 0 /* y */, m_width /* width */, m_height /* height */);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() call failed.");

 	/* Test 21.4 adjusts the behavior of the original tests. The test now needs to run
 	 * in two iterations:
 	 *
 	 * a) Original behavior is left intact
 	 * b) GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT should be set to 0.
 	 */
 	glw::GLboolean test_failed = false;

 	m_layer_data = new glw::GLint[m_width * m_height * m_n_texture_components];

 	for (unsigned int n_test_iteration = 0; n_test_iteration < 2 && !test_failed; ++n_test_iteration)
 	{
 		const glw::GLint current_n_layers = (n_test_iteration == 1) ? 0 : m_n_layers;

 		/* Reset render-target contents */
 		gl.texSubImage3D(GL_TEXTURE_2D_ARRAY, 0, /* level   */
 						 0,						 /* xoffset */
 						 0,						 /* yoffset */
 						 0,						 /* zoffset */
 						 m_width, m_height, m_n_layers, GL_RGBA_INTEGER, GL_INT, m_all_layers_data);
 		GLU_EXPECT_NO_ERROR(gl.getError(), "glTexSubImage3D() call failed.");

 		/* Set the default number of layers to m_n_layers */
 		gl.framebufferParameteri(GL_DRAW_FRAMEBUFFER, m_glExtTokens.FRAMEBUFFER_DEFAULT_LAYERS, current_n_layers);

 		GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set the default number of layers of a framebuffer object!");

 		gl.getFramebufferParameteriv(GL_DRAW_FRAMEBUFFER, m_glExtTokens.FRAMEBUFFER_DEFAULT_LAYERS, &nLayers);

 		/* check if the reported value equals m_n_layers */
 		if (current_n_layers != nLayers)
 		{
 			m_testCtx.getLog() << tcu::TestLog::Message << "FBO's default layers should be equal to " << m_n_layers
 							   << "but is " << nLayers << tcu::TestLog::EndMessage;

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

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

 		GLU_EXPECT_NO_ERROR(gl.getError(), "Could not execute a draw call!");

 		/* Verify result texture data */
 		gl.bindFramebuffer(GL_READ_FRAMEBUFFER, m_fbo_id);

 		for (int n_layer = 0; n_layer < m_n_layers && !test_failed; ++n_layer)
 		{
 			gl.framebufferTextureLayer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_to_id, 0 /* level */, n_layer);

 			GLU_EXPECT_NO_ERROR(gl.getError(), "Could not bind texture as color attachment to framebuffer!");

 			if (gl.checkFramebufferStatus(GL_READ_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
 			{
 				TCU_FAIL("Read framebuffer is not complete!");
 			}

 			gl.memoryBarrier(GL_FRAMEBUFFER_BARRIER_BIT);

 			gl.readPixels(0 /* x */, 0 /* y */, m_width, m_height, GL_RGBA_INTEGER, GL_INT, m_layer_data);

 			GLU_EXPECT_NO_ERROR(gl.getError(),
 								"Could not read back pixels from the texture bound to color attachment!");

 			/* Perform the verification */
 			const int referenceColor[4] = { 0, 255, 0, 0 };

 			for (int nPx = 0; nPx < m_width * m_height; ++nPx)
 			{
 				if (m_layer_data[nPx * m_n_texture_components + 0] != referenceColor[0] ||
 					m_layer_data[nPx * m_n_texture_components + 1] != referenceColor[1] ||
 					m_layer_data[nPx * m_n_texture_components + 2] != referenceColor[2] ||
 					m_layer_data[nPx * m_n_texture_components + 3] != referenceColor[3])
 				{
 					m_testCtx.getLog() << tcu::TestLog::Message << "The test failed: Pixel " << nPx << " from layer "
 									   << n_layer << " is set to [" << m_layer_data[nPx * m_n_texture_components + 0]
 									   << "," << m_layer_data[nPx * m_n_texture_components + 1] << ","
 									   << m_layer_data[nPx * m_n_texture_components + 2] << ","
 									   << m_layer_data[nPx * m_n_texture_components + 3] << "] but should be equal to ["
 									   << referenceColor[0] << "," << referenceColor[1] << "," << referenceColor[2]
 									   << "," << referenceColor[3] << ","
 									   << "]" << tcu::TestLog::EndMessage;

 					test_failed = true;
 					break;
 				} /* if (result pixel is invalid) */
 			}	 /* for (all pixels) */
 		}		  /* for (all layers) */

 		/* Restore the FBO to no-attachment state for the next iteration */
 		gl.framebufferTextureLayer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 0, 0, 0);

 	} /* for (both iterations) */

 	if (test_failed)
 		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 	else
 		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");

 	return STOP;
 }

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

	#include "esextcGeometryShaderLayeredRenderingFBONoAttachment.hpp"

	#include "gluDefs.hpp"
	#include "tcuTestLog.hpp"

	namespace glcts
	{
	/* Fragment shader code */
	const char* GeometryShaderLayeredRenderingFBONoAttachment::m_fs_code =
	"${VERSION}\n"
	"\n"
	"${GEOMETRY_SHADER_REQUIRE}\n"
	"\n"
	"precision highp float;\n"
	"\n"
	"layout(rgba32i, binding = 0) writeonly uniform highp iimage2DArray array_image;\n"
	"\n"
	" in vec2 uv;\n"
	"flat in int layer_id;\n"
	"out vec4 color;\n"
	"\n"
	"void main()\n"
	"{\n"
	" imageStore(array_image, ivec3( int(128.0 * uv.x), int(128.0 * uv.y), layer_id ), ivec4(0, 255, 0, 0) );\n"
	"}\n";

	/* Geometry shader code */
	const char* GeometryShaderLayeredRenderingFBONoAttachment::m_gs_code = "${VERSION}\n"
	"\n"
	"${GEOMETRY_SHADER_REQUIRE}\n"
	"\n"
	"precision highp float;\n"
	"\n"
	"layout(points) in;\n"
	"layout(triangle_strip, max_vertices=16) out;\n"
	"\n"
	" out vec2 uv;\n"
	"flat out int layer_id;\n"
	"\n"
	"void main()\n"
	"{\n"
	" for (int n = 0; n < 4; ++n)\n"
	" {\n"
	" gl_Position = vec4(1, -1, 0, 1);\n"
	" gl_Layer = n;\n"
	" layer_id = n;\n"
	" uv = vec2(1, 0);\n"
	" EmitVertex();\n"
	"\n"
	" gl_Position = vec4(1, 1, 0, 1);\n"
	" gl_Layer = n;\n"
	" layer_id = n;\n"
	" uv = vec2(1, 1);\n"
	" EmitVertex();\n"
	"\n"
	" gl_Position = vec4(-1, -1, 0, 1);\n"
	" gl_Layer = n;\n"
	" layer_id = n;\n"
	" uv = vec2(0, 0);\n"
	" EmitVertex();\n"
	"\n"
	" gl_Position = vec4(-1, 1, 0, 1);\n"
	" gl_Layer = n;\n"
	" layer_id = n;\n"
	" uv = vec2(0, 1);\n"
	" EmitVertex();\n"
	"\n"
	" EndPrimitive();\n"
	" }\n"
	"}\n";

	/* Vertex shader code */
	const char* GeometryShaderLayeredRenderingFBONoAttachment::m_vs_code = "${VERSION}\n"
	"\n"
	"${GEOMETRY_SHADER_REQUIRE}\n"
	"\n"
	"precision highp float;\n"
	"\n"
	"void main()\n"
	"{\n"
	"}\n";

	/* Constants */
	const glw::GLint GeometryShaderLayeredRenderingFBONoAttachment::m_height = 128;
	const glw::GLint GeometryShaderLayeredRenderingFBONoAttachment::m_width = 128;
	const int GeometryShaderLayeredRenderingFBONoAttachment::m_n_layers = 4;
	const glw::GLint GeometryShaderLayeredRenderingFBONoAttachment::m_n_texture_components = 4;

	/** Constructor
	*
	* @param context Test context
	* @param name Test case's name
	* @param description Test case's description
	**/
	GeometryShaderLayeredRenderingFBONoAttachment::GeometryShaderLayeredRenderingFBONoAttachment(
	Context& context, const ExtParameters& extParams, const char* name, const char* description)
	: TestCaseBase(context, extParams, name, description)
	, m_fbo_id(0)
	, m_fs_id(0)
	, m_gs_id(0)
	, m_po_id(0)
	, m_to_id(0)
	, m_vao_id(0)
	, m_vs_id(0)
	, m_all_layers_data(DE_NULL)
	, m_layer_data(DE_NULL)
	{
	/* Nothing to be done here */
	}

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

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

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

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

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

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

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

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

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

	if (m_all_layers_data != DE_NULL)
	{
	delete[] m_all_layers_data;
	m_all_layers_data = DE_NULL;
	}

	if (m_layer_data != DE_NULL)
	{
	delete[] m_layer_data;
	m_layer_data = DE_NULL;
	}

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

	/** 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 GeometryShaderLayeredRenderingFBONoAttachment::iterate(void)
	{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Check if required extensions are supported */
	if (!m_is_geometry_shader_extension_supported)
	{
	throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
	}

	if (!m_is_framebuffer_no_attachments_supported)
	{
	throw tcu::NotSupportedError("framebuffer_no_attachment, is not supported", "", __FILE__, __LINE__);
	}

	if (!m_is_shader_image_load_store_supported)
	{
	throw tcu::NotSupportedError("shader_image_load_store, is not supported", "", __FILE__, __LINE__);
	}

	/* Generate and bind a framebuffer object */
	gl.genFramebuffers(1, &m_fbo_id);
	gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fbo_id);

	/* Get the default number of layers of a newly created framebuffer object */
	glw::GLint nLayers = -1;

	gl.getFramebufferParameteriv(GL_DRAW_FRAMEBUFFER, m_glExtTokens.FRAMEBUFFER_DEFAULT_LAYERS, &nLayers);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not query a framebuffer object for the number of default layers!");

	/* check 14.2 test condition - if default number of layer equals 0 */
	if (nLayers != 0)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "Number of default layers should be equal to 0 but is "
	<< nLayers << tcu::TestLog::EndMessage;

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

	/* Set the default resolution to 128x128 */
	glw::GLint width = 0;
	glw::GLint height = 0;

	gl.framebufferParameteri(GL_DRAW_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_WIDTH, m_width);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set the default framebuffer's width!");
	gl.getFramebufferParameteriv(GL_DRAW_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_WIDTH, &width);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not get the default framebuffer's width!");
	gl.framebufferParameteri(GL_DRAW_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_HEIGHT, m_height);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set the default framebuffer's height!");
	gl.getFramebufferParameteriv(GL_DRAW_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_HEIGHT, &height);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not get the default framebuffer's height!");

	if (m_width != width \|\| m_height != height)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "Framebuffer's default width/height is not equal to" << m_width
	<< "\\" << m_height << " but is " << width << "\\" << height << tcu::TestLog::EndMessage;

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

	/* Configure program object to be used for functional part of the test */
	m_po_id = gl.createProgram();

	m_vs_id = gl.createShader(GL_VERTEX_SHADER);
	m_gs_id = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
	m_fs_id = gl.createShader(GL_FRAGMENT_SHADER);

	if (!buildProgram(m_po_id, m_fs_id, 1 /* part /, &m_fs_code, m_gs_id, 1 / part */, &m_gs_code, m_vs_id,
	1 /* part */, &m_vs_code))
	{
	TCU_FAIL("Could not create program object from a valid vertex/geometry/fragment shader code!");
	}

	/* Configure texture objects and fill them with initial data */
	m_all_layers_data = new glw::GLint[m_n_layers * m_width * m_height * m_n_texture_components];

	for (int n = 0; n < m_n_layers * m_width * m_height; ++n)
	{
	m_all_layers_data[n * m_n_texture_components + 0] = 255;
	m_all_layers_data[n * m_n_texture_components + 1] = 0;
	m_all_layers_data[n * m_n_texture_components + 2] = 0;
	m_all_layers_data[n * m_n_texture_components + 3] = 0;
	}

	gl.genTextures(1, &m_to_id);
	gl.bindTexture(GL_TEXTURE_2D_ARRAY, m_to_id);
	gl.texStorage3D(GL_TEXTURE_2D_ARRAY, 1 /* levels */, GL_RGBA32I, m_width, m_height, m_n_layers);
	gl.texParameterf(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	gl.texParameterf(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Error creating texture objects!");

	/* Activate the test program object */
	gl.useProgram(m_po_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not use program!");

	/* Bind texture to image unit */
	gl.bindImageTexture(0, m_to_id, 0 /* level /, GL_TRUE, 0 / layer */, GL_WRITE_ONLY, GL_RGBA32I);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not bind texture to image unit!");

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

	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a vertex array object!");

	/* Set up the viewport */
	gl.viewport(0 /* x /, 0 / y /, m_width / width /, m_height / height */);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() call failed.");

	/* Test 21.4 adjusts the behavior of the original tests. The test now needs to run
	* in two iterations:
	*
	* a) Original behavior is left intact
	* b) GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT should be set to 0.
	*/
	glw::GLboolean test_failed = false;

	m_layer_data = new glw::GLint[m_width * m_height * m_n_texture_components];

	for (unsigned int n_test_iteration = 0; n_test_iteration < 2 && !test_failed; ++n_test_iteration)
	{
	const glw::GLint current_n_layers = (n_test_iteration == 1) ? 0 : m_n_layers;

	/* Reset render-target contents */
	gl.texSubImage3D(GL_TEXTURE_2D_ARRAY, 0, /* level */
	0, /* xoffset */
	0, /* yoffset */
	0, /* zoffset */
	m_width, m_height, m_n_layers, GL_RGBA_INTEGER, GL_INT, m_all_layers_data);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexSubImage3D() call failed.");

	/* Set the default number of layers to m_n_layers */
	gl.framebufferParameteri(GL_DRAW_FRAMEBUFFER, m_glExtTokens.FRAMEBUFFER_DEFAULT_LAYERS, current_n_layers);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set the default number of layers of a framebuffer object!");

	gl.getFramebufferParameteriv(GL_DRAW_FRAMEBUFFER, m_glExtTokens.FRAMEBUFFER_DEFAULT_LAYERS, &nLayers);

	/* check if the reported value equals m_n_layers */
	if (current_n_layers != nLayers)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "FBO's default layers should be equal to " << m_n_layers
	<< "but is " << nLayers << tcu::TestLog::EndMessage;

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

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

	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not execute a draw call!");

	/* Verify result texture data */
	gl.bindFramebuffer(GL_READ_FRAMEBUFFER, m_fbo_id);

	for (int n_layer = 0; n_layer < m_n_layers && !test_failed; ++n_layer)
	{
	gl.framebufferTextureLayer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_to_id, 0 /* level */, n_layer);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not bind texture as color attachment to framebuffer!");

	if (gl.checkFramebufferStatus(GL_READ_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
	{
	TCU_FAIL("Read framebuffer is not complete!");
	}

	gl.memoryBarrier(GL_FRAMEBUFFER_BARRIER_BIT);

	gl.readPixels(0 /* x /, 0 / y */, m_width, m_height, GL_RGBA_INTEGER, GL_INT, m_layer_data);

	GLU_EXPECT_NO_ERROR(gl.getError(),
	"Could not read back pixels from the texture bound to color attachment!");

	/* Perform the verification */
	const int referenceColor[4] = { 0, 255, 0, 0 };

	for (int nPx = 0; nPx < m_width * m_height; ++nPx)
	{
	if (m_layer_data[nPx * m_n_texture_components + 0] != referenceColor[0] \|\|
	m_layer_data[nPx * m_n_texture_components + 1] != referenceColor[1] \|\|
	m_layer_data[nPx * m_n_texture_components + 2] != referenceColor[2] \|\|
	m_layer_data[nPx * m_n_texture_components + 3] != referenceColor[3])
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "The test failed: Pixel " << nPx << " from layer "
	<< n_layer << " is set to [" << m_layer_data[nPx * m_n_texture_components + 0]
	<< "," << m_layer_data[nPx * m_n_texture_components + 1] << ","
	<< m_layer_data[nPx * m_n_texture_components + 2] << ","
	<< m_layer_data[nPx * m_n_texture_components + 3] << "] but should be equal to ["
	<< referenceColor[0] << "," << referenceColor[1] << "," << referenceColor[2]
	<< "," << referenceColor[3] << ","
	<< "]" << tcu::TestLog::EndMessage;

	test_failed = true;
	break;
	} /* if (result pixel is invalid) */
	} /* for (all pixels) */
	} /* for (all layers) */

	/* Restore the FBO to no-attachment state for the next iteration */
	gl.framebufferTextureLayer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 0, 0, 0);

	} /* for (both iterations) */

	if (test_failed)
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
	else
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");

	return STOP;
	}

	} // namespace glcts