modules/gles31/functional/es31fProgramStateQueryTests.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES 3.1 Module
 * -------------------------------------------------
 *
 * Copyright 2015 The Android Open Source Project
 *
 * 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 Program State Query tests.
 *//*--------------------------------------------------------------------*/

#include "es31fProgramStateQueryTests.hpp"
#include "es31fInfoLogQueryShared.hpp"
#include "glsStateQueryUtil.hpp"
#include "gluRenderContext.hpp"
#include "gluCallLogWrapper.hpp"
#include "gluContextInfo.hpp"
#include "gluObjectWrapper.hpp"
#include "gluShaderProgram.hpp"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"
#include "tcuStringTemplate.hpp"

namespace deqp
{

using std::string;
using std::map;

namespace gles31
{
namespace Functional
{
namespace
{

using namespace gls::StateQueryUtil;

static const char* getVerifierSuffix (QueryType type)
{
	switch (type)
	{
		case QUERY_PROGRAM_INTEGER_VEC3:
		case QUERY_PROGRAM_INTEGER:
			return "get_programiv";

		default:
			DE_ASSERT(DE_FALSE);
			return DE_NULL;
	}
}

static std::string specializeShader(Context& context, const char* code)
{
	const glu::GLSLVersion				glslVersion			= glu::getContextTypeGLSLVersion(context.getRenderContext().getType());
	std::map<std::string, std::string>	specializationMap;

	specializationMap["GLSL_VERSION_DECL"] = glu::getGLSLVersionDeclaration(glslVersion);

	if (glu::contextSupports(context.getRenderContext().getType(), glu::ApiType::es(3, 2)))
	{
		specializationMap["GEOMETRY_SHADER_REQUIRE"] = "";
		specializationMap["TESSELLATION_SHADER_REQUIRE"] = "";
	}
	else
	{
		specializationMap["GEOMETRY_SHADER_REQUIRE"] = "#extension GL_EXT_geometry_shader : require";
		specializationMap["TESSELLATION_SHADER_REQUIRE"] = "#extension GL_EXT_tessellation_shader : require";
	}

	return tcu::StringTemplate(code).specialize(specializationMap);
}


class GeometryShaderCase : public TestCase
{
public:
						GeometryShaderCase		(Context& context, QueryType verifier, const char* name, const char* desc);
	IterateResult		iterate					(void);

private:
	const QueryType		m_verifier;
};

GeometryShaderCase::GeometryShaderCase (Context& context, QueryType verifier, const char* name, const char* desc)
	: TestCase		(context, name, desc)
	, m_verifier	(verifier)
{
}

GeometryShaderCase::IterateResult GeometryShaderCase::iterate (void)
{
	const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));

	if (!supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
		TCU_THROW(NotSupportedError, "Geometry shader tests require GL_EXT_geometry_shader extension or an OpenGL ES 3.2 or higher context.");


	static const char* const	s_vtxFragTemplate	=	"${GLSL_VERSION_DECL}\n"
														"void main()\n"
														"{\n"
														"}\n";

	static const char* const	s_geometryTemplate1	=	"${GLSL_VERSION_DECL}\n"
														"${GEOMETRY_SHADER_REQUIRE}\n"
														"layout(triangles) in;"
														"layout(triangle_strip, max_vertices = 3) out;\n"
														"void main()\n"
														"{\n"
														"   EndPrimitive();\n"
														"}\n";

	static const char* const	s_geometryTemplate2	=	"${GLSL_VERSION_DECL}\n"
														"${GEOMETRY_SHADER_REQUIRE}\n"
														"layout(points) in;"
														"layout(line_strip, max_vertices = 5) out;\n"
														"void main()\n"
														"{\n"
														"   EndPrimitive();\n"
														"}\n";

	static const char* const	s_geometryTemplate3	=	"${GLSL_VERSION_DECL}\n"
														"${GEOMETRY_SHADER_REQUIRE}\n"
														"layout(points) in;"
														"layout(points, max_vertices = 50) out;\n"
														"void main()\n"
														"{\n"
														"   EndPrimitive();\n"
														"}\n";

	glu::CallLogWrapper			gl						(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
	tcu::ResultCollector		result					(m_testCtx.getLog(), " // ERROR: ");

	gl.enableLogging(true);

	{
		const tcu::ScopedLogSection	section		(m_testCtx.getLog(), "Layout", "triangles in, triangle strip out, 3 vertices");
		glu::ShaderProgram			program		(m_context.getRenderContext(), glu::ProgramSources()
			<< glu::VertexSource(specializeShader(m_context, s_vtxFragTemplate))
			<< glu::FragmentSource(specializeShader(m_context, s_vtxFragTemplate))
			<< glu::GeometrySource(specializeShader(m_context, s_geometryTemplate1)));

		TCU_CHECK_MSG(program.isOk(), "Compile failed");

		m_testCtx.getLog() << program;

		verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_VERTICES_OUT, 3, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_INPUT_TYPE, GL_TRIANGLES, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_OUTPUT_TYPE, GL_TRIANGLE_STRIP, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_SHADER_INVOCATIONS, 1, m_verifier);
	}

	{
		const tcu::ScopedLogSection	section		(m_testCtx.getLog(), "Layout", "points in, line strip out, 5 vertices");
		glu::ShaderProgram			program		(m_context.getRenderContext(), glu::ProgramSources()
			<< glu::VertexSource(specializeShader(m_context, s_vtxFragTemplate))
			<< glu::FragmentSource(specializeShader(m_context, s_vtxFragTemplate))
			<< glu::GeometrySource(specializeShader(m_context, s_geometryTemplate2)));

		TCU_CHECK_MSG(program.isOk(), "Compile failed");

		m_testCtx.getLog() << program;

		verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_VERTICES_OUT, 5, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_INPUT_TYPE, GL_POINTS, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_OUTPUT_TYPE, GL_LINE_STRIP, m_verifier);
	}

	{
		const tcu::ScopedLogSection	section		(m_testCtx.getLog(), "Layout", "points in, points out, 50 vertices");
		glu::ShaderProgram			program		(m_context.getRenderContext(), glu::ProgramSources()
			<< glu::VertexSource(specializeShader(m_context, s_vtxFragTemplate))
			<< glu::FragmentSource(specializeShader(m_context, s_vtxFragTemplate))
			<< glu::GeometrySource(specializeShader(m_context, s_geometryTemplate3)));

		TCU_CHECK_MSG(program.isOk(), "Compile failed");

		m_testCtx.getLog() << program;

		verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_VERTICES_OUT, 50, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_INPUT_TYPE, GL_POINTS, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_OUTPUT_TYPE, GL_POINTS, m_verifier);
	}

	result.setTestContextResult(m_testCtx);
	return STOP;
}

class TessellationShaderCase : public TestCase
{
public:
						TessellationShaderCase		(Context& context, QueryType verifier, const char* name, const char* desc);
	IterateResult		iterate					(void);

private:
	const QueryType		m_verifier;
};

TessellationShaderCase::TessellationShaderCase (Context& context, QueryType verifier, const char* name, const char* desc)
	: TestCase		(context, name, desc)
	, m_verifier	(verifier)
{
}

TessellationShaderCase::IterateResult TessellationShaderCase::iterate (void)
{
	const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));

	if (!supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader"))
		TCU_THROW(NotSupportedError, "Tessellation shader tests require GL_EXT_tessellation_shader extension or an OpenGL ES 3.2 or higher context.");


	static const char* const	s_vtxFragTemplate	=	"${GLSL_VERSION_DECL}\n"
														"void main()\n"
														"{\n"
														"}\n";

	static const char* const	s_tessCtrlTemplate1	=	"${GLSL_VERSION_DECL}\n"
														"${TESSELLATION_SHADER_REQUIRE}\n"
														"layout(vertices = 3) out;\n"
														"void main()\n"
														"{\n"
														"}\n";

	static const char* const	s_tessEvalTemplate1	=	"${GLSL_VERSION_DECL}\n"
														"${TESSELLATION_SHADER_REQUIRE}\n"
														"layout(triangles, equal_spacing, cw) in;\n"
														"void main()\n"
														"{\n"
														"}\n";

	static const char* const	s_tessCtrlTemplate2	=	"${GLSL_VERSION_DECL}\n"
														"${TESSELLATION_SHADER_REQUIRE}\n"
														"layout(vertices = 5) out;\n"
														"void main()\n"
														"{\n"
														"}\n";

	static const char* const	s_tessEvalTemplate2	=	"${GLSL_VERSION_DECL}\n"
														"${TESSELLATION_SHADER_REQUIRE}\n"
														"layout(quads, fractional_even_spacing, ccw) in;\n"
														"void main()\n"
														"{\n"
														"}\n";

	static const char* const	s_tessEvalTemplate3	=	"${GLSL_VERSION_DECL}\n"
														"${TESSELLATION_SHADER_REQUIRE}\n"
														"layout(isolines, fractional_odd_spacing, ccw, point_mode) in;\n"
														"void main()\n"
														"{\n"
														"}\n";

	glu::CallLogWrapper			gl						(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
	tcu::ResultCollector		result					(m_testCtx.getLog(), " // ERROR: ");

	gl.enableLogging(true);

	{
		const tcu::ScopedLogSection	section		(m_testCtx.getLog(), "Query State", "3 vertices, triangles, equal_spacing, cw");
		glu::ShaderProgram			program		(m_context.getRenderContext(), glu::ProgramSources()
			<< glu::VertexSource(specializeShader(m_context, s_vtxFragTemplate))
			<< glu::FragmentSource(specializeShader(m_context, s_vtxFragTemplate))
			<< glu::TessellationControlSource(specializeShader(m_context, s_tessCtrlTemplate1))
			<< glu::TessellationEvaluationSource(specializeShader(m_context, s_tessEvalTemplate1)));

		TCU_CHECK_MSG(program.isOk(), "Compile failed");

		m_testCtx.getLog() << program;

		verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_CONTROL_OUTPUT_VERTICES, 3, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_MODE, GL_TRIANGLES, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_SPACING, GL_EQUAL, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_VERTEX_ORDER, GL_CW, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_POINT_MODE, GL_FALSE, m_verifier);
	}

	{
		const tcu::ScopedLogSection	section		(m_testCtx.getLog(), "Query State", "5 vertices, quads, fractional_even_spacing, ccw");
		glu::ShaderProgram			program		(m_context.getRenderContext(), glu::ProgramSources()
			<< glu::VertexSource(specializeShader(m_context, s_vtxFragTemplate))
			<< glu::FragmentSource(specializeShader(m_context, s_vtxFragTemplate))
			<< glu::TessellationControlSource(specializeShader(m_context, s_tessCtrlTemplate2))
			<< glu::TessellationEvaluationSource(specializeShader(m_context, s_tessEvalTemplate2)));

		TCU_CHECK_MSG(program.isOk(), "Compile failed");

		m_testCtx.getLog() << program;

		verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_CONTROL_OUTPUT_VERTICES, 5, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_MODE, GL_QUADS, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_SPACING, GL_FRACTIONAL_EVEN, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_VERTEX_ORDER, GL_CCW, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_POINT_MODE, GL_FALSE, m_verifier);
	}

	{
		const tcu::ScopedLogSection	section		(m_testCtx.getLog(), "Query State", "5 vertices, isolines, fractional_odd_spacing, ccw, point_mode");
		glu::ShaderProgram			program		(m_context.getRenderContext(), glu::ProgramSources()
			<< glu::VertexSource(specializeShader(m_context, s_vtxFragTemplate))
			<< glu::FragmentSource(specializeShader(m_context, s_vtxFragTemplate))
			<< glu::TessellationControlSource(specializeShader(m_context, s_tessCtrlTemplate2))
			<< glu::TessellationEvaluationSource(specializeShader(m_context, s_tessEvalTemplate3)));

		TCU_CHECK_MSG(program.isOk(), "Compile failed");

		m_testCtx.getLog() << program;

		verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_CONTROL_OUTPUT_VERTICES, 5, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_MODE, GL_ISOLINES, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_SPACING, GL_FRACTIONAL_ODD, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_VERTEX_ORDER, GL_CCW, m_verifier);
		verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_POINT_MODE, GL_TRUE, m_verifier);
	}

	result.setTestContextResult(m_testCtx);
	return STOP;
}

class ProgramSeparableCase : public TestCase
{
public:
						ProgramSeparableCase	(Context& context, QueryType verifier, const char* name, const char* desc);
	IterateResult		iterate					(void);

private:
	const QueryType		m_verifier;
};

ProgramSeparableCase::ProgramSeparableCase (Context& context, QueryType verifier, const char* name, const char* desc)
	: TestCase		(context, name, desc)
	, m_verifier	(verifier)
{
}

ProgramSeparableCase::IterateResult ProgramSeparableCase::iterate (void)
{
	const string				vtxTemplate	=	"${GLSL_VERSION_DECL}\n"
												"out highp vec4 v_color;\n"
												"void main()\n"
												"{\n"
												"	gl_Position = vec4(float(gl_VertexID) * 0.5, float(gl_VertexID+1) * 0.5, 0.0, 1.0);\n"
												"	v_color = vec4(float(gl_VertexID), 1.0, 0.0, 1.0);\n"
												"}\n";
	const string				fragTemplate =	"${GLSL_VERSION_DECL}\n"
												"in highp vec4 v_color;\n"
												"layout(location=0) out highp vec4 o_color;\n"
												"void main()\n"
												"{\n"
												"	o_color = v_color;\n"
												"}\n";

	glu::CallLogWrapper			gl				(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
	tcu::ResultCollector		result			(m_testCtx.getLog(), " // ERROR: ");
	glu::Shader					vtxShader		(m_context.getRenderContext(), glu::SHADERTYPE_VERTEX);
	glu::Shader					frgShader		(m_context.getRenderContext(), glu::SHADERTYPE_FRAGMENT);

	const std::string			vStr			= specializeShader(m_context, vtxTemplate.c_str());
	const std::string			fStr			= specializeShader(m_context, fragTemplate.c_str());
	const char* const			vtxSourcePtr	= vStr.c_str();
	const char* const			fragSourcePtr	= fStr.c_str();

	vtxShader.setSources(1, &vtxSourcePtr, DE_NULL);
	frgShader.setSources(1, &fragSourcePtr, DE_NULL);

	vtxShader.compile();
	frgShader.compile();

	{
		const tcu::ScopedLogSection section(m_testCtx.getLog(), "VtxShader", "Vertex shader");
		m_testCtx.getLog() << vtxShader;
	}

	{
		const tcu::ScopedLogSection section(m_testCtx.getLog(), "FrgShader", "Fragment shader");
		m_testCtx.getLog() << frgShader;
	}

	TCU_CHECK_MSG(vtxShader.getCompileStatus() && frgShader.getCompileStatus(), "failed to build shaders");

	gl.enableLogging(true);

	{
		const tcu::ScopedLogSection	section	(m_testCtx.getLog(), "Initial", "Initial");
		glu::Program				program	(m_context.getRenderContext());

		verifyStateProgramInteger(result, gl, program.getProgram(), GL_PROGRAM_SEPARABLE, 0, m_verifier);
	}

	{
		const tcu::ScopedLogSection section		(m_testCtx.getLog(), "SetFalse", "SetFalse");
		glu::Program				program		(m_context.getRenderContext());
		int							linkStatus	= 0;

		gl.glAttachShader(program.getProgram(), vtxShader.getShader());
		gl.glAttachShader(program.getProgram(), frgShader.getShader());
		gl.glProgramParameteri(program.getProgram(), GL_PROGRAM_SEPARABLE, GL_FALSE);
		gl.glLinkProgram(program.getProgram());
		GLU_EXPECT_NO_ERROR(gl.glGetError(), "setup program");

		gl.glGetProgramiv(program.getProgram(), GL_LINK_STATUS, &linkStatus);
		GLU_EXPECT_NO_ERROR(gl.glGetError(), "query link status");

		TCU_CHECK_MSG(linkStatus == GL_TRUE, "failed to link program");

		verifyStateProgramInteger(result, gl, program.getProgram(), GL_PROGRAM_SEPARABLE, 0, m_verifier);
	}

	{
		const tcu::ScopedLogSection section		(m_testCtx.getLog(), "SetTrue", "SetTrue");
		glu::Program				program		(m_context.getRenderContext());
		int							linkStatus	= 0;

		gl.glAttachShader(program.getProgram(), vtxShader.getShader());
		gl.glAttachShader(program.getProgram(), frgShader.getShader());
		gl.glProgramParameteri(program.getProgram(), GL_PROGRAM_SEPARABLE, GL_TRUE);
		gl.glLinkProgram(program.getProgram());
		GLU_EXPECT_NO_ERROR(gl.glGetError(), "setup program");

		gl.glGetProgramiv(program.getProgram(), GL_LINK_STATUS, &linkStatus);
		GLU_EXPECT_NO_ERROR(gl.glGetError(), "query link status");

		TCU_CHECK_MSG(linkStatus == GL_TRUE, "failed to link program");

		verifyStateProgramInteger(result, gl, program.getProgram(), GL_PROGRAM_SEPARABLE, GL_TRUE, m_verifier);
	}

	result.setTestContextResult(m_testCtx);
	return STOP;
}

class ComputeWorkGroupSizeCase : public TestCase
{
public:
						ComputeWorkGroupSizeCase	(Context& context, QueryType verifier, const char* name, const char* desc);
	IterateResult		iterate						(void);

private:
	const QueryType		m_verifier;
};

ComputeWorkGroupSizeCase::ComputeWorkGroupSizeCase (Context& context, QueryType verifier, const char* name, const char* desc)
	: TestCase		(context, name, desc)
	, m_verifier	(verifier)
{
}

ComputeWorkGroupSizeCase::IterateResult ComputeWorkGroupSizeCase::iterate (void)
{
	static const char* const	s_computeTemplate1D =	"${GLSL_VERSION_DECL}\n"
														"layout (local_size_x = 3) in;\n"
														"layout(binding = 0) buffer Output\n"
														"{\n"
														"	highp float val;\n"
														"} sb_out;\n"
														"\n"
														"void main (void)\n"
														"{\n"
														"	sb_out.val = 1.0;\n"
														"}\n";
	static const char* const	s_computeTemplate2D =	"${GLSL_VERSION_DECL}\n"
														"layout (local_size_x = 3, local_size_y = 2) in;\n"
														"layout(binding = 0) buffer Output\n"
														"{\n"
														"	highp float val;\n"
														"} sb_out;\n"
														"\n"
														"void main (void)\n"
														"{\n"
														"	sb_out.val = 1.0;\n"
														"}\n";
	static const char* const	s_computeTemplate3D =	"${GLSL_VERSION_DECL}\n"
														"layout (local_size_x = 3, local_size_y = 2, local_size_z = 4) in;\n"
														"layout(binding = 0) buffer Output\n"
														"{\n"
														"	highp float val;\n"
														"} sb_out;\n"
														"\n"
														"void main (void)\n"
														"{\n"
														"	sb_out.val = 1.0;\n"
														"}\n";

	glu::CallLogWrapper			gl						(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
	tcu::ResultCollector		result					(m_testCtx.getLog(), " // ERROR: ");

	gl.enableLogging(true);

	{
		const tcu::ScopedLogSection section		(m_testCtx.getLog(), "OneDimensional", "1D");
		glu::ShaderProgram			program		(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(specializeShader(m_context, s_computeTemplate1D)));

		m_testCtx.getLog() << program;

		TCU_CHECK_MSG(program.isOk(), "failed to build program");

		verifyStateProgramIntegerVec3(result, gl, program.getProgram(), GL_COMPUTE_WORK_GROUP_SIZE, tcu::IVec3(3, 1, 1), m_verifier);
	}

	{
		const tcu::ScopedLogSection section		(m_testCtx.getLog(), "TwoDimensional", "2D");
		glu::ShaderProgram			program		(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(specializeShader(m_context, s_computeTemplate2D)));

		m_testCtx.getLog() << program;

		TCU_CHECK_MSG(program.isOk(), "failed to build program");

		verifyStateProgramIntegerVec3(result, gl, program.getProgram(), GL_COMPUTE_WORK_GROUP_SIZE, tcu::IVec3(3, 2, 1), m_verifier);
	}

	{
		const tcu::ScopedLogSection section		(m_testCtx.getLog(), "TreeDimensional", "3D");
		glu::ShaderProgram			program		(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(specializeShader(m_context, s_computeTemplate3D)));

		m_testCtx.getLog() << program;

		TCU_CHECK_MSG(program.isOk(), "failed to build program");

		verifyStateProgramIntegerVec3(result, gl, program.getProgram(), GL_COMPUTE_WORK_GROUP_SIZE, tcu::IVec3(3, 2, 4), m_verifier);
	}

	result.setTestContextResult(m_testCtx);
	return STOP;
}

class ActiveAtomicCounterBuffersCase : public TestCase
{
public:
						ActiveAtomicCounterBuffersCase	(Context& context, QueryType verifier, const char* name, const char* desc);
	IterateResult		iterate							(void);

private:
	const QueryType		m_verifier;
};

ActiveAtomicCounterBuffersCase::ActiveAtomicCounterBuffersCase (Context& context, QueryType verifier, const char* name, const char* desc)
	: TestCase		(context, name, desc)
	, m_verifier	(verifier)
{
}

ActiveAtomicCounterBuffersCase::IterateResult ActiveAtomicCounterBuffersCase::iterate (void)
{
	static const char* const	s_computeTemplate0	=	"${GLSL_VERSION_DECL}\n"
														"layout (local_size_x = 3) in;\n"
														"layout(binding = 0) buffer Output\n"
														"{\n"
														"	highp float val;\n"
														"} sb_out;\n"
														"\n"
														"void main (void)\n"
														"{\n"
														"	sb_out.val = 1.0;\n"
														"}\n";
	static const char* const	s_computeTemplate1	=	"${GLSL_VERSION_DECL}\n"
														"layout (local_size_x = 3) in;\n"
														"layout(binding = 0) uniform highp atomic_uint u_counters[2];\n"
														"layout(binding = 0) buffer Output\n"
														"{\n"
														"	highp float val;\n"
														"} sb_out;\n"
														"\n"
														"void main (void)\n"
														"{\n"
														"	sb_out.val = float(atomicCounterIncrement(u_counters[0])) + float(atomicCounterIncrement(u_counters[1]));\n"
														"}\n";

	glu::CallLogWrapper			gl						(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
	tcu::ResultCollector		result					(m_testCtx.getLog(), " // ERROR: ");

	gl.enableLogging(true);

	{
		const tcu::ScopedLogSection	section		(m_testCtx.getLog(), "Initial", "Initial");
		glu::Program				program		(m_context.getRenderContext());

		verifyStateProgramInteger(result, gl, program.getProgram(), GL_ACTIVE_ATOMIC_COUNTER_BUFFERS, 0, m_verifier);
	}

	{
		const tcu::ScopedLogSection	section		(m_testCtx.getLog(), "NoBuffers", "No buffers");
		glu::ShaderProgram			program		(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(specializeShader(m_context, s_computeTemplate0)));

		m_testCtx.getLog() << program;

		TCU_CHECK_MSG(program.isOk(), "failed to build program");

		verifyStateProgramInteger(result, gl, program.getProgram(), GL_ACTIVE_ATOMIC_COUNTER_BUFFERS, 0, m_verifier);
	}

	{
		const tcu::ScopedLogSection	section		(m_testCtx.getLog(), "OneBuffer", "One buffer");
		glu::ShaderProgram			program		(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(specializeShader(m_context, s_computeTemplate1)));

		m_testCtx.getLog() << program;

		TCU_CHECK_MSG(program.isOk(), "failed to build program");

		verifyStateProgramInteger(result, gl, program.getProgram(), GL_ACTIVE_ATOMIC_COUNTER_BUFFERS, 1, m_verifier);
	}

	result.setTestContextResult(m_testCtx);
	return STOP;
}

class ProgramLogCase : public TestCase
{
public:
	enum BuildErrorType
	{
		BUILDERROR_VERTEX_FRAGMENT = 0,
		BUILDERROR_COMPUTE,
		BUILDERROR_GEOMETRY,
		BUILDERROR_TESSELLATION,
	};

							ProgramLogCase		(Context& ctx, const char* name, const char* desc, BuildErrorType errorType);

private:
	void					init				(void);
	IterateResult			iterate				(void);
	glu::ProgramSources		getProgramSources	(void) const;

	const BuildErrorType	m_buildErrorType;
};

ProgramLogCase::ProgramLogCase (Context& ctx, const char* name, const char* desc, BuildErrorType errorType)
	: TestCase			(ctx, name, desc)
	, m_buildErrorType	(errorType)
{
}

void ProgramLogCase::init (void)
{
	const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));

	switch (m_buildErrorType)
	{
		case BUILDERROR_VERTEX_FRAGMENT:
		case BUILDERROR_COMPUTE:
			break;

		case BUILDERROR_GEOMETRY:
			if (!supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
				TCU_THROW(NotSupportedError, "Test requires GL_EXT_geometry_shader extension");
			break;

		case BUILDERROR_TESSELLATION:
			if (!supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader"))
				TCU_THROW(NotSupportedError, "Test requires GL_EXT_tessellation_shader extension");
			break;

		default:
			DE_ASSERT(false);
			break;
	}
}

ProgramLogCase::IterateResult ProgramLogCase::iterate (void)
{
	using gls::StateQueryUtil::StateQueryMemoryWriteGuard;

	tcu::ResultCollector					result		(m_testCtx.getLog());
	glu::CallLogWrapper						gl			(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
	glu::ShaderProgram						program		(m_context.getRenderContext(), getProgramSources());
	StateQueryMemoryWriteGuard<glw::GLint>	logLen;

	gl.enableLogging(true);

	m_testCtx.getLog() << tcu::TestLog::Message << "Trying to link a broken program." << tcu::TestLog::EndMessage;

	gl.glGetProgramiv(program.getProgram(), GL_INFO_LOG_LENGTH, &logLen);
	logLen.verifyValidity(result);

	if (logLen.verifyValidity(result))
		verifyInfoLogQuery(result, gl, logLen, program.getProgram(), &glu::CallLogWrapper::glGetProgramInfoLog, "glGetProgramInfoLog");

	result.setTestContextResult(m_testCtx);
	return STOP;
}

glu::ProgramSources ProgramLogCase::getProgramSources (void) const
{
	const char* const	vertexTemplate1 =	"${GLSL_VERSION_DECL}\n"
											"in highp vec4 a_pos;\n"
											"uniform highp vec4 u_uniform;\n"
											"void main()\n"
											"{\n"
											"	gl_Position = a_pos + u_uniform;\n"
											"}\n";
	const char* const	vertexTemplate2 =	"${GLSL_VERSION_DECL}\n"
											"in highp vec4 a_pos;\n"
											"void main()\n"
											"{\n"
											"	gl_Position = a_pos;\n"
											"}\n";
	const char* const	fragmentTemplate1 =	"${GLSL_VERSION_DECL}\n"
											"in highp vec4 v_missingVar;\n"
											"uniform highp int u_uniform;\n"
											"layout(location = 0) out mediump vec4 fragColor;\n"
											"void main()\n"
											"{\n"
											"	fragColor = v_missingVar + vec4(float(u_uniform));\n"
											"}\n";

	const char* const	fragmentTemplate2 =	"${GLSL_VERSION_DECL}\n"
											"layout(location = 0) out mediump vec4 fragColor;\n"
											"void main()\n"
											"{\n"
											"	fragColor = vec4(1.0);\n"
											"}\n";
	const char* const	computeTemplate1 =	"${GLSL_VERSION_DECL}\n"
											"layout (binding = 0) buffer IOBuffer { highp float buf_var; };\n"
											"uniform highp vec4 u_uniform;\n"
											"void main()\n"
											"{\n"
											"	buf_var = u_uniform.x;\n"
											"}\n";
	const char* const	geometryTemplate1 =	"${GLSL_VERSION_DECL}\n"
											"${GEOMETRY_SHADER_REQUIRE}\n"
											"layout(triangles) in;\n"
											"layout(max_vertices=1, points) out;\n"
											"in highp vec4 v_missingVar[];\n"
											"uniform highp int u_uniform;\n"
											"void main()\n"
											"{\n"
											"	gl_Position = gl_in[0].gl_Position + v_missingVar[2] + vec4(float(u_uniform));\n"
											"	EmitVertex();\n"
											"}\n";
	const char* const	tessCtrlTemplate1 =	"${GLSL_VERSION_DECL}\n"
											"${TESSELLATION_SHADER_REQUIRE}\n"
											"layout(vertices=2) out;"
											"patch out highp vec2 vp_var;\n"
											"void main()\n"
											"{\n"
											"	gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position\n"
											"	gl_TessLevelOuter[0] = 0.8;\n"
											"	gl_TessLevelOuter[1] = 0.8;\n"
											"	if (gl_InvocationID == 0)\n"
											"		vp_var = gl_in[gl_InvocationID].gl_Position.xy;\n"
											"}\n";
	const char* const	tessEvalTemplate1 =	"${GLSL_VERSION_DECL}\n"
											"${TESSELLATION_SHADER_REQUIRE}\n"
											"layout(isolines) in;"
											"in highp float vp_var[];\n"
											"void main()\n"
											"{\n"
											"	gl_Position = gl_in[gl_InvocationID].gl_Position + vec4(vp_var[1]);\n"
											"}\n";

	switch (m_buildErrorType)
	{
		case BUILDERROR_VERTEX_FRAGMENT:
			return glu::ProgramSources()
					<< glu::VertexSource(specializeShader(m_context, vertexTemplate1))
					<< glu::FragmentSource(specializeShader(m_context, fragmentTemplate1));

		case BUILDERROR_COMPUTE:
			return glu::ProgramSources()
					<< glu::ComputeSource(specializeShader(m_context, computeTemplate1));

		case BUILDERROR_GEOMETRY:
			return glu::ProgramSources()
					<< glu::VertexSource(specializeShader(m_context, vertexTemplate1))
					<< glu::GeometrySource(specializeShader(m_context, geometryTemplate1))
					<< glu::FragmentSource(specializeShader(m_context, fragmentTemplate2));

		case BUILDERROR_TESSELLATION:
			return glu::ProgramSources()
					<< glu::VertexSource(specializeShader(m_context, vertexTemplate2))
					<< glu::TessellationControlSource(specializeShader(m_context, tessCtrlTemplate1))
					<< glu::TessellationEvaluationSource(specializeShader(m_context, tessEvalTemplate1))
					<< glu::FragmentSource(specializeShader(m_context, fragmentTemplate2));

		default:
			DE_ASSERT(false);
			return glu::ProgramSources();
	}
}

} // anonymous

ProgramStateQueryTests::ProgramStateQueryTests (Context& context)
	: TestCaseGroup(context, "program", "Program State Query tests")
{
}

ProgramStateQueryTests::~ProgramStateQueryTests (void)
{
}

void ProgramStateQueryTests::init (void)
{
	static const QueryType intVerifiers[] =
	{
		QUERY_PROGRAM_INTEGER,
	};
	static const QueryType intVec3Verifiers[] =
	{
		QUERY_PROGRAM_INTEGER_VEC3,
	};

#define FOR_EACH_INT_VERIFIER(X) \
	for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(intVerifiers); ++verifierNdx)	\
	{																							\
		const char* verifierSuffix = getVerifierSuffix(intVerifiers[verifierNdx]);				\
		const QueryType verifier = intVerifiers[verifierNdx];									\
		this->addChild(X);																		\
	}

#define FOR_EACH_VEC_VERIFIER(X) \
	for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(intVec3Verifiers); ++verifierNdx)	\
	{																								\
		const char* verifierSuffix = getVerifierSuffix(intVec3Verifiers[verifierNdx]);				\
		const QueryType verifier = intVec3Verifiers[verifierNdx];									\
		this->addChild(X);																			\
	}

	FOR_EACH_INT_VERIFIER(new ProgramSeparableCase				(m_context, verifier, (std::string("program_separable_") + verifierSuffix).c_str(),				"Test PROGRAM_SEPARABLE"));
	FOR_EACH_VEC_VERIFIER(new ComputeWorkGroupSizeCase			(m_context, verifier, (std::string("compute_work_group_size_") + verifierSuffix).c_str(),		"Test COMPUTE_WORK_GROUP_SIZE"));
	FOR_EACH_INT_VERIFIER(new ActiveAtomicCounterBuffersCase	(m_context, verifier, (std::string("active_atomic_counter_buffers_") + verifierSuffix).c_str(),	"Test ACTIVE_ATOMIC_COUNTER_BUFFERS"));
	FOR_EACH_INT_VERIFIER(new GeometryShaderCase				(m_context, verifier, (std::string("geometry_shader_state_") + verifierSuffix).c_str(),			"Test Geometry Shader State"));
	FOR_EACH_INT_VERIFIER(new TessellationShaderCase			(m_context, verifier, (std::string("tesselation_shader_state_") + verifierSuffix).c_str(),		"Test Tesselation Shader State"));

#undef FOR_EACH_INT_VERIFIER
#undef FOR_EACH_VEC_VERIFIER

	// program info log tests
	// \note, there exists similar tests in gles3 module. However, the gles31 could use a different
	//        shader compiler with different INFO_LOG bugs.
	{
		static const struct
		{
			const char*						caseName;
			ProgramLogCase::BuildErrorType	caseType;
		} shaderTypes[] =
		{
			{ "info_log_vertex_fragment_link_fail",		ProgramLogCase::BUILDERROR_VERTEX_FRAGMENT	},
			{ "info_log_compute_link_fail",				ProgramLogCase::BUILDERROR_COMPUTE			},
			{ "info_log_geometry_link_fail",			ProgramLogCase::BUILDERROR_GEOMETRY			},
			{ "info_log_tessellation_link_fail",		ProgramLogCase::BUILDERROR_TESSELLATION		},
		};

		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(shaderTypes); ++ndx)
			addChild(new ProgramLogCase(m_context, shaderTypes[ndx].caseName, "", shaderTypes[ndx].caseType));
	}
}

} // Functional
} // gles31
} // deqp