modules/gles3/functional/es3fBooleanStateQueryTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.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 "es3fBooleanStateQueryTests.hpp"
  25 #include "glsStateQueryUtil.hpp"
  26 #include "es3fApiCase.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 gles3
  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 private:
  56         const char*     const   m_testNamePostfix;
  57 };
  58
  59 StateVerifier::StateVerifier (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix)
  60         : glu::CallLogWrapper   (gl, log)
  61         , m_testNamePostfix             (testNamePostfix)
  62 {
  63         enableLogging(true);
  64 }
  65
  66 StateVerifier::~StateVerifier ()
  67 {
  68 }
  69
  70 const char* StateVerifier::getTestNamePostfix (void) const
  71 {
  72         return m_testNamePostfix;
  73 }
  74
  75 // IsEnabledVerifier
  76
  77 class IsEnabledVerifier : public StateVerifier
  78 {
  79 public:
  80                         IsEnabledVerifier                       (const glw::Functions& gl, tcu::TestLog& log);
  81         void    verifyBoolean                                   (tcu::TestContext& testCtx, GLenum name, bool reference);
  82         void    verifyBoolean4                                  (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3);
  83 };
  84
  85 IsEnabledVerifier::IsEnabledVerifier (const glw::Functions& gl, tcu::TestLog& log)
  86         : StateVerifier(gl, log, "_isenabled")
  87 {
  88 }
  89
  90 void IsEnabledVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
  91 {
  92         using tcu::TestLog;
  93
  94         const GLboolean state = glIsEnabled(name);
  95         const GLboolean expectedGLState = reference ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE;
  96
  97         if (state != expectedGLState)
  98         {
  99                 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << (reference ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
 100                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 101                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 102         }
 103 }
 104
 105 void IsEnabledVerifier::verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)
 106 {
 107         DE_UNREF(testCtx);
 108         DE_UNREF(name);
 109         DE_UNREF(reference0);
 110         DE_UNREF(reference1);
 111         DE_UNREF(reference2);
 112         DE_UNREF(reference3);
 113         DE_ASSERT(false && "not supported");
 114 }
 115
 116 // GetBooleanVerifier
 117
 118 class GetBooleanVerifier : public StateVerifier
 119 {
 120 public:
 121                         GetBooleanVerifier              (const glw::Functions& gl, tcu::TestLog& log);
 122         void    verifyBoolean                                   (tcu::TestContext& testCtx, GLenum name, bool reference);
 123         void    verifyBoolean4                                  (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3);
 124 };
 125
 126 GetBooleanVerifier::GetBooleanVerifier (const glw::Functions& gl, tcu::TestLog& log)
 127         : StateVerifier(gl, log, "_getboolean")
 128 {
 129 }
 130
 131 void GetBooleanVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
 132 {
 133         using tcu::TestLog;
 134
 135         StateQueryMemoryWriteGuard<GLboolean> state;
 136         glGetBooleanv(name, &state);
 137
 138         if (!state.verifyValidity(testCtx))
 139                 return;
 140
 141         const GLboolean expectedGLState = reference ? GL_TRUE : GL_FALSE;
 142
 143         if (state != expectedGLState)
 144         {
 145                 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << (reference ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
 146                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 147                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 148         }
 149 }
 150
 151 void GetBooleanVerifier::verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)
 152 {
 153         using tcu::TestLog;
 154
 155         StateQueryMemoryWriteGuard<GLboolean[4]> boolVector4;
 156         glGetBooleanv(name, boolVector4);
 157
 158         if (!boolVector4.verifyValidity(testCtx))
 159                 return;
 160
 161         const GLboolean referenceAsGLBoolean[] =
 162         {
 163                 reference0 ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE),
 164                 reference1 ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE),
 165                 reference2 ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE),
 166                 reference3 ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE),
 167         };
 168
 169         if (boolVector4[0] != referenceAsGLBoolean[0] ||
 170                 boolVector4[1] != referenceAsGLBoolean[1] ||
 171                 boolVector4[2] != referenceAsGLBoolean[2] ||
 172                 boolVector4[3] != referenceAsGLBoolean[3])
 173         {
 174                 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
 175                         << (referenceAsGLBoolean[0] ? "GL_TRUE" : "GL_FALSE") << " "
 176                         << (referenceAsGLBoolean[1] ? "GL_TRUE" : "GL_FALSE") << " "
 177                         << (referenceAsGLBoolean[2] ? "GL_TRUE" : "GL_FALSE") << " "
 178                         << (referenceAsGLBoolean[3] ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
 179
 180                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 181                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 182         }
 183 }
 184
 185 //GetIntegerVerifier
 186
 187 class GetIntegerVerifier : public StateVerifier
 188 {
 189 public:
 190                         GetIntegerVerifier              (const glw::Functions& gl, tcu::TestLog& log);
 191         void    verifyBoolean                                   (tcu::TestContext& testCtx, GLenum name, bool reference);
 192         void    verifyBoolean4                                  (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3);
 193
 194 };
 195
 196 GetIntegerVerifier::GetIntegerVerifier (const glw::Functions& gl, tcu::TestLog& log)
 197         : StateVerifier(gl, log, "_getinteger")
 198 {
 199 }
 200
 201 void GetIntegerVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
 202 {
 203         using tcu::TestLog;
 204
 205         StateQueryMemoryWriteGuard<GLint> state;
 206         glGetIntegerv(name, &state);
 207
 208         if (!state.verifyValidity(testCtx))
 209                 return;
 210
 211         const GLint expectedGLState = reference ? 1 : 0;
 212
 213         if (state != expectedGLState)
 214         {
 215                 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << expectedGLState << TestLog::EndMessage;
 216                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 217                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 218         }
 219 }
 220
 221 void GetIntegerVerifier::verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)
 222 {
 223         using tcu::TestLog;
 224
 225         StateQueryMemoryWriteGuard<GLint[4]> boolVector4;
 226         glGetIntegerv(name, boolVector4);
 227
 228         if (!boolVector4.verifyValidity(testCtx))
 229                 return;
 230
 231         const GLint referenceAsGLint[] =
 232         {
 233                 reference0 ? 1 : 0,
 234                 reference1 ? 1 : 0,
 235                 reference2 ? 1 : 0,
 236                 reference3 ? 1 : 0,
 237         };
 238
 239         if (boolVector4[0] != referenceAsGLint[0] ||
 240                 boolVector4[1] != referenceAsGLint[1] ||
 241                 boolVector4[2] != referenceAsGLint[2] ||
 242                 boolVector4[3] != referenceAsGLint[3])
 243         {
 244                 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
 245                         << referenceAsGLint[0] << " "
 246                         << referenceAsGLint[1] << " "
 247                         << referenceAsGLint[2] << " "
 248                         << referenceAsGLint[3] << " " << TestLog::EndMessage;
 249
 250                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 251                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 252         }
 253 }
 254
 255 //GetInteger64Verifier
 256
 257 class GetInteger64Verifier : public StateVerifier
 258 {
 259 public:
 260                         GetInteger64Verifier            (const glw::Functions& gl, tcu::TestLog& log);
 261         void    verifyBoolean                                   (tcu::TestContext& testCtx, GLenum name, bool reference);
 262         void    verifyBoolean4                                  (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3);
 263 };
 264
 265 GetInteger64Verifier::GetInteger64Verifier (const glw::Functions& gl, tcu::TestLog& log)
 266         : StateVerifier(gl, log, "_getinteger64")
 267 {
 268 }
 269
 270 void GetInteger64Verifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
 271 {
 272         using tcu::TestLog;
 273
 274         StateQueryMemoryWriteGuard<GLint64> state;
 275         glGetInteger64v(name, &state);
 276
 277         if (!state.verifyValidity(testCtx))
 278                 return;
 279
 280         const GLint64 expectedGLState = reference ? 1 : 0;
 281
 282         if (state != expectedGLState)
 283         {
 284                 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << expectedGLState << TestLog::EndMessage;
 285                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 286                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 287         }
 288 }
 289
 290 void GetInteger64Verifier::verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)
 291 {
 292         using tcu::TestLog;
 293
 294         StateQueryMemoryWriteGuard<GLint64[4]> boolVector4;
 295         glGetInteger64v(name, boolVector4);
 296
 297         if (!boolVector4.verifyValidity(testCtx))
 298                 return;
 299
 300         const GLint64 referenceAsGLint64[] =
 301         {
 302                 reference0 ? 1 : 0,
 303                 reference1 ? 1 : 0,
 304                 reference2 ? 1 : 0,
 305                 reference3 ? 1 : 0,
 306         };
 307
 308         if (boolVector4[0] != referenceAsGLint64[0] ||
 309                 boolVector4[1] != referenceAsGLint64[1] ||
 310                 boolVector4[2] != referenceAsGLint64[2] ||
 311                 boolVector4[3] != referenceAsGLint64[3])
 312         {
 313                 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
 314                         << referenceAsGLint64[0] << " "
 315                         << referenceAsGLint64[1] << " "
 316                         << referenceAsGLint64[2] << " "
 317                         << referenceAsGLint64[3] << " " << TestLog::EndMessage;
 318
 319                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 320                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 321         }
 322 }
 323
 324 //GetFloatVerifier
 325
 326 class GetFloatVerifier : public StateVerifier
 327 {
 328 public:
 329                         GetFloatVerifier                        (const glw::Functions& gl, tcu::TestLog& log);
 330         void    verifyBoolean                                   (tcu::TestContext& testCtx, GLenum name, bool reference);
 331         void    verifyBoolean4                                  (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3);
 332 };
 333
 334 GetFloatVerifier::GetFloatVerifier (const glw::Functions& gl, tcu::TestLog& log)
 335         : StateVerifier(gl, log, "_getfloat")
 336 {
 337 }
 338
 339 void GetFloatVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
 340 {
 341         using tcu::TestLog;
 342
 343         StateQueryMemoryWriteGuard<GLfloat> state;
 344         glGetFloatv(name, &state);
 345
 346         if (!state.verifyValidity(testCtx))
 347                 return;
 348
 349         const GLfloat expectedGLState = reference ? 1.0f : 0.0f;
 350
 351         if (state != expectedGLState)
 352         {
 353                 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << expectedGLState << "; got " << state << TestLog::EndMessage;
 354                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 355                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
 356         }
 357 }
 358
 359 void GetFloatVerifier::verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)
 360 {
 361         using tcu::TestLog;
 362
 363         StateQueryMemoryWriteGuard<GLfloat[4]> boolVector4;
 364         glGetFloatv(name, boolVector4);
 365
 366         if (!boolVector4.verifyValidity(testCtx))
 367                 return;
 368
 369         const GLfloat referenceAsGLfloat[] =
 370         {
 371                 reference0 ? 1.0f : 0.0f,
 372                 reference1 ? 1.0f : 0.0f,
 373                 reference2 ? 1.0f : 0.0f,
 374                 reference3 ? 1.0f : 0.0f,
 375         };
 376
 377         if (boolVector4[0] != referenceAsGLfloat[0] ||
 378                 boolVector4[1] != referenceAsGLfloat[1] ||
 379                 boolVector4[2] != referenceAsGLfloat[2] ||
 380                 boolVector4[3] != referenceAsGLfloat[3])
 381         {
 382                 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
 383                         << referenceAsGLfloat[0] << " "
 384                         << referenceAsGLfloat[1] << " "
 385                         << referenceAsGLfloat[2] << " "
 386                         << referenceAsGLfloat[3] << " " << TestLog::EndMessage;
 387
 388                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 389                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
 390         }
 391 }
 392
 393 } // BooleanStateQueryVerifiers
 394
 395 namespace
 396 {
 397
 398 using namespace BooleanStateQueryVerifiers;
 399
 400 static const char* transformFeedbackTestVertSource      =       "#version 300 es\n"
 401                                                                                                                 "void main (void)\n"
 402                                                                                                                 "{\n"
 403                                                                                                                 "       gl_Position = vec4(0.0);\n"
 404                                                                                                                 "}\n\0";
 405 static const char* transformFeedbackTestFragSource      =       "#version 300 es\n"
 406                                                                                                                 "layout(location = 0) out mediump vec4 fragColor;"
 407                                                                                                                 "void main (void)\n"
 408                                                                                                                 "{\n"
 409                                                                                                                 "       fragColor = vec4(0.0);\n"
 410                                                                                                                 "}\n\0";
 411
 412 class IsEnabledStateTestCase : public ApiCase
 413 {
 414 public:
 415         IsEnabledStateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum targetName, bool initial)
 416                 : ApiCase               (context, name, description)
 417                 , m_targetName  (targetName)
 418                 , m_initial             (initial)
 419                 , m_verifier    (verifier)
 420         {
 421         }
 422
 423         void test (void)
 424         {
 425                 // check inital value
 426                 m_verifier->verifyBoolean(m_testCtx, m_targetName, m_initial);
 427                 expectError(GL_NO_ERROR);
 428
 429                 // check toggle
 430
 431                 glEnable(m_targetName);
 432                 expectError(GL_NO_ERROR);
 433
 434                 m_verifier->verifyBoolean(m_testCtx, m_targetName, true);
 435                 expectError(GL_NO_ERROR);
 436
 437                 glDisable(m_targetName);
 438                 expectError(GL_NO_ERROR);
 439
 440                 m_verifier->verifyBoolean(m_testCtx, m_targetName, false);
 441                 expectError(GL_NO_ERROR);
 442         }
 443
 444 private:
 445         GLenum                  m_targetName;
 446         bool                    m_initial;
 447         StateVerifier*  m_verifier;
 448 };
 449
 450 class DepthWriteMaskTestCase : public ApiCase
 451 {
 452 public:
 453         DepthWriteMaskTestCase  (Context& context, StateVerifier* verifier, const char* name, const char* description)
 454                 : ApiCase               (context, name, description)
 455                 , m_verifier    (verifier)
 456         {
 457         }
 458
 459         void test (void)
 460         {
 461                 m_verifier->verifyBoolean(m_testCtx, GL_DEPTH_WRITEMASK, true);
 462                 expectError(GL_NO_ERROR);
 463
 464                 glDepthMask(GL_FALSE);
 465                 m_verifier->verifyBoolean(m_testCtx, GL_DEPTH_WRITEMASK, false);
 466                 expectError(GL_NO_ERROR);
 467
 468                 glDepthMask(GL_TRUE);
 469                 m_verifier->verifyBoolean(m_testCtx, GL_DEPTH_WRITEMASK, true);
 470                 expectError(GL_NO_ERROR);
 471         }
 472 private:
 473         StateVerifier*  m_verifier;
 474 };
 475
 476 class SampleCoverageInvertTestCase : public ApiCase
 477 {
 478 public:
 479         SampleCoverageInvertTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
 480                 : ApiCase               (context, name, description)
 481                 , m_verifier    (verifier)
 482         {
 483         }
 484
 485         void test (void)
 486         {
 487                 m_verifier->verifyBoolean(m_testCtx, GL_SAMPLE_COVERAGE_INVERT, false);
 488                 expectError(GL_NO_ERROR);
 489
 490                 glSampleCoverage(1.0f, GL_TRUE);
 491                 m_verifier->verifyBoolean(m_testCtx, GL_SAMPLE_COVERAGE_INVERT, true);
 492                 expectError(GL_NO_ERROR);
 493
 494                 glSampleCoverage(1.0f, GL_FALSE);
 495                 m_verifier->verifyBoolean(m_testCtx, GL_SAMPLE_COVERAGE_INVERT, false);
 496                 expectError(GL_NO_ERROR);
 497         }
 498 private:
 499         StateVerifier*  m_verifier;
 500 };
 501
 502 class InitialBooleanTestCase : public ApiCase
 503 {
 504 public:
 505         InitialBooleanTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum target, bool reference)
 506                 : ApiCase               (context, name, description)
 507                 , m_target              (target)
 508                 , m_reference   (reference)
 509                 , m_verifier    (verifier)
 510         {
 511         }
 512
 513         void test (void)
 514         {
 515                 m_verifier->verifyBoolean(m_testCtx, m_target, m_reference);
 516                 expectError(GL_NO_ERROR);
 517         }
 518
 519 private:
 520         GLenum                  m_target;
 521         bool                    m_reference;
 522         StateVerifier*  m_verifier;
 523 };
 524
 525 class ColorMaskTestCase : public ApiCase
 526 {
 527 public:
 528         ColorMaskTestCase       (Context& context, StateVerifier* verifier, const char* name, const char* description)
 529                 : ApiCase(context, name, description)
 530                 , m_verifier    (verifier)
 531         {
 532         }
 533         void test (void)
 534         {
 535                 m_verifier->verifyBoolean4(m_testCtx, GL_COLOR_WRITEMASK, true, true, true, true);
 536                 expectError(GL_NO_ERROR);
 537
 538                 const struct ColorMask
 539                 {
 540                         GLboolean r, g, b, a;
 541                 } testMasks[] =
 542                 {
 543                         { GL_TRUE,      GL_TRUE,        GL_TRUE,        GL_TRUE  },
 544                         { GL_TRUE,      GL_TRUE,        GL_TRUE,        GL_FALSE },
 545                         { GL_TRUE,      GL_TRUE,        GL_FALSE,       GL_TRUE  },
 546                         { GL_TRUE,      GL_TRUE,        GL_FALSE,       GL_FALSE },
 547                         { GL_TRUE,      GL_FALSE,       GL_TRUE,        GL_TRUE  },
 548                         { GL_TRUE,      GL_FALSE,       GL_TRUE,        GL_FALSE },
 549                         { GL_TRUE,      GL_FALSE,       GL_FALSE,       GL_TRUE  },
 550                         { GL_TRUE,      GL_FALSE,       GL_FALSE,       GL_FALSE },
 551                         { GL_FALSE,     GL_TRUE,        GL_TRUE,        GL_TRUE  },
 552                         { GL_FALSE,     GL_TRUE,        GL_TRUE,        GL_FALSE },
 553                         { GL_FALSE,     GL_TRUE,        GL_FALSE,       GL_TRUE  },
 554                         { GL_FALSE,     GL_TRUE,        GL_FALSE,       GL_FALSE },
 555                         { GL_FALSE,     GL_FALSE,       GL_TRUE,        GL_TRUE  },
 556                         { GL_FALSE,     GL_FALSE,       GL_TRUE,        GL_FALSE },
 557                         { GL_FALSE,     GL_FALSE,       GL_FALSE,       GL_TRUE  },
 558                         { GL_FALSE,     GL_FALSE,       GL_FALSE,       GL_FALSE },
 559                 };
 560
 561                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(testMasks); ndx++)
 562                 {
 563                         glColorMask(testMasks[ndx].r, testMasks[ndx].g, testMasks[ndx].b, testMasks[ndx].a);
 564                         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);
 565                         expectError(GL_NO_ERROR);
 566                 }
 567         }
 568 private:
 569         StateVerifier*  m_verifier;
 570 };
 571
 572
 573 class TransformFeedbackTestCase : public ApiCase
 574 {
 575 public:
 576         TransformFeedbackTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
 577                 : ApiCase                               (context, name, description)
 578                 , m_verifier                    (verifier)
 579                 , m_transformfeedback   (0)
 580         {
 581         }
 582
 583         void test (void)
 584         {
 585                 glGenTransformFeedbacks(1, &m_transformfeedback);
 586                 expectError(GL_NO_ERROR);
 587
 588                 GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER);
 589                 glShaderSource(shaderVert, 1, &transformFeedbackTestVertSource, DE_NULL);
 590                 glCompileShader(shaderVert);
 591                 expectError(GL_NO_ERROR);
 592                 GLint compileStatus;
 593                 glGetShaderiv(shaderVert, GL_COMPILE_STATUS, &compileStatus);
 594                 checkBooleans(compileStatus, GL_TRUE);
 595
 596                 GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER);
 597                 glShaderSource(shaderFrag, 1, &transformFeedbackTestFragSource, DE_NULL);
 598                 glCompileShader(shaderFrag);
 599                 expectError(GL_NO_ERROR);
 600                 glGetShaderiv(shaderFrag, GL_COMPILE_STATUS, &compileStatus);
 601                 checkBooleans(compileStatus, GL_TRUE);
 602
 603                 GLuint shaderProg = glCreateProgram();
 604                 glAttachShader(shaderProg, shaderVert);
 605                 glAttachShader(shaderProg, shaderFrag);
 606                 const char* transform_feedback_outputs = "gl_Position";
 607                 glTransformFeedbackVaryings(shaderProg, 1, &transform_feedback_outputs, GL_INTERLEAVED_ATTRIBS);
 608                 glLinkProgram(shaderProg);
 609                 expectError(GL_NO_ERROR);
 610                 GLint linkStatus;
 611                 glGetProgramiv(shaderProg, GL_LINK_STATUS, &linkStatus);
 612                 checkBooleans(linkStatus, GL_TRUE);
 613
 614                 glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transformfeedback);
 615                 expectError(GL_NO_ERROR);
 616
 617                 GLuint feedbackBufferId;
 618                 glGenBuffers(1, &feedbackBufferId);
 619                 glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackBufferId);
 620                 glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_DYNAMIC_READ);
 621                 glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, feedbackBufferId);
 622                 expectError(GL_NO_ERROR);
 623
 624                 glUseProgram(shaderProg);
 625
 626                 testTransformFeedback();
 627
 628                 glUseProgram(0);
 629                 glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
 630                 glDeleteTransformFeedbacks(1, &m_transformfeedback);
 631                 glDeleteBuffers(1, &feedbackBufferId);
 632                 glDeleteShader(shaderVert);
 633                 glDeleteShader(shaderFrag);
 634                 glDeleteProgram(shaderProg);
 635                 expectError(GL_NO_ERROR);
 636         }
 637
 638         virtual void testTransformFeedback (void) = DE_NULL;
 639
 640 protected:
 641         StateVerifier*  m_verifier;
 642         GLuint                  m_transformfeedback;
 643 };
 644
 645 class TransformFeedbackBasicTestCase : public TransformFeedbackTestCase
 646 {
 647 public:
 648         TransformFeedbackBasicTestCase (Context& context, StateVerifier* verifier, const char* name)
 649                 : TransformFeedbackTestCase     (context, verifier, name, "Test TRANSFORM_FEEDBACK_ACTIVE and TRANSFORM_FEEDBACK_PAUSED")
 650         {
 651         }
 652
 653         void testTransformFeedback (void)
 654         {
 655                 glBeginTransformFeedback(GL_POINTS);
 656                 expectError(GL_NO_ERROR);
 657
 658                 m_verifier->verifyBoolean(m_testCtx, GL_TRANSFORM_FEEDBACK_ACTIVE, true);
 659                 m_verifier->verifyBoolean(m_testCtx, GL_TRANSFORM_FEEDBACK_PAUSED, false);
 660                 expectError(GL_NO_ERROR);
 661
 662                 glPauseTransformFeedback();
 663                 expectError(GL_NO_ERROR);
 664
 665                 m_verifier->verifyBoolean(m_testCtx, GL_TRANSFORM_FEEDBACK_ACTIVE, true);
 666                 m_verifier->verifyBoolean(m_testCtx, GL_TRANSFORM_FEEDBACK_PAUSED, true);
 667                 expectError(GL_NO_ERROR);
 668
 669                 glResumeTransformFeedback();
 670                 expectError(GL_NO_ERROR);
 671
 672                 m_verifier->verifyBoolean(m_testCtx, GL_TRANSFORM_FEEDBACK_ACTIVE, true);
 673                 m_verifier->verifyBoolean(m_testCtx, GL_TRANSFORM_FEEDBACK_PAUSED, false);
 674                 expectError(GL_NO_ERROR);
 675
 676                 glEndTransformFeedback();
 677                 expectError(GL_NO_ERROR);
 678
 679                 m_verifier->verifyBoolean(m_testCtx, GL_TRANSFORM_FEEDBACK_ACTIVE, false);
 680                 m_verifier->verifyBoolean(m_testCtx, GL_TRANSFORM_FEEDBACK_PAUSED, false);
 681                 expectError(GL_NO_ERROR);
 682         }
 683 };
 684
 685 class TransformFeedbackImplicitResumeTestCase : public TransformFeedbackTestCase
 686 {
 687 public:
 688         TransformFeedbackImplicitResumeTestCase (Context& context, StateVerifier* verifier, const char* name)
 689                 : TransformFeedbackTestCase(context, verifier, name, "EndTransformFeedback performs an implicit ResumeTransformFeedback.")
 690         {
 691         }
 692
 693         void testTransformFeedback (void)
 694         {
 695                 glBeginTransformFeedback(GL_POINTS);
 696                 expectError(GL_NO_ERROR);
 697
 698                 m_verifier->verifyBoolean(m_testCtx, GL_TRANSFORM_FEEDBACK_ACTIVE, true);
 699                 m_verifier->verifyBoolean(m_testCtx, GL_TRANSFORM_FEEDBACK_PAUSED, false);
 700                 expectError(GL_NO_ERROR);
 701
 702                 glPauseTransformFeedback();
 703                 expectError(GL_NO_ERROR);
 704
 705                 m_verifier->verifyBoolean(m_testCtx, GL_TRANSFORM_FEEDBACK_ACTIVE, true);
 706                 m_verifier->verifyBoolean(m_testCtx, GL_TRANSFORM_FEEDBACK_PAUSED, true);
 707                 expectError(GL_NO_ERROR);
 708
 709                 glEndTransformFeedback();
 710                 expectError(GL_NO_ERROR);
 711
 712                 m_verifier->verifyBoolean(m_testCtx, GL_TRANSFORM_FEEDBACK_ACTIVE, false);
 713                 m_verifier->verifyBoolean(m_testCtx, GL_TRANSFORM_FEEDBACK_PAUSED, false);
 714                 expectError(GL_NO_ERROR);
 715         }
 716 };
 717
 718 #define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK)                                                                                                \
 719         for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++)        \
 720         {                                                                                                                                                                                       \
 721                 StateVerifier* verifier = (VERIFIERS)[_verifierNdx];                                                                    \
 722                 CODE_BLOCK;                                                                                                                                                             \
 723         }
 724
 725 } // anonymous
 726
 727 BooleanStateQueryTests::BooleanStateQueryTests (Context& context)
 728         : TestCaseGroup                         (context, "boolean", "Boolean State Query tests")
 729         , m_verifierIsEnabled           (DE_NULL)
 730         , m_verifierBoolean                     (DE_NULL)
 731         , m_verifierInteger                     (DE_NULL)
 732         , m_verifierInteger64           (DE_NULL)
 733         , m_verifierFloat                       (DE_NULL)
 734 {
 735 }
 736
 737 BooleanStateQueryTests::~BooleanStateQueryTests (void)
 738 {
 739         deinit();
 740 }
 741
 742 void BooleanStateQueryTests::init (void)
 743 {
 744         DE_ASSERT(m_verifierIsEnabled == DE_NULL);
 745         DE_ASSERT(m_verifierBoolean == DE_NULL);
 746         DE_ASSERT(m_verifierInteger == DE_NULL);
 747         DE_ASSERT(m_verifierInteger64 == DE_NULL);
 748         DE_ASSERT(m_verifierFloat == DE_NULL);
 749
 750         m_verifierIsEnabled             = new IsEnabledVerifier         (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
 751         m_verifierBoolean               = new GetBooleanVerifier        (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
 752         m_verifierInteger               = new GetIntegerVerifier        (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
 753         m_verifierInteger64             = new GetInteger64Verifier      (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
 754         m_verifierFloat                 = new GetFloatVerifier          (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
 755
 756         StateVerifier* isEnabledVerifiers[] = {m_verifierIsEnabled, m_verifierBoolean, m_verifierInteger, m_verifierInteger64, m_verifierFloat};
 757         StateVerifier* normalVerifiers[] = {m_verifierBoolean, m_verifierInteger, m_verifierInteger64, m_verifierFloat};
 758
 759         struct StateBoolean
 760         {
 761                 const char*             name;
 762                 const char*             description;
 763                 GLenum                  targetName;
 764                 bool                    value;
 765         };
 766         const StateBoolean isEnableds[] =
 767         {
 768                 { "primitive_restart_fixed_index",      "PRIMITIVE_RESTART_FIXED_INDEX",        GL_PRIMITIVE_RESTART_FIXED_INDEX,       false},
 769                 { "rasterizer_discard",                         "RASTERIZER_DISCARD",                           GL_RASTERIZER_DISCARD,                          false},
 770                 { "cull_face",                                          "CULL_FACE",                                            GL_CULL_FACE,                                           false},
 771                 { "polygon_offset_fill",                        "POLYGON_OFFSET_FILL",                          GL_POLYGON_OFFSET_FILL,                         false},
 772                 { "sample_alpha_to_coverage",           "SAMPLE_ALPHA_TO_COVERAGE",                     GL_SAMPLE_ALPHA_TO_COVERAGE,            false},
 773                 { "sample_coverage",                            "SAMPLE_COVERAGE",                                      GL_SAMPLE_COVERAGE,                                     false},
 774                 { "scissor_test",                                       "SCISSOR_TEST",                                         GL_SCISSOR_TEST,                                        false},
 775                 { "stencil_test",                                       "STENCIL_TEST",                                         GL_STENCIL_TEST,                                        false},
 776                 { "depth_test",                                         "DEPTH_TEST",                                           GL_DEPTH_TEST,                                          false},
 777                 { "blend",                                                      "BLEND",                                                        GL_BLEND,                                                       false},
 778                 { "dither",                                                     "DITHER",                                                       GL_DITHER,                                                      true },
 779         };
 780         for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(isEnableds); testNdx++)
 781         {
 782                 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)));
 783         }
 784
 785         FOR_EACH_VERIFIER(normalVerifiers, addChild(new ColorMaskTestCase                                                       (m_context, verifier, (std::string("color_writemask")                                           + verifier->getTestNamePostfix()).c_str(), "COLOR_WRITEMASK")));
 786         FOR_EACH_VERIFIER(normalVerifiers, addChild(new DepthWriteMaskTestCase                                          (m_context, verifier, (std::string("depth_writemask")                                           + verifier->getTestNamePostfix()).c_str(), "DEPTH_WRITEMASK")));
 787         FOR_EACH_VERIFIER(normalVerifiers, addChild(new SampleCoverageInvertTestCase                            (m_context, verifier, (std::string("sample_coverage_invert")                            + verifier->getTestNamePostfix()).c_str(), "SAMPLE_COVERAGE_INVERT")));
 788         FOR_EACH_VERIFIER(normalVerifiers, addChild(new InitialBooleanTestCase                                          (m_context, verifier, (std::string("shader_compiler")                                           + verifier->getTestNamePostfix()).c_str(), "SHADER_COMPILER",                                           GL_SHADER_COMPILER, true)));
 789         FOR_EACH_VERIFIER(normalVerifiers, addChild(new InitialBooleanTestCase                                          (m_context, verifier, (std::string("transform_feedback_active_initial")         + verifier->getTestNamePostfix()).c_str(), "initial TRANSFORM_FEEDBACK_ACTIVE",         GL_TRANSFORM_FEEDBACK_ACTIVE, false)));
 790         FOR_EACH_VERIFIER(normalVerifiers, addChild(new InitialBooleanTestCase                                          (m_context, verifier, (std::string("transform_feedback_paused_initial")         + verifier->getTestNamePostfix()).c_str(), "initial TRANSFORM_FEEDBACK_PAUSED",         GL_TRANSFORM_FEEDBACK_PAUSED, false)));
 791         FOR_EACH_VERIFIER(normalVerifiers, addChild(new TransformFeedbackBasicTestCase                          (m_context, verifier, (std::string("transform_feedback")                                        + verifier->getTestNamePostfix()).c_str())));
 792         FOR_EACH_VERIFIER(normalVerifiers, addChild(new TransformFeedbackImplicitResumeTestCase         (m_context, verifier, (std::string("transform_feedback_implicit_resume")        + verifier->getTestNamePostfix()).c_str())));
 793 }
 794
 795 void BooleanStateQueryTests::deinit (void)
 796 {
 797         if (m_verifierIsEnabled)
 798         {
 799                 delete m_verifierIsEnabled;
 800                 m_verifierIsEnabled = DE_NULL;
 801         }
 802         if (m_verifierBoolean)
 803         {
 804                 delete m_verifierBoolean;
 805                 m_verifierBoolean = DE_NULL;
 806         }
 807         if (m_verifierInteger)
 808         {
 809                 delete m_verifierInteger;
 810                 m_verifierInteger = DE_NULL;
 811         }
 812         if (m_verifierInteger64)
 813         {
 814                 delete m_verifierInteger64;
 815                 m_verifierInteger64 = DE_NULL;
 816         }
 817         if (m_verifierFloat)
 818         {
 819                 delete m_verifierFloat;
 820                 m_verifierFloat = DE_NULL;
 821         }
 822
 823         this->TestCaseGroup::deinit();
 824 }
 825
 826 } // Functional
 827 } // gles3
 828 } // deqp