modules/gles2/functional/es2fBooleanStateQueryTests.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 Boolean State Query tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es2fBooleanStateQueryTests.hpp"
  25 #include "es2fApiCase.hpp"
  26 #include "glsStateQueryUtil.hpp"
  27 #include "gluRenderContext.hpp"
  28 #include "tcuRenderTarget.hpp"
  29 #include "glwEnums.hpp"
  30
  31 using namespace glw; // GLint and other GL types
  32 using deqp::gls::StateQueryUtil::StateQueryMemoryWriteGuard;
  33
  34 namespace deqp
  35 {
  36 namespace gles2
  37 {
  38 namespace Functional
  39 {
  40 namespace BooleanStateQueryVerifiers
  41 {
  42
  43 // StateVerifier
  44
  45 class StateVerifier : protected glu::CallLogWrapper
  46 {
  47 public:
  48                                                 StateVerifier                                   (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix);
  49         virtual                         ~StateVerifier                                  (); // make GCC happy
  50
  51         const char*                     getTestNamePostfix                              (void) const;
  52
  53         virtual void            verifyBoolean                                   (tcu::TestContext& testCtx, GLenum name, bool reference)                                                                                                                = DE_NULL;
  54         virtual void            verifyBoolean4                                  (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)    = DE_NULL;
  55         virtual void            verifyBooleanAnything                   (tcu::TestContext& testCtx, GLenum name)                                                                                                                                                = DE_NULL;
  56 private:
  57         const char*     const   m_testNamePostfix;
  58 };
  59
  60 StateVerifier::StateVerifier (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix)
  61         : glu::CallLogWrapper   (gl, log)
  62         , m_testNamePostfix             (testNamePostfix)
  63 {
  64         enableLogging(true);
  65 }
  66
  67 StateVerifier::~StateVerifier ()
  68 {
  69 }
  70
  71 const char* StateVerifier::getTestNamePostfix (void) const
  72 {
  73         return m_testNamePostfix;
  74 }
  75
  76 // IsEnabledVerifier
  77
  78 class IsEnabledVerifier : public StateVerifier
  79 {
  80 public:
  81                         IsEnabledVerifier               (const glw::Functions& gl, tcu::TestLog& log);
  82         void    verifyBoolean                   (tcu::TestContext& testCtx, GLenum name, bool reference);
  83         void    verifyBoolean4                  (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3);
  84         void    verifyBooleanAnything   (tcu::TestContext& testCtx, GLenum name);
  85 };
  86
  87 IsEnabledVerifier::IsEnabledVerifier (const glw::Functions& gl, tcu::TestLog& log)
  88         : StateVerifier(gl, log, "_isenabled")
  89 {
  90 }
  91
  92 void IsEnabledVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
  93 {
  94         using tcu::TestLog;
  95
  96         const GLboolean state = glIsEnabled(name);
  97         const GLboolean expectedGLState = reference ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE;
  98
  99         if (state != expectedGLState)
 100         {
 101                 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << (reference ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
 102                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 103                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 104         }
 105 }
 106
 107 void IsEnabledVerifier::verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)
 108 {
 109         DE_UNREF(testCtx);
 110         DE_UNREF(name);
 111         DE_UNREF(reference0);
 112         DE_UNREF(reference1);
 113         DE_UNREF(reference2);
 114         DE_UNREF(reference3);
 115         DE_ASSERT(false && "not supported");
 116 }
 117
 118 void IsEnabledVerifier::verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name)
 119 {
 120         DE_UNREF(testCtx);
 121         DE_UNREF(name);
 122         DE_ASSERT(false && "not supported");
 123 }
 124 // GetBooleanVerifier
 125
 126 class GetBooleanVerifier : public StateVerifier
 127 {
 128 public:
 129                         GetBooleanVerifier              (const glw::Functions& gl, tcu::TestLog& log);
 130         void    verifyBoolean                   (tcu::TestContext& testCtx, GLenum name, bool reference);
 131         void    verifyBoolean4                  (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3);
 132         void    verifyBooleanAnything   (tcu::TestContext& testCtx, GLenum name);
 133 };
 134
 135 GetBooleanVerifier::GetBooleanVerifier (const glw::Functions& gl, tcu::TestLog& log)
 136         : StateVerifier(gl, log, "_getboolean")
 137 {
 138 }
 139
 140 void GetBooleanVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
 141 {
 142         using tcu::TestLog;
 143
 144         StateQueryMemoryWriteGuard<GLboolean> state;
 145         glGetBooleanv(name, &state);
 146
 147         if (!state.verifyValidity(testCtx))
 148                 return;
 149
 150         const GLboolean expectedGLState = reference ? GL_TRUE : GL_FALSE;
 151
 152         if (state != expectedGLState)
 153         {
 154                 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << (reference ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
 155                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 156                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 157         }
 158 }
 159
 160 void GetBooleanVerifier::verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)
 161 {
 162         using tcu::TestLog;
 163
 164         StateQueryMemoryWriteGuard<GLboolean[4]> boolVector4;
 165         glGetBooleanv(name, boolVector4);
 166
 167         if (!boolVector4.verifyValidity(testCtx))
 168                 return;
 169
 170         const GLboolean referenceAsGLBoolean[] =
 171         {
 172                 reference0 ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE),
 173                 reference1 ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE),
 174                 reference2 ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE),
 175                 reference3 ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE),
 176         };
 177
 178         if (boolVector4[0] != referenceAsGLBoolean[0] ||
 179                 boolVector4[1] != referenceAsGLBoolean[1] ||
 180                 boolVector4[2] != referenceAsGLBoolean[2] ||
 181                 boolVector4[3] != referenceAsGLBoolean[3])
 182         {
 183                 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
 184                         << (referenceAsGLBoolean[0] ? "GL_TRUE" : "GL_FALSE") << " "
 185                         << (referenceAsGLBoolean[1] ? "GL_TRUE" : "GL_FALSE") << " "
 186                         << (referenceAsGLBoolean[2] ? "GL_TRUE" : "GL_FALSE") << " "
 187                         << (referenceAsGLBoolean[3] ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
 188
 189                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 190                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 191         }
 192 }
 193
 194 void GetBooleanVerifier::verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name)
 195 {
 196         using tcu::TestLog;
 197
 198         StateQueryMemoryWriteGuard<GLboolean> state;
 199         glGetBooleanv(name, &state);
 200
 201         state.verifyValidity(testCtx);
 202 }
 203
 204 //GetIntegerVerifier
 205
 206 class GetIntegerVerifier : public StateVerifier
 207 {
 208 public:
 209                         GetIntegerVerifier              (const glw::Functions& gl, tcu::TestLog& log);
 210         void    verifyBoolean                   (tcu::TestContext& testCtx, GLenum name, bool reference);
 211         void    verifyBoolean4                  (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3);
 212         void    verifyBooleanAnything   (tcu::TestContext& testCtx, GLenum name);
 213
 214 };
 215
 216 GetIntegerVerifier::GetIntegerVerifier (const glw::Functions& gl, tcu::TestLog& log)
 217         : StateVerifier(gl, log, "_getinteger")
 218 {
 219 }
 220
 221 void GetIntegerVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
 222 {
 223         using tcu::TestLog;
 224
 225         StateQueryMemoryWriteGuard<GLint> state;
 226         glGetIntegerv(name, &state);
 227
 228         if (!state.verifyValidity(testCtx))
 229                 return;
 230
 231         const GLint expectedGLState = reference ? 1 : 0;
 232
 233         if (state != expectedGLState)
 234         {
 235                 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << expectedGLState << TestLog::EndMessage;
 236                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 237                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 238         }
 239 }
 240
 241 void GetIntegerVerifier::verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)
 242 {
 243         using tcu::TestLog;
 244
 245         StateQueryMemoryWriteGuard<GLint[4]> boolVector4;
 246         glGetIntegerv(name, boolVector4);
 247
 248         if (!boolVector4.verifyValidity(testCtx))
 249                 return;
 250
 251         const GLint referenceAsGLint[] =
 252         {
 253                 reference0 ? 1 : 0,
 254                 reference1 ? 1 : 0,
 255                 reference2 ? 1 : 0,
 256                 reference3 ? 1 : 0,
 257         };
 258
 259         if (boolVector4[0] != referenceAsGLint[0] ||
 260                 boolVector4[1] != referenceAsGLint[1] ||
 261                 boolVector4[2] != referenceAsGLint[2] ||
 262                 boolVector4[3] != referenceAsGLint[3])
 263         {
 264                 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
 265                         << referenceAsGLint[0] << " "
 266                         << referenceAsGLint[1] << " "
 267                         << referenceAsGLint[2] << " "
 268                         << referenceAsGLint[3] << " " << TestLog::EndMessage;
 269
 270                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 271                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 272         }
 273 }
 274
 275 void GetIntegerVerifier::verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name)
 276 {
 277         using tcu::TestLog;
 278
 279         StateQueryMemoryWriteGuard<GLint> state;
 280         glGetIntegerv(name, &state);
 281
 282         state.verifyValidity(testCtx);
 283 }
 284
 285 //GetFloatVerifier
 286
 287 class GetFloatVerifier : public StateVerifier
 288 {
 289 public:
 290                         GetFloatVerifier                (const glw::Functions& gl, tcu::TestLog& log);
 291         void    verifyBoolean                   (tcu::TestContext& testCtx, GLenum name, bool reference);
 292         void    verifyBoolean4                  (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3);
 293         void    verifyBooleanAnything   (tcu::TestContext& testCtx, GLenum name);
 294 };
 295
 296 GetFloatVerifier::GetFloatVerifier (const glw::Functions& gl, tcu::TestLog& log)
 297         : StateVerifier(gl, log, "_getfloat")
 298 {
 299 }
 300
 301 void GetFloatVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
 302 {
 303         using tcu::TestLog;
 304
 305         StateQueryMemoryWriteGuard<GLfloat> state;
 306         glGetFloatv(name, &state);
 307
 308         if (!state.verifyValidity(testCtx))
 309                 return;
 310
 311         const GLfloat expectedGLState = reference ? 1.0f : 0.0f;
 312
 313         if (state != expectedGLState)
 314         {
 315                 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << expectedGLState << "; got " << state << TestLog::EndMessage;
 316                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 317                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
 318         }
 319 }
 320
 321 void GetFloatVerifier::verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)
 322 {
 323         using tcu::TestLog;
 324
 325         StateQueryMemoryWriteGuard<GLfloat[4]> boolVector4;
 326         glGetFloatv(name, boolVector4);
 327
 328         if (!boolVector4.verifyValidity(testCtx))
 329                 return;
 330
 331         const GLfloat referenceAsGLfloat[] =
 332         {
 333                 reference0 ? 1.0f : 0.0f,
 334                 reference1 ? 1.0f : 0.0f,
 335                 reference2 ? 1.0f : 0.0f,
 336                 reference3 ? 1.0f : 0.0f,
 337         };
 338
 339         if (boolVector4[0] != referenceAsGLfloat[0] ||
 340                 boolVector4[1] != referenceAsGLfloat[1] ||
 341                 boolVector4[2] != referenceAsGLfloat[2] ||
 342                 boolVector4[3] != referenceAsGLfloat[3])
 343         {
 344                 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
 345                         << referenceAsGLfloat[0] << " "
 346                         << referenceAsGLfloat[1] << " "
 347                         << referenceAsGLfloat[2] << " "
 348                         << referenceAsGLfloat[3] << " " << TestLog::EndMessage;
 349
 350                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 351                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
 352         }
 353 }
 354
 355 void GetFloatVerifier::verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name)
 356 {
 357         using tcu::TestLog;
 358
 359         StateQueryMemoryWriteGuard<GLfloat> state;
 360         glGetFloatv(name, &state);
 361
 362         state.verifyValidity(testCtx);
 363 }
 364
 365 } // BooleanStateQueryVerifiers
 366
 367 namespace
 368 {
 369
 370 using namespace BooleanStateQueryVerifiers;
 371
 372 class IsEnabledStateTestCase : public ApiCase
 373 {
 374 public:
 375         IsEnabledStateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum targetName, bool initial)
 376                 : ApiCase               (context, name, description)
 377                 , m_targetName  (targetName)
 378                 , m_initial             (initial)
 379                 , m_verifier    (verifier)
 380         {
 381         }
 382
 383         void test (void)
 384         {
 385                 // check inital value
 386                 m_verifier->verifyBoolean(m_testCtx, m_targetName, m_initial);
 387                 expectError(GL_NO_ERROR);
 388
 389                 // check toggle
 390
 391                 glEnable(m_targetName);
 392                 expectError(GL_NO_ERROR);
 393
 394                 m_verifier->verifyBoolean(m_testCtx, m_targetName, true);
 395                 expectError(GL_NO_ERROR);
 396
 397                 glDisable(m_targetName);
 398                 expectError(GL_NO_ERROR);
 399
 400                 m_verifier->verifyBoolean(m_testCtx, m_targetName, false);
 401                 expectError(GL_NO_ERROR);
 402         }
 403
 404 private:
 405         GLenum                  m_targetName;
 406         bool                    m_initial;
 407         StateVerifier*  m_verifier;
 408 };
 409
 410 class DepthWriteMaskTestCase : public ApiCase
 411 {
 412 public:
 413         DepthWriteMaskTestCase  (Context& context, StateVerifier* verifier, const char* name, const char* description)
 414                 : ApiCase               (context, name, description)
 415                 , m_verifier    (verifier)
 416         {
 417         }
 418
 419         void test (void)
 420         {
 421                 m_verifier->verifyBoolean(m_testCtx, GL_DEPTH_WRITEMASK, true);
 422                 expectError(GL_NO_ERROR);
 423
 424                 glDepthMask(GL_FALSE);
 425                 m_verifier->verifyBoolean(m_testCtx, GL_DEPTH_WRITEMASK, false);
 426                 expectError(GL_NO_ERROR);
 427
 428                 glDepthMask(GL_TRUE);
 429                 m_verifier->verifyBoolean(m_testCtx, GL_DEPTH_WRITEMASK, true);
 430                 expectError(GL_NO_ERROR);
 431         }
 432 private:
 433         StateVerifier*  m_verifier;
 434 };
 435
 436 class SampleCoverageInvertTestCase : public ApiCase
 437 {
 438 public:
 439         SampleCoverageInvertTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
 440                 : ApiCase               (context, name, description)
 441                 , m_verifier    (verifier)
 442         {
 443         }
 444
 445         void test (void)
 446         {
 447                 m_verifier->verifyBoolean(m_testCtx, GL_SAMPLE_COVERAGE_INVERT, false);
 448                 expectError(GL_NO_ERROR);
 449
 450                 glSampleCoverage(1.0f, GL_TRUE);
 451                 m_verifier->verifyBoolean(m_testCtx, GL_SAMPLE_COVERAGE_INVERT, true);
 452                 expectError(GL_NO_ERROR);
 453
 454                 glSampleCoverage(1.0f, GL_FALSE);
 455                 m_verifier->verifyBoolean(m_testCtx, GL_SAMPLE_COVERAGE_INVERT, false);
 456                 expectError(GL_NO_ERROR);
 457         }
 458 private:
 459         StateVerifier*  m_verifier;
 460 };
 461
 462 class ShaderCompilerTestCase : public ApiCase
 463 {
 464 public:
 465         ShaderCompilerTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
 466                 : ApiCase               (context, name, description)
 467                 , m_verifier    (verifier)
 468         {
 469         }
 470
 471         void test (void)
 472         {
 473                 m_verifier->verifyBooleanAnything(m_testCtx, GL_SHADER_COMPILER);
 474                 expectError(GL_NO_ERROR);
 475         }
 476
 477 private:
 478         StateVerifier*  m_verifier;
 479 };
 480
 481 class ColorMaskTestCase : public ApiCase
 482 {
 483 public:
 484         ColorMaskTestCase       (Context& context, StateVerifier* verifier, const char* name, const char* description)
 485                 : ApiCase(context, name, description)
 486                 , m_verifier    (verifier)
 487         {
 488         }
 489         void test (void)
 490         {
 491                 m_verifier->verifyBoolean4(m_testCtx, GL_COLOR_WRITEMASK, true, true, true, true);
 492                 expectError(GL_NO_ERROR);
 493
 494                 const struct ColorMask
 495                 {
 496                         GLboolean r, g, b, a;
 497                 } testMasks[] =
 498                 {
 499                         { GL_TRUE,      GL_TRUE,        GL_TRUE,        GL_TRUE  },
 500                         { GL_TRUE,      GL_TRUE,        GL_TRUE,        GL_FALSE },
 501                         { GL_TRUE,      GL_TRUE,        GL_FALSE,       GL_TRUE  },
 502                         { GL_TRUE,      GL_TRUE,        GL_FALSE,       GL_FALSE },
 503                         { GL_TRUE,      GL_FALSE,       GL_TRUE,        GL_TRUE  },
 504                         { GL_TRUE,      GL_FALSE,       GL_TRUE,        GL_FALSE },
 505                         { GL_TRUE,      GL_FALSE,       GL_FALSE,       GL_TRUE  },
 506                         { GL_TRUE,      GL_FALSE,       GL_FALSE,       GL_FALSE },
 507                         { GL_FALSE,     GL_TRUE,        GL_TRUE,        GL_TRUE  },
 508                         { GL_FALSE,     GL_TRUE,        GL_TRUE,        GL_FALSE },
 509                         { GL_FALSE,     GL_TRUE,        GL_FALSE,       GL_TRUE  },
 510                         { GL_FALSE,     GL_TRUE,        GL_FALSE,       GL_FALSE },
 511                         { GL_FALSE,     GL_FALSE,       GL_TRUE,        GL_TRUE  },
 512                         { GL_FALSE,     GL_FALSE,       GL_TRUE,        GL_FALSE },
 513                         { GL_FALSE,     GL_FALSE,       GL_FALSE,       GL_TRUE  },
 514                         { GL_FALSE,     GL_FALSE,       GL_FALSE,       GL_FALSE },
 515                 };
 516
 517                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(testMasks); ndx++)
 518                 {
 519                         glColorMask(testMasks[ndx].r, testMasks[ndx].g, testMasks[ndx].b, testMasks[ndx].a);
 520                         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);
 521                         expectError(GL_NO_ERROR);
 522                 }
 523         }
 524 private:
 525         StateVerifier*  m_verifier;
 526 };
 527
 528 #define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK)                                                                                                \
 529         for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++)        \
 530         {                                                                                                                                                                                       \
 531                 StateVerifier* verifier = (VERIFIERS)[_verifierNdx];                                                                    \
 532                 CODE_BLOCK;                                                                                                                                                             \
 533         }
 534
 535 } // anonymous
 536
 537 BooleanStateQueryTests::BooleanStateQueryTests (Context& context)
 538         : TestCaseGroup                         (context, "boolean", "Boolean State Query tests")
 539         , m_verifierIsEnabled           (DE_NULL)
 540         , m_verifierBoolean                     (DE_NULL)
 541         , m_verifierInteger                     (DE_NULL)
 542         , m_verifierFloat                       (DE_NULL)
 543 {
 544 }
 545
 546 BooleanStateQueryTests::~BooleanStateQueryTests (void)
 547 {
 548         deinit();
 549 }
 550
 551 void BooleanStateQueryTests::init (void)
 552 {
 553         DE_ASSERT(m_verifierIsEnabled == DE_NULL);
 554         DE_ASSERT(m_verifierBoolean == DE_NULL);
 555         DE_ASSERT(m_verifierInteger == DE_NULL);
 556         DE_ASSERT(m_verifierFloat == DE_NULL);
 557
 558         m_verifierIsEnabled             = new IsEnabledVerifier         (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
 559         m_verifierBoolean               = new GetBooleanVerifier        (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
 560         m_verifierInteger               = new GetIntegerVerifier        (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
 561         m_verifierFloat                 = new GetFloatVerifier          (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
 562
 563         StateVerifier* isEnabledVerifiers[] = {m_verifierIsEnabled, m_verifierBoolean, m_verifierInteger, m_verifierFloat};
 564         StateVerifier* normalVerifiers[]        = {                                             m_verifierBoolean, m_verifierInteger, m_verifierFloat};
 565
 566         struct StateBoolean
 567         {
 568                 const char*             name;
 569                 const char*             description;
 570                 GLenum                  targetName;
 571                 bool                    value;
 572         };
 573         const StateBoolean isEnableds[] =
 574         {
 575                 { "cull_face",                                          "CULL_FACE",                                            GL_CULL_FACE,                                           false},
 576                 { "polygon_offset_fill",                        "POLYGON_OFFSET_FILL",                          GL_POLYGON_OFFSET_FILL,                         false},
 577                 { "sample_alpha_to_coverage",           "SAMPLE_ALPHA_TO_COVERAGE",                     GL_SAMPLE_ALPHA_TO_COVERAGE,            false},
 578                 { "sample_coverage",                            "SAMPLE_COVERAGE",                                      GL_SAMPLE_COVERAGE,                                     false},
 579                 { "scissor_test",                                       "SCISSOR_TEST",                                         GL_SCISSOR_TEST,                                        false},
 580                 { "stencil_test",                                       "STENCIL_TEST",                                         GL_STENCIL_TEST,                                        false},
 581                 { "depth_test",                                         "DEPTH_TEST",                                           GL_DEPTH_TEST,                                          false},
 582                 { "blend",                                                      "BLEND",                                                        GL_BLEND,                                                       false},
 583                 { "dither",                                                     "DITHER",                                                       GL_DITHER,                                                      true },
 584         };
 585         for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(isEnableds); testNdx++)
 586                 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)));
 587
 588         FOR_EACH_VERIFIER(normalVerifiers, addChild(new SampleCoverageInvertTestCase                            (m_context, verifier, (std::string("sample_coverage_invert")                            + verifier->getTestNamePostfix()).c_str(), "SAMPLE_COVERAGE_INVERT")));
 589         FOR_EACH_VERIFIER(normalVerifiers, addChild(new ColorMaskTestCase                                                       (m_context, verifier, (std::string("color_writemask")                                           + verifier->getTestNamePostfix()).c_str(), "COLOR_WRITEMASK")));
 590         FOR_EACH_VERIFIER(normalVerifiers, addChild(new DepthWriteMaskTestCase                                          (m_context, verifier, (std::string("depth_writemask")                                           + verifier->getTestNamePostfix()).c_str(), "DEPTH_WRITEMASK")));
 591         FOR_EACH_VERIFIER(normalVerifiers, addChild(new ShaderCompilerTestCase                                          (m_context, verifier, (std::string("shader_compiler")                                           + verifier->getTestNamePostfix()).c_str(), "SHADER_COMPILER")));
 592 }
 593
 594 void BooleanStateQueryTests::deinit (void)
 595 {
 596         if (m_verifierIsEnabled)
 597         {
 598                 delete m_verifierIsEnabled;
 599                 m_verifierIsEnabled = DE_NULL;
 600         }
 601         if (m_verifierBoolean)
 602         {
 603                 delete m_verifierBoolean;
 604                 m_verifierBoolean = DE_NULL;
 605         }
 606         if (m_verifierInteger)
 607         {
 608                 delete m_verifierInteger;
 609                 m_verifierInteger = DE_NULL;
 610         }
 611         if (m_verifierFloat)
 612         {
 613                 delete m_verifierFloat;
 614                 m_verifierFloat = DE_NULL;
 615         }
 616
 617         this->TestCaseGroup::deinit();
 618 }
 619
 620 } // Functional
 621 } // gles2
 622 } // deqp