xref: /third_party/vk-gl-cts/modules/gles31/functional/es31fProgramPipelineStateQueryTests.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 Pipeline State Query tests.
 *//*--------------------------------------------------------------------*/

#include "es31fProgramPipelineStateQueryTests.hpp"
#include "es31fInfoLogQueryShared.hpp"
#include "glsStateQueryUtil.hpp"
#include "gluRenderContext.hpp"
#include "gluCallLogWrapper.hpp"
#include "gluObjectWrapper.hpp"
#include "gluShaderProgram.hpp"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"

namespace deqp
{
namespace gles31
{
namespace Functional
{
namespace
{

using namespace gls::StateQueryUtil;

static const char* getVerifierSuffix (QueryType type)
{
	switch (type)
	{
		case QUERY_PIPELINE_INTEGER:	return "get_program_pipelineiv";
		default:
			DE_ASSERT(DE_FALSE);
			return DE_NULL;
	}
}

static const char* const s_vertexSource =		"#version 310 es\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";
static const char* const s_fragmentSource =		"#version 310 es\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";
static const char* const s_computeSource =		"#version 310 es\n"
												"layout (local_size_x = 1, local_size_y = 1) 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";

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

private:
	const QueryType		m_verifier;
};

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

ActiveProgramCase::IterateResult ActiveProgramCase::iterate (void)
{
	const glu::ShaderProgram	vtxProgram	(m_context.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << glu::VertexSource(s_vertexSource));
	const glu::ShaderProgram	frgProgram	(m_context.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << glu::FragmentSource(s_fragmentSource));
	const glu::ProgramPipeline	pipeline	(m_context.getRenderContext());
	glu::CallLogWrapper			gl			(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
	tcu::ResultCollector		result		(m_testCtx.getLog(), " // ERROR: ");

	{
		const tcu::ScopedLogSection section(m_testCtx.getLog(), "VtxProg", "Vertex program");
		m_testCtx.getLog() << vtxProgram;
	}

	{
		const tcu::ScopedLogSection section(m_testCtx.getLog(), "FrgProg", "Fragment program");
		m_testCtx.getLog() << frgProgram;
	}

	if (!vtxProgram.isOk() || !frgProgram.isOk())
		throw tcu::TestError("failed to build program");

	gl.enableLogging(true);
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");

	gl.glBindProgramPipeline(pipeline.getPipeline());
	gl.glUseProgramStages(pipeline.getPipeline(), GL_VERTEX_SHADER_BIT, vtxProgram.getProgram());
	gl.glUseProgramStages(pipeline.getPipeline(), GL_FRAGMENT_SHADER_BIT, frgProgram.getProgram());
	GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen pipeline");
	gl.glBindProgramPipeline(0);
	GLU_EXPECT_NO_ERROR(gl.glGetError(), "unbind pipeline");

	{
		const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
		verifyStatePipelineInteger(result, gl, pipeline.getPipeline(), GL_ACTIVE_PROGRAM, 0, m_verifier);
	}

	{
		const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");

		gl.glActiveShaderProgram(pipeline.getPipeline(), frgProgram.getProgram());
		GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen pipeline");
		verifyStatePipelineInteger(result, gl, pipeline.getPipeline(), GL_ACTIVE_PROGRAM, (int)frgProgram.getProgram(), m_verifier);
	}

	result.setTestContextResult(m_testCtx);
	return STOP;
}

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

private:
	const QueryType		m_verifier;
	const glw::GLenum	m_targetStage;
};

PipelineProgramCase::PipelineProgramCase (Context& context, QueryType verifier, const char* name, const char* desc, glw::GLenum stage)
	: TestCase		(context, name, desc)
	, m_verifier	(verifier)
	, m_targetStage	(stage)
{
}

PipelineProgramCase::IterateResult PipelineProgramCase::iterate (void)
{
	glu::CallLogWrapper		gl			(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
	tcu::ResultCollector	result		(m_testCtx.getLog(), " // ERROR: ");
	const int				stageBit	= (m_targetStage == GL_VERTEX_SHADER)	? (GL_VERTEX_SHADER_BIT)
										: (m_targetStage == GL_FRAGMENT_SHADER)	? (GL_FRAGMENT_SHADER_BIT)
										: (GL_COMPUTE_SHADER_BIT);
	glu::ProgramSources	sources;

	if (m_targetStage == GL_VERTEX_SHADER)
		sources << glu::ProgramSeparable(true) << glu::VertexSource(s_vertexSource);
	else if (m_targetStage == GL_FRAGMENT_SHADER)
		sources << glu::ProgramSeparable(true) << glu::FragmentSource(s_fragmentSource);
	else if (m_targetStage == GL_COMPUTE_SHADER)
		sources << glu::ProgramSeparable(true) << glu::ComputeSource(s_computeSource);
	else
		DE_ASSERT(false);

	gl.enableLogging(true);

	{
		glu::ShaderProgram program(m_context.getRenderContext(), sources);

		{
			const tcu::ScopedLogSection section(m_testCtx.getLog(), "program", "Program");
			m_testCtx.getLog() << program;
		}

		if (!program.isOk())
			throw tcu::TestError("failed to build program");

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

			gl.glBindProgramPipeline(pipeline.getPipeline());
			GLU_EXPECT_NO_ERROR(gl.glGetError(), "setup pipeline");

			verifyStatePipelineInteger(result, gl, pipeline.getPipeline(), m_targetStage, 0, m_verifier);
		}

		{
			const tcu::ScopedLogSection section		(m_testCtx.getLog(), "Set", "Set");
			glu::ProgramPipeline		pipeline	(m_context.getRenderContext());

			gl.glBindProgramPipeline(pipeline.getPipeline());
			gl.glUseProgramStages(pipeline.getPipeline(), stageBit, program.getProgram());
			GLU_EXPECT_NO_ERROR(gl.glGetError(), "setup pipeline");

			verifyStatePipelineInteger(result, gl, pipeline.getPipeline(), m_targetStage, program.getProgram(), m_verifier);
		}
	}

	result.setTestContextResult(m_testCtx);
	return STOP;
}

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

private:
	const QueryType		m_verifier;
};

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

ValidateStatusCase::IterateResult ValidateStatusCase::iterate (void)
{
	glu::ShaderProgram		vtxProgram	(m_context.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << glu::VertexSource(s_vertexSource));
	glu::ShaderProgram		frgProgram	(m_context.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << glu::FragmentSource(s_fragmentSource));
	glu::ProgramPipeline	pipeline	(m_context.getRenderContext());
	glu::CallLogWrapper		gl			(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
	tcu::ResultCollector	result		(m_testCtx.getLog(), " // ERROR: ");

	{
		const tcu::ScopedLogSection section(m_testCtx.getLog(), "VtxProg", "Vertex program");
		m_testCtx.getLog() << vtxProgram;
	}

	{
		const tcu::ScopedLogSection section(m_testCtx.getLog(), "FrgProg", "Fragment program");
		m_testCtx.getLog() << frgProgram;
	}

	if (!vtxProgram.isOk() || !frgProgram.isOk())
		throw tcu::TestError("failed to build program");

	gl.enableLogging(true);

	gl.glBindProgramPipeline(pipeline.getPipeline());
	gl.glUseProgramStages(pipeline.getPipeline(), GL_VERTEX_SHADER_BIT, vtxProgram.getProgram());
	gl.glUseProgramStages(pipeline.getPipeline(), GL_FRAGMENT_SHADER_BIT, frgProgram.getProgram());
	GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen pipeline");
	gl.glBindProgramPipeline(0);
	GLU_EXPECT_NO_ERROR(gl.glGetError(), "unbind pipeline");

	{
		const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
		verifyStatePipelineInteger(result, gl, pipeline.getPipeline(), GL_VALIDATE_STATUS, 0, m_verifier);
	}

	{
		const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Validate");

		gl.glValidateProgramPipeline(pipeline.getPipeline());
		GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen pipeline");
		verifyStatePipelineInteger(result, gl, pipeline.getPipeline(), GL_VALIDATE_STATUS, GL_TRUE, m_verifier);
	}

	result.setTestContextResult(m_testCtx);
	return STOP;
}

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

InfoLogCase::InfoLogCase (Context& context, const char* name, const char* desc)
	: TestCase(context, name, desc)
{
}

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

	static const char* const s_incompatibleFragmentSource = "#version 310 es\n"
															"in mediump vec2 v_colorB;\n"
															"in mediump vec2 v_colorC;\n"
															"layout(location=0) out highp vec4 o_color;\n"
															"void main()\n"
															"{\n"
															"	o_color = v_colorB.xxyy + v_colorC.yyxy;\n"
															"}\n";

	glu::ShaderProgram		vtxProgram	(m_context.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << glu::VertexSource(s_vertexSource));
	glu::ShaderProgram		frgProgram	(m_context.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << glu::FragmentSource(s_incompatibleFragmentSource));
	glu::CallLogWrapper		gl			(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
	tcu::ResultCollector	result		(m_testCtx.getLog(), " // ERROR: ");

	{
		const tcu::ScopedLogSection section(m_testCtx.getLog(), "VtxProg", "Vertex program");
		m_testCtx.getLog() << vtxProgram;
	}

	{
		const tcu::ScopedLogSection section(m_testCtx.getLog(), "FrgProg", "Fragment program");
		m_testCtx.getLog() << frgProgram;
	}

	if (!vtxProgram.isOk() || !frgProgram.isOk())
		throw tcu::TestError("failed to build program");

	gl.enableLogging(true);

	{
		const tcu::ScopedLogSection section		(m_testCtx.getLog(), "Initial", "Initial");
		glu::ProgramPipeline		pipeline	(m_context.getRenderContext());
		std::string					buf			(3, 'X');
		int							written		= -1;

		verifyStatePipelineInteger(result, gl, pipeline.getPipeline(), GL_INFO_LOG_LENGTH, 0, QUERY_PIPELINE_INTEGER);

		gl.glGetProgramPipelineInfoLog(pipeline.getPipeline(), 2, &written, &buf[0]);
		GLU_EXPECT_NO_ERROR(gl.glGetError(), "query log");

		if (written == -1)
			result.fail("'length' was not written to");
		else if (written != 0)
			result.fail("'length' was not 0");
		else if (buf[0] != '\0')
			result.fail("log was not 0-sized null-terminated string");
		else if (buf[1] != 'X' || buf[2] != 'X')
			result.fail("buffer after returned length modified");
	}

	{
		const tcu::ScopedLogSection				superSection	(m_testCtx.getLog(), "ValidationFail", "Failed validation");
		glu::ProgramPipeline					pipeline		(m_context.getRenderContext());
		StateQueryMemoryWriteGuard<glw::GLint>	logLen;

		gl.glBindProgramPipeline(pipeline.getPipeline());
		gl.glUseProgramStages(pipeline.getPipeline(), GL_VERTEX_SHADER_BIT, vtxProgram.getProgram());
		gl.glUseProgramStages(pipeline.getPipeline(), GL_FRAGMENT_SHADER_BIT, frgProgram.getProgram());
		GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen pipeline");

		gl.glBindProgramPipeline(0);
		GLU_EXPECT_NO_ERROR(gl.glGetError(), "unbind pipeline");
		gl.glValidateProgramPipeline(pipeline.getPipeline());
		GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen pipeline");

		gl.glGetProgramPipelineiv(pipeline.getPipeline(), GL_INFO_LOG_LENGTH, &logLen);
		GLU_EXPECT_NO_ERROR(gl.glGetError(), "get INFO_LOG_LENGTH");

		if (logLen.verifyValidity(result))
			verifyInfoLogQuery(result, gl, logLen, pipeline.getPipeline(), &glu::CallLogWrapper::glGetProgramPipelineInfoLog, "glGetProgramPipelineInfoLog");
	}

	result.setTestContextResult(m_testCtx);
	return STOP;
}

} // anonymous

ProgramPipelineStateQueryTests::ProgramPipelineStateQueryTests (Context& context)
	: TestCaseGroup(context, "program_pipeline", "Program Pipeline State Query tests")
{
}

ProgramPipelineStateQueryTests::~ProgramPipelineStateQueryTests (void)
{
}

void ProgramPipelineStateQueryTests::init (void)
{
	static const QueryType verifiers[] =
	{
		QUERY_PIPELINE_INTEGER,
	};

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

	FOR_EACH_VERIFIER(new ActiveProgramCase(m_context, verifier, (std::string("active_program_") + verifierSuffix).c_str(), "Test ACTIVE_PROGRAM"));
	FOR_EACH_VERIFIER(new PipelineProgramCase(m_context, verifier, (std::string("vertex_shader_") + verifierSuffix).c_str(), "Test VERTEX_SHADER", GL_VERTEX_SHADER));
	FOR_EACH_VERIFIER(new PipelineProgramCase(m_context, verifier, (std::string("fragment_shader_") + verifierSuffix).c_str(), "Test FRAGMENT_SHADER", GL_FRAGMENT_SHADER));
	FOR_EACH_VERIFIER(new PipelineProgramCase(m_context, verifier, (std::string("compute_shader_") + verifierSuffix).c_str(), "Test COMPUTE_SHADER", GL_COMPUTE_SHADER));
	FOR_EACH_VERIFIER(new ValidateStatusCase(m_context, verifier, (std::string("validate_status_") + verifierSuffix).c_str(), "Test VALIDATE_STATUS"));

#undef FOR_EACH_VERIFIER

	this->addChild(new InfoLogCase(m_context, "info_log", "Test info log"));
}

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