/*-------------------------------------------------------------------------
* drawElements Quality Program OpenGL ES 2.0 Module
* -------------------------------------------------
*
* Copyright 2014 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 Boolean State Query tests.
*//*--------------------------------------------------------------------*/
#include "es2fBooleanStateQueryTests.hpp"
#include "es2fApiCase.hpp"
#include "glsStateQueryUtil.hpp"
#include "gluRenderContext.hpp"
#include "tcuRenderTarget.hpp"
#include "glwEnums.hpp"
using namespace glw; // GLint and other GL types
using deqp::gls::StateQueryUtil::StateQueryMemoryWriteGuard;
namespace deqp
{
namespace gles2
{
namespace Functional
{
namespace BooleanStateQueryVerifiers
{
// StateVerifier
class StateVerifier : protected glu::CallLogWrapper
{
public:
StateVerifier (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix);
virtual ~StateVerifier (); // make GCC happy
const char* getTestNamePostfix (void) const;
virtual void verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference) = DE_NULL;
virtual void verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3) = DE_NULL;
virtual void verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name) = DE_NULL;
private:
const char* const m_testNamePostfix;
};
StateVerifier::StateVerifier (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix)
: glu::CallLogWrapper (gl, log)
, m_testNamePostfix (testNamePostfix)
{
enableLogging(true);
}
StateVerifier::~StateVerifier ()
{
}
const char* StateVerifier::getTestNamePostfix (void) const
{
return m_testNamePostfix;
}
// IsEnabledVerifier
class IsEnabledVerifier : public StateVerifier
{
public:
IsEnabledVerifier (const glw::Functions& gl, tcu::TestLog& log);
void verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference);
void verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3);
void verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name);
};
IsEnabledVerifier::IsEnabledVerifier (const glw::Functions& gl, tcu::TestLog& log)
: StateVerifier(gl, log, "_isenabled")
{
}
void IsEnabledVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
{
using tcu::TestLog;
const GLboolean state = glIsEnabled(name);
const GLboolean expectedGLState = reference ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE;
if (state != expectedGLState)
{
testCtx.getLog() << TestLog::Message << "// ERROR: expected " << (reference ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
}
}
void IsEnabledVerifier::verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)
{
DE_UNREF(testCtx);
DE_UNREF(name);
DE_UNREF(reference0);
DE_UNREF(reference1);
DE_UNREF(reference2);
DE_UNREF(reference3);
DE_ASSERT(false && "not supported");
}
void IsEnabledVerifier::verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name)
{
DE_UNREF(testCtx);
DE_UNREF(name);
DE_ASSERT(false && "not supported");
}
// GetBooleanVerifier
class GetBooleanVerifier : public StateVerifier
{
public:
GetBooleanVerifier (const glw::Functions& gl, tcu::TestLog& log);
void verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference);
void verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3);
void verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name);
};
GetBooleanVerifier::GetBooleanVerifier (const glw::Functions& gl, tcu::TestLog& log)
: StateVerifier(gl, log, "_getboolean")
{
}
void GetBooleanVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
{
using tcu::TestLog;
StateQueryMemoryWriteGuard<GLboolean> state;
glGetBooleanv(name, &state);
if (!state.verifyValidity(testCtx))
return;
const GLboolean expectedGLState = reference ? GL_TRUE : GL_FALSE;
if (state != expectedGLState)
{
testCtx.getLog() << TestLog::Message << "// ERROR: expected " << (reference ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
}
}
void GetBooleanVerifier::verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)
{
using tcu::TestLog;
StateQueryMemoryWriteGuard<GLboolean[4]> boolVector4;
glGetBooleanv(name, boolVector4);
if (!boolVector4.verifyValidity(testCtx))
return;
const GLboolean referenceAsGLBoolean[] =
{
reference0 ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE),
reference1 ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE),
reference2 ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE),
reference3 ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE),
};
if (boolVector4[0] != referenceAsGLBoolean[0] ||
boolVector4[1] != referenceAsGLBoolean[1] ||
boolVector4[2] != referenceAsGLBoolean[2] ||
boolVector4[3] != referenceAsGLBoolean[3])
{
testCtx.getLog() << TestLog::Message << "// ERROR: expected "
<< (referenceAsGLBoolean[0] ? "GL_TRUE" : "GL_FALSE") << " "
<< (referenceAsGLBoolean[1] ? "GL_TRUE" : "GL_FALSE") << " "
<< (referenceAsGLBoolean[2] ? "GL_TRUE" : "GL_FALSE") << " "
<< (referenceAsGLBoolean[3] ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
}
}
void GetBooleanVerifier::verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name)
{
using tcu::TestLog;
StateQueryMemoryWriteGuard<GLboolean> state;
glGetBooleanv(name, &state);
state.verifyValidity(testCtx);
}
//GetIntegerVerifier
class GetIntegerVerifier : public StateVerifier
{
public:
GetIntegerVerifier (const glw::Functions& gl, tcu::TestLog& log);
void verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference);
void verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3);
void verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name);
};
GetIntegerVerifier::GetIntegerVerifier (const glw::Functions& gl, tcu::TestLog& log)
: StateVerifier(gl, log, "_getinteger")
{
}
void GetIntegerVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
{
using tcu::TestLog;
StateQueryMemoryWriteGuard<GLint> state;
glGetIntegerv(name, &state);
if (!state.verifyValidity(testCtx))
return;
const GLint expectedGLState = reference ? 1 : 0;
if (state != expectedGLState)
{
testCtx.getLog() << TestLog::Message << "// ERROR: expected " << expectedGLState << TestLog::EndMessage;
if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
}
}
void GetIntegerVerifier::verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)
{
using tcu::TestLog;
StateQueryMemoryWriteGuard<GLint[4]> boolVector4;
glGetIntegerv(name, boolVector4);
if (!boolVector4.verifyValidity(testCtx))
return;
const GLint referenceAsGLint[] =
{
reference0 ? 1 : 0,
reference1 ? 1 : 0,
reference2 ? 1 : 0,
reference3 ? 1 : 0,
};
if (boolVector4[0] != referenceAsGLint[0] ||
boolVector4[1] != referenceAsGLint[1] ||
boolVector4[2] != referenceAsGLint[2] ||
boolVector4[3] != referenceAsGLint[3])
{
testCtx.getLog() << TestLog::Message << "// ERROR: expected "
<< referenceAsGLint[0] << " "
<< referenceAsGLint[1] << " "
<< referenceAsGLint[2] << " "
<< referenceAsGLint[3] << " " << TestLog::EndMessage;
if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
}
}
void GetIntegerVerifier::verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name)
{
using tcu::TestLog;
StateQueryMemoryWriteGuard<GLint> state;
glGetIntegerv(name, &state);
state.verifyValidity(testCtx);
}
//GetFloatVerifier
class GetFloatVerifier : public StateVerifier
{
public:
GetFloatVerifier (const glw::Functions& gl, tcu::TestLog& log);
void verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference);
void verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3);
void verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name);
};
GetFloatVerifier::GetFloatVerifier (const glw::Functions& gl, tcu::TestLog& log)
: StateVerifier(gl, log, "_getfloat")
{
}
void GetFloatVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
{
using tcu::TestLog;
StateQueryMemoryWriteGuard<GLfloat> state;
glGetFloatv(name, &state);
if (!state.verifyValidity(testCtx))
return;
const GLfloat expectedGLState = reference ? 1.0f : 0.0f;
if (state != expectedGLState)
{
testCtx.getLog() << TestLog::Message << "// ERROR: expected " << expectedGLState << "; got " << state << TestLog::EndMessage;
if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
}
}
void GetFloatVerifier::verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)
{
using tcu::TestLog;
StateQueryMemoryWriteGuard<GLfloat[4]> boolVector4;
glGetFloatv(name, boolVector4);
if (!boolVector4.verifyValidity(testCtx))
return;
const GLfloat referenceAsGLfloat[] =
{
reference0 ? 1.0f : 0.0f,
reference1 ? 1.0f : 0.0f,
reference2 ? 1.0f : 0.0f,
reference3 ? 1.0f : 0.0f,
};
if (boolVector4[0] != referenceAsGLfloat[0] ||
boolVector4[1] != referenceAsGLfloat[1] ||
boolVector4[2] != referenceAsGLfloat[2] ||
boolVector4[3] != referenceAsGLfloat[3])
{
testCtx.getLog() << TestLog::Message << "// ERROR: expected "
<< referenceAsGLfloat[0] << " "
<< referenceAsGLfloat[1] << " "
<< referenceAsGLfloat[2] << " "
<< referenceAsGLfloat[3] << " " << TestLog::EndMessage;
if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
}
}
void GetFloatVerifier::verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name)
{
using tcu::TestLog;
StateQueryMemoryWriteGuard<GLfloat> state;
glGetFloatv(name, &state);
state.verifyValidity(testCtx);
}
} // BooleanStateQueryVerifiers
namespace
{
using namespace BooleanStateQueryVerifiers;
class IsEnabledStateTestCase : public ApiCase
{
public:
IsEnabledStateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum targetName, bool initial)
: ApiCase (context, name, description)
, m_targetName (targetName)
, m_initial (initial)
, m_verifier (verifier)
{
}
void test (void)
{
// check inital value
m_verifier->verifyBoolean(m_testCtx, m_targetName, m_initial);
expectError(GL_NO_ERROR);
// check toggle
glEnable(m_targetName);
expectError(GL_NO_ERROR);
m_verifier->verifyBoolean(m_testCtx, m_targetName, true);
expectError(GL_NO_ERROR);
glDisable(m_targetName);
expectError(GL_NO_ERROR);
m_verifier->verifyBoolean(m_testCtx, m_targetName, false);
expectError(GL_NO_ERROR);
}
private:
GLenum m_targetName;
bool m_initial;
StateVerifier* m_verifier;
};
class DepthWriteMaskTestCase : public ApiCase
{
public:
DepthWriteMaskTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
: ApiCase (context, name, description)
, m_verifier (verifier)
{
}
void test (void)
{
m_verifier->verifyBoolean(m_testCtx, GL_DEPTH_WRITEMASK, true);
expectError(GL_NO_ERROR);
glDepthMask(GL_FALSE);
m_verifier->verifyBoolean(m_testCtx, GL_DEPTH_WRITEMASK, false);
expectError(GL_NO_ERROR);
glDepthMask(GL_TRUE);
m_verifier->verifyBoolean(m_testCtx, GL_DEPTH_WRITEMASK, true);
expectError(GL_NO_ERROR);
}
private:
StateVerifier* m_verifier;
};
class SampleCoverageInvertTestCase : public ApiCase
{
public:
SampleCoverageInvertTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
: ApiCase (context, name, description)
, m_verifier (verifier)
{
}
void test (void)
{
m_verifier->verifyBoolean(m_testCtx, GL_SAMPLE_COVERAGE_INVERT, false);
expectError(GL_NO_ERROR);
glSampleCoverage(1.0f, GL_TRUE);
m_verifier->verifyBoolean(m_testCtx, GL_SAMPLE_COVERAGE_INVERT, true);
expectError(GL_NO_ERROR);
glSampleCoverage(1.0f, GL_FALSE);
m_verifier->verifyBoolean(m_testCtx, GL_SAMPLE_COVERAGE_INVERT, false);
expectError(GL_NO_ERROR);
}
private:
StateVerifier* m_verifier;
};
class ShaderCompilerTestCase : public ApiCase
{
public:
ShaderCompilerTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
: ApiCase (context, name, description)
, m_verifier (verifier)
{
}
void test (void)
{
m_verifier->verifyBooleanAnything(m_testCtx, GL_SHADER_COMPILER);
expectError(GL_NO_ERROR);
}
private:
StateVerifier* m_verifier;
};
class ColorMaskTestCase : public ApiCase
{
public:
ColorMaskTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
: ApiCase(context, name, description)
, m_verifier (verifier)
{
}
void test (void)
{
m_verifier->verifyBoolean4(m_testCtx, GL_COLOR_WRITEMASK, true, true, true, true);
expectError(GL_NO_ERROR);
const struct ColorMask
{
GLboolean r, g, b, a;
} testMasks[] =
{
{ GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE },
{ GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE },
{ GL_TRUE, GL_TRUE, GL_FALSE, GL_TRUE },
{ GL_TRUE, GL_TRUE, GL_FALSE, GL_FALSE },
{ GL_TRUE, GL_FALSE, GL_TRUE, GL_TRUE },
{ GL_TRUE, GL_FALSE, GL_TRUE, GL_FALSE },
{ GL_TRUE, GL_FALSE, GL_FALSE, GL_TRUE },
{ GL_TRUE, GL_FALSE, GL_FALSE, GL_FALSE },
{ GL_FALSE, GL_TRUE, GL_TRUE, GL_TRUE },
{ GL_FALSE, GL_TRUE, GL_TRUE, GL_FALSE },
{ GL_FALSE, GL_TRUE, GL_FALSE, GL_TRUE },
{ GL_FALSE, GL_TRUE, GL_FALSE, GL_FALSE },
{ GL_FALSE, GL_FALSE, GL_TRUE, GL_TRUE },
{ GL_FALSE, GL_FALSE, GL_TRUE, GL_FALSE },
{ GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE },
{ GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE },
};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(testMasks); ndx++)
{
glColorMask(testMasks[ndx].r, testMasks[ndx].g, testMasks[ndx].b, testMasks[ndx].a);
m_verifier->verifyBoolean4(m_testCtx, GL_COLOR_WRITEMASK, testMasks[ndx].r==GL_TRUE, testMasks[ndx].g==GL_TRUE, testMasks[ndx].b==GL_TRUE, testMasks[ndx].a==GL_TRUE);
expectError(GL_NO_ERROR);
}
}
private:
StateVerifier* m_verifier;
};
#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
{ \
StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
CODE_BLOCK; \
}
} // anonymous
BooleanStateQueryTests::BooleanStateQueryTests (Context& context)
: TestCaseGroup (context, "boolean", "Boolean State Query tests")
, m_verifierIsEnabled (DE_NULL)
, m_verifierBoolean (DE_NULL)
, m_verifierInteger (DE_NULL)
, m_verifierFloat (DE_NULL)
{
}
BooleanStateQueryTests::~BooleanStateQueryTests (void)
{
deinit();
}
void BooleanStateQueryTests::init (void)
{
DE_ASSERT(m_verifierIsEnabled == DE_NULL);
DE_ASSERT(m_verifierBoolean == DE_NULL);
DE_ASSERT(m_verifierInteger == DE_NULL);
DE_ASSERT(m_verifierFloat == DE_NULL);
m_verifierIsEnabled = new IsEnabledVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
m_verifierBoolean = new GetBooleanVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
m_verifierInteger = new GetIntegerVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
m_verifierFloat = new GetFloatVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
StateVerifier* isEnabledVerifiers[] = {m_verifierIsEnabled, m_verifierBoolean, m_verifierInteger, m_verifierFloat};
StateVerifier* normalVerifiers[] = { m_verifierBoolean, m_verifierInteger, m_verifierFloat};
struct StateBoolean
{
const char* name;
const char* description;
GLenum targetName;
bool value;
};
const StateBoolean isEnableds[] =
{
{ "cull_face", "CULL_FACE", GL_CULL_FACE, false},
{ "polygon_offset_fill", "POLYGON_OFFSET_FILL", GL_POLYGON_OFFSET_FILL, false},
{ "sample_alpha_to_coverage", "SAMPLE_ALPHA_TO_COVERAGE", GL_SAMPLE_ALPHA_TO_COVERAGE, false},
{ "sample_coverage", "SAMPLE_COVERAGE", GL_SAMPLE_COVERAGE, false},
{ "scissor_test", "SCISSOR_TEST", GL_SCISSOR_TEST, false},
{ "stencil_test", "STENCIL_TEST", GL_STENCIL_TEST, false},
{ "depth_test", "DEPTH_TEST", GL_DEPTH_TEST, false},
{ "blend", "BLEND", GL_BLEND, false},
{ "dither", "DITHER", GL_DITHER, true },
};
for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(isEnableds); testNdx++)
FOR_EACH_VERIFIER(isEnabledVerifiers, addChild(new IsEnabledStateTestCase(m_context, verifier, (std::string(isEnableds[testNdx].name) + verifier->getTestNamePostfix()).c_str(), isEnableds[testNdx].description, isEnableds[testNdx].targetName, isEnableds[testNdx].value)));
FOR_EACH_VERIFIER(normalVerifiers, addChild(new SampleCoverageInvertTestCase (m_context, verifier, (std::string("sample_coverage_invert") + verifier->getTestNamePostfix()).c_str(), "SAMPLE_COVERAGE_INVERT")));
FOR_EACH_VERIFIER(normalVerifiers, addChild(new ColorMaskTestCase (m_context, verifier, (std::string("color_writemask") + verifier->getTestNamePostfix()).c_str(), "COLOR_WRITEMASK")));
FOR_EACH_VERIFIER(normalVerifiers, addChild(new DepthWriteMaskTestCase (m_context, verifier, (std::string("depth_writemask") + verifier->getTestNamePostfix()).c_str(), "DEPTH_WRITEMASK")));
FOR_EACH_VERIFIER(normalVerifiers, addChild(new ShaderCompilerTestCase (m_context, verifier, (std::string("shader_compiler") + verifier->getTestNamePostfix()).c_str(), "SHADER_COMPILER")));
}
void BooleanStateQueryTests::deinit (void)
{
if (m_verifierIsEnabled)
{
delete m_verifierIsEnabled;
m_verifierIsEnabled = DE_NULL;
}
if (m_verifierBoolean)
{
delete m_verifierBoolean;
m_verifierBoolean = DE_NULL;
}
if (m_verifierInteger)
{
delete m_verifierInteger;
m_verifierInteger = DE_NULL;
}
if (m_verifierFloat)
{
delete m_verifierFloat;
m_verifierFloat = DE_NULL;
}
this->TestCaseGroup::deinit();
}
} // Functional
} // gles2
} // deqp