| /*------------------------------------------------------------------------- |
| * 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(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; |
| } |
| |
| } // namespace |
| |
| 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")); |
| } |
| |
| } // namespace Functional |
| } // namespace gles31 |
| } // namespace deqp |
