modules/gles2/functional/es2fTextureStateQueryTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 2.0 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Texture State Query tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es2fTextureStateQueryTests.hpp"
  25 #include "es2fApiCase.hpp"
  26 #include "glsStateQueryUtil.hpp"
  27 #include "gluRenderContext.hpp"
  28 #include "glwEnums.hpp"
  29 #include "glwFunctions.hpp"
  30 #include "deRandom.hpp"
  31 #include "deMath.h"
  32
  33 using namespace glw; // GLint and other GL types
  34 using namespace deqp::gls;
  35 using deqp::gls::StateQueryUtil::StateQueryMemoryWriteGuard;
  36
  37
  38 namespace deqp
  39 {
  40 namespace gles2
  41 {
  42 namespace Functional
  43 {
  44 namespace TextureParamVerifiers
  45 {
  46
  47 // TexParamVerifier
  48
  49 class TexParamVerifier : protected glu::CallLogWrapper
  50 {
  51 public:
  52                                                 TexParamVerifier        (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix);
  53         virtual                         ~TexParamVerifier       (); // make GCC happy
  54
  55         const char*                     getTestNamePostfix      (void) const;
  56
  57         virtual void            verifyInteger           (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint reference)        = DE_NULL;
  58         virtual void            verifyFloat                     (tcu::TestContext& testCtx, GLenum target, GLenum name, GLfloat reference)      = DE_NULL;
  59 private:
  60         const char*     const   m_testNamePostfix;
  61 };
  62
  63 TexParamVerifier::TexParamVerifier (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix)
  64         : glu::CallLogWrapper   (gl, log)
  65         , m_testNamePostfix             (testNamePostfix)
  66 {
  67         enableLogging(true);
  68 }
  69 TexParamVerifier::~TexParamVerifier ()
  70 {
  71 }
  72
  73 const char* TexParamVerifier::getTestNamePostfix (void) const
  74 {
  75         return m_testNamePostfix;
  76 }
  77
  78 class GetTexParameterIVerifier : public TexParamVerifier
  79 {
  80 public:
  81                         GetTexParameterIVerifier        (const glw::Functions& gl, tcu::TestLog& log);
  82
  83         void    verifyInteger                           (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint reference);
  84         void    verifyFloat                                     (tcu::TestContext& testCtx, GLenum target, GLenum name, GLfloat reference);
  85 };
  86
  87 GetTexParameterIVerifier::GetTexParameterIVerifier (const glw::Functions& gl, tcu::TestLog& log)
  88         : TexParamVerifier(gl, log, "_gettexparameteri")
  89 {
  90 }
  91
  92 void GetTexParameterIVerifier::verifyInteger (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint reference)
  93 {
  94         using tcu::TestLog;
  95
  96         StateQueryMemoryWriteGuard<GLint> state;
  97         glGetTexParameteriv(target, name, &state);
  98
  99         if (!state.verifyValidity(testCtx))
 100                 return;
 101
 102         if (state != reference)
 103         {
 104                 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state << TestLog::EndMessage;
 105
 106                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 107                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid texture param value");
 108         }
 109 }
 110
 111 void GetTexParameterIVerifier::verifyFloat (tcu::TestContext& testCtx, GLenum target, GLenum name, GLfloat reference)
 112 {
 113         using tcu::TestLog;
 114
 115         const GLint expectedGLStateMax = StateQueryUtil::roundGLfloatToNearestIntegerHalfUp<GLint>(reference);
 116         const GLint expectedGLStateMin = StateQueryUtil::roundGLfloatToNearestIntegerHalfDown<GLint>(reference);
 117
 118         StateQueryMemoryWriteGuard<GLint> state;
 119         glGetTexParameteriv(target, name, &state);
 120
 121         if (!state.verifyValidity(testCtx))
 122                 return;
 123
 124         if (state < expectedGLStateMin || state > expectedGLStateMax)
 125         {
 126                 testCtx.getLog() << TestLog::Message << "// ERROR: expected in range [" << expectedGLStateMin << ", " << expectedGLStateMax << "]; got " << state << TestLog::EndMessage;
 127
 128                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 129                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid texture param value");
 130         }
 131 }
 132
 133 class GetTexParameterFVerifier : public TexParamVerifier
 134 {
 135 public:
 136                         GetTexParameterFVerifier        (const glw::Functions& gl, tcu::TestLog& log);
 137
 138         void    verifyInteger                           (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint reference);
 139         void    verifyFloat                                     (tcu::TestContext& testCtx, GLenum target, GLenum name, GLfloat reference);
 140 };
 141
 142 GetTexParameterFVerifier::GetTexParameterFVerifier (const glw::Functions& gl, tcu::TestLog& log)
 143         : TexParamVerifier(gl, log, "_gettexparameterf")
 144 {
 145 }
 146
 147 void GetTexParameterFVerifier::verifyInteger (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint reference)
 148 {
 149         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
 150
 151         using tcu::TestLog;
 152
 153         const GLfloat referenceAsFloat = GLfloat(reference);
 154
 155         StateQueryMemoryWriteGuard<GLfloat> state;
 156         glGetTexParameterfv(target, name, &state);
 157
 158         if (!state.verifyValidity(testCtx))
 159                 return;
 160
 161         if (state != referenceAsFloat)
 162         {
 163                 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << referenceAsFloat << "; got " << state << TestLog::EndMessage;
 164
 165                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 166                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
 167         }
 168 }
 169
 170 void GetTexParameterFVerifier::verifyFloat (tcu::TestContext& testCtx, GLenum target, GLenum name, GLfloat reference)
 171 {
 172         using tcu::TestLog;
 173
 174         StateQueryMemoryWriteGuard<GLfloat> state;
 175         glGetTexParameterfv(target, name, &state);
 176
 177         if (!state.verifyValidity(testCtx))
 178                 return;
 179
 180         if (state != reference)
 181         {
 182                 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state << TestLog::EndMessage;
 183
 184                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 185                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
 186         }
 187 }
 188
 189 } // TextureParamVerifiers
 190
 191 namespace
 192 {
 193
 194 using namespace TextureParamVerifiers;
 195
 196 // Tests
 197
 198 class TextureCase : public ApiCase
 199 {
 200 public:
 201         TextureCase (Context& context, TexParamVerifier* verifier, const char* name, const char* description, GLenum textureTarget)
 202                 : ApiCase                       (context, name, description)
 203                 , m_textureTarget       (textureTarget)
 204                 , m_verifier            (verifier)
 205         {
 206         }
 207
 208         virtual void testTexture (void) = DE_NULL;
 209
 210         void test (void)
 211         {
 212                 GLuint textureId = 0;
 213                 glGenTextures(1, &textureId);
 214                 glBindTexture(m_textureTarget, textureId);
 215                 expectError(GL_NO_ERROR);
 216
 217                 testTexture();
 218
 219                 glDeleteTextures(1, &textureId);
 220                 expectError(GL_NO_ERROR);
 221         }
 222
 223 protected:
 224         GLenum                          m_textureTarget;
 225         TexParamVerifier*       m_verifier;
 226 };
 227
 228 class TextureWrapCase : public TextureCase
 229 {
 230 public:
 231         TextureWrapCase (Context& context, TexParamVerifier* verifier, const char* name, const char* description, GLenum textureTarget, GLenum valueName)
 232                 : TextureCase   (context, verifier, name, description, textureTarget)
 233                 , m_valueName   (valueName)
 234         {
 235         }
 236
 237         void testTexture (void)
 238         {
 239                 const GLenum wrapValues[] = {GL_CLAMP_TO_EDGE, GL_REPEAT, GL_MIRRORED_REPEAT};
 240
 241                 m_verifier->verifyInteger(m_testCtx, m_textureTarget, m_valueName, GL_REPEAT);
 242                 expectError(GL_NO_ERROR);
 243
 244                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
 245                 {
 246                         glTexParameteri(m_textureTarget, m_valueName, wrapValues[ndx]);
 247                         expectError(GL_NO_ERROR);
 248
 249                         m_verifier->verifyInteger(m_testCtx, m_textureTarget, m_valueName, wrapValues[ndx]);
 250                         expectError(GL_NO_ERROR);
 251                 }
 252
 253                 //check unit conversions with float
 254
 255                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
 256                 {
 257                         glTexParameterf(m_textureTarget, m_valueName, (GLfloat)wrapValues[ndx]);
 258                         expectError(GL_NO_ERROR);
 259
 260                         m_verifier->verifyInteger(m_testCtx, m_textureTarget, m_valueName, wrapValues[ndx]);
 261                         expectError(GL_NO_ERROR);
 262                 }
 263         }
 264
 265 private:
 266         GLenum  m_valueName;
 267 };
 268
 269 class TextureMagFilterCase : public TextureCase
 270 {
 271 public:
 272         TextureMagFilterCase (Context& context, TexParamVerifier* verifier, const char* name, const char* description, GLenum textureTarget)
 273                 : TextureCase(context, verifier, name, description, textureTarget)
 274         {
 275         }
 276
 277         void testTexture (void)
 278         {
 279                 const GLenum magValues[] = {GL_NEAREST, GL_LINEAR};
 280
 281                 m_verifier->verifyInteger(m_testCtx, m_textureTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 282                 expectError(GL_NO_ERROR);
 283
 284                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(magValues); ++ndx)
 285                 {
 286                         glTexParameteri(m_textureTarget, GL_TEXTURE_MAG_FILTER, magValues[ndx]);
 287                         expectError(GL_NO_ERROR);
 288
 289                         m_verifier->verifyInteger(m_testCtx, m_textureTarget, GL_TEXTURE_MAG_FILTER, magValues[ndx]);
 290                         expectError(GL_NO_ERROR);
 291                 }
 292
 293                 //check unit conversions with float
 294
 295                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(magValues); ++ndx)
 296                 {
 297                         glTexParameterf(m_textureTarget, GL_TEXTURE_MAG_FILTER, (GLfloat)magValues[ndx]);
 298                         expectError(GL_NO_ERROR);
 299
 300                         m_verifier->verifyInteger(m_testCtx, m_textureTarget, GL_TEXTURE_MAG_FILTER, magValues[ndx]);
 301                         expectError(GL_NO_ERROR);
 302                 }
 303         }
 304 };
 305
 306 class TextureMinFilterCase : public TextureCase
 307 {
 308 public:
 309         TextureMinFilterCase (Context& context, TexParamVerifier* verifier, const char* name, const char* description, GLenum textureTarget)
 310                 : TextureCase(context, verifier, name, description, textureTarget)
 311         {
 312         }
 313
 314         void testTexture (void)
 315         {
 316                 const GLenum minValues[] = {GL_NEAREST, GL_LINEAR, GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR};
 317
 318                 m_verifier->verifyInteger(m_testCtx, m_textureTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
 319                 expectError(GL_NO_ERROR);
 320
 321                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(minValues); ++ndx)
 322                 {
 323                         glTexParameteri(m_textureTarget, GL_TEXTURE_MIN_FILTER, minValues[ndx]);
 324                         expectError(GL_NO_ERROR);
 325
 326                         m_verifier->verifyInteger(m_testCtx, m_textureTarget, GL_TEXTURE_MIN_FILTER, minValues[ndx]);
 327                         expectError(GL_NO_ERROR);
 328                 }
 329
 330                 //check unit conversions with float
 331
 332                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(minValues); ++ndx)
 333                 {
 334                         glTexParameterf(m_textureTarget, GL_TEXTURE_MIN_FILTER, (GLfloat)minValues[ndx]);
 335                         expectError(GL_NO_ERROR);
 336
 337                         m_verifier->verifyInteger(m_testCtx, m_textureTarget, GL_TEXTURE_MIN_FILTER, minValues[ndx]);
 338                         expectError(GL_NO_ERROR);
 339                 }
 340         }
 341 };
 342
 343 } // anonymous
 344
 345 #define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK)                                                                                                \
 346         for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++)        \
 347         {                                                                                                                                                                                       \
 348                 TexParamVerifier* verifier = (VERIFIERS)[_verifierNdx];                                                                 \
 349                 CODE_BLOCK;                                                                                                                                                             \
 350         }
 351
 352 TextureStateQueryTests::TextureStateQueryTests (Context& context)
 353         : TestCaseGroup         (context, "texture", "Texture State Query tests")
 354         , m_verifierInt         (DE_NULL)
 355         , m_verifierFloat       (DE_NULL)
 356 {
 357 }
 358
 359 TextureStateQueryTests::~TextureStateQueryTests (void)
 360 {
 361         deinit();
 362 }
 363
 364 void TextureStateQueryTests::init (void)
 365 {
 366         using namespace TextureParamVerifiers;
 367
 368         DE_ASSERT(m_verifierInt == DE_NULL);
 369         DE_ASSERT(m_verifierFloat == DE_NULL);
 370
 371         m_verifierInt           = new GetTexParameterIVerifier(m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
 372         m_verifierFloat         = new GetTexParameterFVerifier(m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
 373
 374         TexParamVerifier* verifiers[] = {m_verifierInt, m_verifierFloat};
 375
 376         const struct
 377         {
 378                 const char*     name;
 379                 GLenum          textureTarget;
 380         } textureTargets[] =
 381         {
 382                 { "texture_2d",                 GL_TEXTURE_2D},
 383                 { "texture_cube_map",   GL_TEXTURE_CUBE_MAP}
 384         };
 385
 386         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(textureTargets); ++ndx)
 387         {
 388                 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)));
 389                 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)));
 390
 391                 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)));
 392                 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)));
 393         }
 394 }
 395
 396 void TextureStateQueryTests::deinit (void)
 397 {
 398         if (m_verifierInt)
 399         {
 400                 delete m_verifierInt;
 401                 m_verifierInt = NULL;
 402         }
 403         if (m_verifierFloat)
 404         {
 405                 delete m_verifierFloat;
 406                 m_verifierFloat = NULL;
 407         }
 408
 409         this->TestCaseGroup::deinit();
 410 }
 411
 412 } // Functional
 413 } // gles2
 414 } // deqp