You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
416 lines
15 KiB
416 lines
15 KiB
/*-------------------------------------------------------------------------
|
|
* 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) \
|
|
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); \
|
|
}
|
|
|
|
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
|