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.
414 lines
13 KiB
414 lines
13 KiB
/*------------------------------------------------------------------------- |
|
* 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 Texture State Query tests. |
|
*//*--------------------------------------------------------------------*/ |
|
|
|
#include "es2fTextureStateQueryTests.hpp" |
|
#include "es2fApiCase.hpp" |
|
#include "glsStateQueryUtil.hpp" |
|
#include "gluRenderContext.hpp" |
|
#include "glwEnums.hpp" |
|
#include "glwFunctions.hpp" |
|
#include "deRandom.hpp" |
|
#include "deMath.h" |
|
|
|
using namespace glw; // GLint and other GL types |
|
using namespace deqp::gls; |
|
using deqp::gls::StateQueryUtil::StateQueryMemoryWriteGuard; |
|
|
|
|
|
namespace deqp |
|
{ |
|
namespace gles2 |
|
{ |
|
namespace Functional |
|
{ |
|
namespace TextureParamVerifiers |
|
{ |
|
|
|
// TexParamVerifier |
|
|
|
class TexParamVerifier : protected glu::CallLogWrapper |
|
{ |
|
public: |
|
TexParamVerifier (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix); |
|
virtual ~TexParamVerifier (); // make GCC happy |
|
|
|
const char* getTestNamePostfix (void) const; |
|
|
|
virtual void verifyInteger (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint reference) = DE_NULL; |
|
virtual void verifyFloat (tcu::TestContext& testCtx, GLenum target, GLenum name, GLfloat reference) = DE_NULL; |
|
private: |
|
const char* const m_testNamePostfix; |
|
}; |
|
|
|
TexParamVerifier::TexParamVerifier (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix) |
|
: glu::CallLogWrapper (gl, log) |
|
, m_testNamePostfix (testNamePostfix) |
|
{ |
|
enableLogging(true); |
|
} |
|
TexParamVerifier::~TexParamVerifier () |
|
{ |
|
} |
|
|
|
const char* TexParamVerifier::getTestNamePostfix (void) const |
|
{ |
|
return m_testNamePostfix; |
|
} |
|
|
|
class GetTexParameterIVerifier : public TexParamVerifier |
|
{ |
|
public: |
|
GetTexParameterIVerifier (const glw::Functions& gl, tcu::TestLog& log); |
|
|
|
void verifyInteger (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint reference); |
|
void verifyFloat (tcu::TestContext& testCtx, GLenum target, GLenum name, GLfloat reference); |
|
}; |
|
|
|
GetTexParameterIVerifier::GetTexParameterIVerifier (const glw::Functions& gl, tcu::TestLog& log) |
|
: TexParamVerifier(gl, log, "_gettexparameteri") |
|
{ |
|
} |
|
|
|
void GetTexParameterIVerifier::verifyInteger (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint reference) |
|
{ |
|
using tcu::TestLog; |
|
|
|
StateQueryMemoryWriteGuard<GLint> state; |
|
glGetTexParameteriv(target, name, &state); |
|
|
|
if (!state.verifyValidity(testCtx)) |
|
return; |
|
|
|
if (state != reference) |
|
{ |
|
testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state << TestLog::EndMessage; |
|
|
|
if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
|
testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid texture param value"); |
|
} |
|
} |
|
|
|
void GetTexParameterIVerifier::verifyFloat (tcu::TestContext& testCtx, GLenum target, GLenum name, GLfloat reference) |
|
{ |
|
using tcu::TestLog; |
|
|
|
const GLint expectedGLStateMax = StateQueryUtil::roundGLfloatToNearestIntegerHalfUp<GLint>(reference); |
|
const GLint expectedGLStateMin = StateQueryUtil::roundGLfloatToNearestIntegerHalfDown<GLint>(reference); |
|
|
|
StateQueryMemoryWriteGuard<GLint> state; |
|
glGetTexParameteriv(target, name, &state); |
|
|
|
if (!state.verifyValidity(testCtx)) |
|
return; |
|
|
|
if (state < expectedGLStateMin || state > expectedGLStateMax) |
|
{ |
|
testCtx.getLog() << TestLog::Message << "// ERROR: expected in range [" << expectedGLStateMin << ", " << expectedGLStateMax << "]; got " << state << TestLog::EndMessage; |
|
|
|
if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
|
testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid texture param value"); |
|
} |
|
} |
|
|
|
class GetTexParameterFVerifier : public TexParamVerifier |
|
{ |
|
public: |
|
GetTexParameterFVerifier (const glw::Functions& gl, tcu::TestLog& log); |
|
|
|
void verifyInteger (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint reference); |
|
void verifyFloat (tcu::TestContext& testCtx, GLenum target, GLenum name, GLfloat reference); |
|
}; |
|
|
|
GetTexParameterFVerifier::GetTexParameterFVerifier (const glw::Functions& gl, tcu::TestLog& log) |
|
: TexParamVerifier(gl, log, "_gettexparameterf") |
|
{ |
|
} |
|
|
|
void GetTexParameterFVerifier::verifyInteger (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint reference) |
|
{ |
|
DE_ASSERT(reference == GLint(GLfloat(reference))); // reference integer must have 1:1 mapping to float for this to work. Reference value is always such value in these tests |
|
|
|
using tcu::TestLog; |
|
|
|
const GLfloat referenceAsFloat = GLfloat(reference); |
|
|
|
StateQueryMemoryWriteGuard<GLfloat> state; |
|
glGetTexParameterfv(target, name, &state); |
|
|
|
if (!state.verifyValidity(testCtx)) |
|
return; |
|
|
|
if (state != referenceAsFloat) |
|
{ |
|
testCtx.getLog() << TestLog::Message << "// ERROR: expected " << referenceAsFloat << "; got " << state << TestLog::EndMessage; |
|
|
|
if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
|
testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value"); |
|
} |
|
} |
|
|
|
void GetTexParameterFVerifier::verifyFloat (tcu::TestContext& testCtx, GLenum target, GLenum name, GLfloat reference) |
|
{ |
|
using tcu::TestLog; |
|
|
|
StateQueryMemoryWriteGuard<GLfloat> state; |
|
glGetTexParameterfv(target, name, &state); |
|
|
|
if (!state.verifyValidity(testCtx)) |
|
return; |
|
|
|
if (state != reference) |
|
{ |
|
testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state << TestLog::EndMessage; |
|
|
|
if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
|
testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value"); |
|
} |
|
} |
|
|
|
} // TextureParamVerifiers |
|
|
|
namespace |
|
{ |
|
|
|
using namespace TextureParamVerifiers; |
|
|
|
// Tests |
|
|
|
class TextureCase : public ApiCase |
|
{ |
|
public: |
|
TextureCase (Context& context, TexParamVerifier* verifier, const char* name, const char* description, GLenum textureTarget) |
|
: ApiCase (context, name, description) |
|
, m_textureTarget (textureTarget) |
|
, m_verifier (verifier) |
|
{ |
|
} |
|
|
|
virtual void testTexture (void) = DE_NULL; |
|
|
|
void test (void) |
|
{ |
|
GLuint textureId = 0; |
|
glGenTextures(1, &textureId); |
|
glBindTexture(m_textureTarget, textureId); |
|
expectError(GL_NO_ERROR); |
|
|
|
testTexture(); |
|
|
|
glDeleteTextures(1, &textureId); |
|
expectError(GL_NO_ERROR); |
|
} |
|
|
|
protected: |
|
GLenum m_textureTarget; |
|
TexParamVerifier* m_verifier; |
|
}; |
|
|
|
class TextureWrapCase : public TextureCase |
|
{ |
|
public: |
|
TextureWrapCase (Context& context, TexParamVerifier* verifier, const char* name, const char* description, GLenum textureTarget, GLenum valueName) |
|
: TextureCase (context, verifier, name, description, textureTarget) |
|
, m_valueName (valueName) |
|
{ |
|
} |
|
|
|
void testTexture (void) |
|
{ |
|
const GLenum wrapValues[] = {GL_CLAMP_TO_EDGE, GL_REPEAT, GL_MIRRORED_REPEAT}; |
|
|
|
m_verifier->verifyInteger(m_testCtx, m_textureTarget, m_valueName, GL_REPEAT); |
|
expectError(GL_NO_ERROR); |
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx) |
|
{ |
|
glTexParameteri(m_textureTarget, m_valueName, wrapValues[ndx]); |
|
expectError(GL_NO_ERROR); |
|
|
|
m_verifier->verifyInteger(m_testCtx, m_textureTarget, m_valueName, wrapValues[ndx]); |
|
expectError(GL_NO_ERROR); |
|
} |
|
|
|
//check unit conversions with float |
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx) |
|
{ |
|
glTexParameterf(m_textureTarget, m_valueName, (GLfloat)wrapValues[ndx]); |
|
expectError(GL_NO_ERROR); |
|
|
|
m_verifier->verifyInteger(m_testCtx, m_textureTarget, m_valueName, wrapValues[ndx]); |
|
expectError(GL_NO_ERROR); |
|
} |
|
} |
|
|
|
private: |
|
GLenum m_valueName; |
|
}; |
|
|
|
class TextureMagFilterCase : public TextureCase |
|
{ |
|
public: |
|
TextureMagFilterCase (Context& context, TexParamVerifier* verifier, const char* name, const char* description, GLenum textureTarget) |
|
: TextureCase(context, verifier, name, description, textureTarget) |
|
{ |
|
} |
|
|
|
void testTexture (void) |
|
{ |
|
const GLenum magValues[] = {GL_NEAREST, GL_LINEAR}; |
|
|
|
m_verifier->verifyInteger(m_testCtx, m_textureTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
|
expectError(GL_NO_ERROR); |
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(magValues); ++ndx) |
|
{ |
|
glTexParameteri(m_textureTarget, GL_TEXTURE_MAG_FILTER, magValues[ndx]); |
|
expectError(GL_NO_ERROR); |
|
|
|
m_verifier->verifyInteger(m_testCtx, m_textureTarget, GL_TEXTURE_MAG_FILTER, magValues[ndx]); |
|
expectError(GL_NO_ERROR); |
|
} |
|
|
|
//check unit conversions with float |
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(magValues); ++ndx) |
|
{ |
|
glTexParameterf(m_textureTarget, GL_TEXTURE_MAG_FILTER, (GLfloat)magValues[ndx]); |
|
expectError(GL_NO_ERROR); |
|
|
|
m_verifier->verifyInteger(m_testCtx, m_textureTarget, GL_TEXTURE_MAG_FILTER, magValues[ndx]); |
|
expectError(GL_NO_ERROR); |
|
} |
|
} |
|
}; |
|
|
|
class TextureMinFilterCase : public TextureCase |
|
{ |
|
public: |
|
TextureMinFilterCase (Context& context, TexParamVerifier* verifier, const char* name, const char* description, GLenum textureTarget) |
|
: TextureCase(context, verifier, name, description, textureTarget) |
|
{ |
|
} |
|
|
|
void testTexture (void) |
|
{ |
|
const GLenum minValues[] = {GL_NEAREST, GL_LINEAR, GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR}; |
|
|
|
m_verifier->verifyInteger(m_testCtx, m_textureTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR); |
|
expectError(GL_NO_ERROR); |
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(minValues); ++ndx) |
|
{ |
|
glTexParameteri(m_textureTarget, GL_TEXTURE_MIN_FILTER, minValues[ndx]); |
|
expectError(GL_NO_ERROR); |
|
|
|
m_verifier->verifyInteger(m_testCtx, m_textureTarget, GL_TEXTURE_MIN_FILTER, minValues[ndx]); |
|
expectError(GL_NO_ERROR); |
|
} |
|
|
|
//check unit conversions with float |
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(minValues); ++ndx) |
|
{ |
|
glTexParameterf(m_textureTarget, GL_TEXTURE_MIN_FILTER, (GLfloat)minValues[ndx]); |
|
expectError(GL_NO_ERROR); |
|
|
|
m_verifier->verifyInteger(m_testCtx, m_textureTarget, GL_TEXTURE_MIN_FILTER, minValues[ndx]); |
|
expectError(GL_NO_ERROR); |
|
} |
|
} |
|
}; |
|
|
|
} // anonymous |
|
|
|
#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \ |
|
for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \ |
|
{ \ |
|
TexParamVerifier* verifier = (VERIFIERS)[_verifierNdx]; \ |
|
CODE_BLOCK; \ |
|
} |
|
|
|
TextureStateQueryTests::TextureStateQueryTests (Context& context) |
|
: TestCaseGroup (context, "texture", "Texture State Query tests") |
|
, m_verifierInt (DE_NULL) |
|
, m_verifierFloat (DE_NULL) |
|
{ |
|
} |
|
|
|
TextureStateQueryTests::~TextureStateQueryTests (void) |
|
{ |
|
deinit(); |
|
} |
|
|
|
void TextureStateQueryTests::init (void) |
|
{ |
|
using namespace TextureParamVerifiers; |
|
|
|
DE_ASSERT(m_verifierInt == DE_NULL); |
|
DE_ASSERT(m_verifierFloat == DE_NULL); |
|
|
|
m_verifierInt = new GetTexParameterIVerifier(m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog()); |
|
m_verifierFloat = new GetTexParameterFVerifier(m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog()); |
|
|
|
TexParamVerifier* verifiers[] = {m_verifierInt, m_verifierFloat}; |
|
|
|
const struct |
|
{ |
|
const char* name; |
|
GLenum textureTarget; |
|
} textureTargets[] = |
|
{ |
|
{ "texture_2d", GL_TEXTURE_2D}, |
|
{ "texture_cube_map", GL_TEXTURE_CUBE_MAP} |
|
}; |
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(textureTargets); ++ndx) |
|
{ |
|
FOR_EACH_VERIFIER(verifiers, addChild(new TextureWrapCase (m_context, verifier, (std::string(textureTargets[ndx].name) + "_texture_wrap_s" + verifier->getTestNamePostfix()).c_str(), "TEXTURE_WRAP_S", textureTargets[ndx].textureTarget, GL_TEXTURE_WRAP_S))); |
|
FOR_EACH_VERIFIER(verifiers, addChild(new TextureWrapCase (m_context, verifier, (std::string(textureTargets[ndx].name) + "_texture_wrap_t" + verifier->getTestNamePostfix()).c_str(), "TEXTURE_WRAP_T", textureTargets[ndx].textureTarget, GL_TEXTURE_WRAP_T))); |
|
|
|
FOR_EACH_VERIFIER(verifiers, addChild(new TextureMagFilterCase (m_context, verifier, (std::string(textureTargets[ndx].name) + "_texture_mag_filter" + verifier->getTestNamePostfix()).c_str(), "TEXTURE_MAG_FILTER", textureTargets[ndx].textureTarget))); |
|
FOR_EACH_VERIFIER(verifiers, addChild(new TextureMinFilterCase (m_context, verifier, (std::string(textureTargets[ndx].name) + "_texture_min_filter" + verifier->getTestNamePostfix()).c_str(), "TEXTURE_MIN_FILTER", textureTargets[ndx].textureTarget))); |
|
} |
|
} |
|
|
|
void TextureStateQueryTests::deinit (void) |
|
{ |
|
if (m_verifierInt) |
|
{ |
|
delete m_verifierInt; |
|
m_verifierInt = NULL; |
|
} |
|
if (m_verifierFloat) |
|
{ |
|
delete m_verifierFloat; |
|
m_verifierFloat = NULL; |
|
} |
|
|
|
this->TestCaseGroup::deinit(); |
|
} |
|
|
|
} // Functional |
|
} // gles2 |
|
} // deqp
|
|
|