modules/gles3/functional/es3fIntegerStateQueryTests.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 State Query tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es3fIntegerStateQueryTests.hpp"
  25 #include "es3fApiCase.hpp"
  26
  27 #include "glsStateQueryUtil.hpp"
  28
  29 #include "gluRenderContext.hpp"
  30 #include "gluContextInfo.hpp"
  31 #include "gluStrUtil.hpp"
  32
  33 #include "tcuRenderTarget.hpp"
  34
  35 #include "deRandom.hpp"
  36
  37 #include "glwEnums.hpp"
  38
  39 using namespace glw; // GLint and other GL types
  40 using deqp::gls::StateQueryUtil::StateQueryMemoryWriteGuard;
  41
  42 #ifndef GL_SLUMINANCE_NV
  43 #define GL_SLUMINANCE_NV 0x8C46
  44 #endif
  45 #ifndef GL_SLUMINANCE_ALPHA_NV
  46 #define GL_SLUMINANCE_ALPHA_NV 0x8C44
  47 #endif
  48 #ifndef GL_BGR_NV
  49 #define GL_BGR_NV 0x80E0
  50 #endif
  51
  52 namespace deqp
  53 {
  54 namespace gles3
  55 {
  56 namespace Functional
  57 {
  58 namespace IntegerStateQueryVerifiers
  59 {
  60
  61 // StateVerifier
  62
  63 class StateVerifier : protected glu::CallLogWrapper
  64 {
  65 public:
  66                                                 StateVerifier                                           (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix);
  67         virtual                         ~StateVerifier                                          (); // make GCC happy
  68
  69         const char*                     getTestNamePostfix                                      (void) const;
  70
  71         virtual void            verifyInteger                                           (tcu::TestContext& testCtx, GLenum name, GLint reference)                                                                                                                                                                                                                                                                               = DE_NULL;
  72         virtual void            verifyInteger4                                          (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3)                                                                                                                                                                = DE_NULL;
  73         virtual void            verifyInteger4Mask                                      (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3)                    = DE_NULL;
  74         virtual void            verifyIntegerGreaterOrEqual                     (tcu::TestContext& testCtx, GLenum name, GLint reference)                                                                                                                                                                                                                                                                               = DE_NULL;
  75         virtual void            verifyUnsignedIntegerGreaterOrEqual     (tcu::TestContext& testCtx, GLenum name, GLuint reference)                                                                                                                                                                                                                                                                              = DE_NULL;
  76         virtual void            verifyIntegerLessOrEqual                        (tcu::TestContext& testCtx, GLenum name, GLint reference)                                                                                                                                                                                                                                                                               = DE_NULL;
  77         virtual void            verifyIntegerGreaterOrEqual2            (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1)                                                                                                                                                                                                                                    = DE_NULL;
  78         virtual void            verifyIntegerAnyOf                                      (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength)                                                                                                                                                                                                                     = DE_NULL;
  79         virtual void            verifyStencilMaskInitial                        (tcu::TestContext& testCtx, GLenum name, int stencilBits)                                                                                                                                                                                                                                                                               = DE_NULL;
  80
  81 private:
  82         const char*     const   m_testNamePostfix;
  83 };
  84
  85 StateVerifier::StateVerifier (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix)
  86         : glu::CallLogWrapper   (gl, log)
  87         , m_testNamePostfix             (testNamePostfix)
  88 {
  89         enableLogging(true);
  90 }
  91
  92 StateVerifier::~StateVerifier ()
  93 {
  94 }
  95
  96 const char* StateVerifier::getTestNamePostfix (void) const
  97 {
  98         return m_testNamePostfix;
  99 }
 100
 101 // GetBooleanVerifier
 102
 103 class GetBooleanVerifier : public StateVerifier
 104 {
 105 public:
 106                         GetBooleanVerifier                      (const glw::Functions& gl, tcu::TestLog& log);
 107         void    verifyInteger                                           (tcu::TestContext& testCtx, GLenum name, GLint reference);
 108         void    verifyInteger4                                          (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3);
 109         void    verifyInteger4Mask                                      (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3);
 110         void    verifyIntegerGreaterOrEqual                     (tcu::TestContext& testCtx, GLenum name, GLint reference);
 111         void    verifyUnsignedIntegerGreaterOrEqual     (tcu::TestContext& testCtx, GLenum name, GLuint reference);
 112         void    verifyIntegerLessOrEqual                        (tcu::TestContext& testCtx, GLenum name, GLint reference);
 113         void    verifyIntegerGreaterOrEqual2            (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1);
 114         void    verifyIntegerAnyOf                                      (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength);
 115         void    verifyStencilMaskInitial                        (tcu::TestContext& testCtx, GLenum name, int stencilBits);
 116 };
 117
 118 GetBooleanVerifier::GetBooleanVerifier (const glw::Functions& gl, tcu::TestLog& log)
 119         : StateVerifier(gl, log, "_getboolean")
 120 {
 121 }
 122
 123 void GetBooleanVerifier::verifyInteger (tcu::TestContext& testCtx, GLenum name, GLint reference)
 124 {
 125         using tcu::TestLog;
 126
 127         StateQueryMemoryWriteGuard<GLboolean> state;
 128         glGetBooleanv(name, &state);
 129
 130         if (!state.verifyValidity(testCtx))
 131                 return;
 132
 133         const GLboolean expectedGLState = reference ? GL_TRUE : GL_FALSE;
 134
 135         if (state != expectedGLState)
 136         {
 137                 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << (expectedGLState==GL_TRUE ? "GL_TRUE" : "GL_FALSE") << "; got " << (state == GL_TRUE ? "GL_TRUE" : (state == GL_FALSE ? "GL_FALSE" : "non-boolean")) << TestLog::EndMessage;
 138                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 139                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 140         }
 141 }
 142
 143 void GetBooleanVerifier::verifyInteger4 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3)
 144 {
 145         verifyInteger4Mask(testCtx, name, reference0, true, reference1, true, reference2, true, reference3, true);
 146 }
 147
 148 void GetBooleanVerifier::verifyInteger4Mask (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3)
 149 {
 150         using tcu::TestLog;
 151
 152         StateQueryMemoryWriteGuard<GLboolean[4]> boolVector4;
 153         glGetBooleanv(name, boolVector4);
 154
 155         if (!boolVector4.verifyValidity(testCtx))
 156                 return;
 157
 158         const GLboolean referenceAsGLBoolean[] =
 159         {
 160                 reference0 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
 161                 reference1 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
 162                 reference2 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
 163                 reference3 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
 164         };
 165
 166         if ((enableRef0 && (boolVector4[0] != referenceAsGLBoolean[0])) ||
 167                 (enableRef1 && (boolVector4[1] != referenceAsGLBoolean[1])) ||
 168                 (enableRef2 && (boolVector4[2] != referenceAsGLBoolean[2])) ||
 169                 (enableRef3 && (boolVector4[3] != referenceAsGLBoolean[3])))
 170         {
 171                 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
 172                         << (enableRef0 ? (referenceAsGLBoolean[0] ? "GL_TRUE" : "GL_FALSE") : " - ") << ", "
 173                         << (enableRef1 ? (referenceAsGLBoolean[1] ? "GL_TRUE" : "GL_FALSE") : " - ") << ", "
 174                         << (enableRef2 ? (referenceAsGLBoolean[2] ? "GL_TRUE" : "GL_FALSE") : " - ") << ", "
 175                         << (enableRef3 ? (referenceAsGLBoolean[3] ? "GL_TRUE" : "GL_FALSE") : " - ") << TestLog::EndMessage;
 176
 177                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 178                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 179         }
 180 }
 181
 182 void GetBooleanVerifier::verifyIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference)
 183 {
 184         using tcu::TestLog;
 185
 186         StateQueryMemoryWriteGuard<GLboolean> state;
 187         glGetBooleanv(name, &state);
 188
 189         if (!state.verifyValidity(testCtx))
 190                 return;
 191
 192         if (state == GL_TRUE) // state is non-zero, could be greater than reference (correct)
 193                 return;
 194
 195         if (state == GL_FALSE) // state is zero
 196         {
 197                 if (reference > 0) // and reference is greater than zero?
 198                 {
 199                         testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
 200                         if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 201                                 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 202                 }
 203         }
 204         else
 205         {
 206                 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE or GL_FALSE" << TestLog::EndMessage;
 207                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 208                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 209         }
 210 }
 211
 212 void GetBooleanVerifier::verifyUnsignedIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLuint reference)
 213 {
 214         using tcu::TestLog;
 215
 216         StateQueryMemoryWriteGuard<GLboolean> state;
 217         glGetBooleanv(name, &state);
 218
 219         if (!state.verifyValidity(testCtx))
 220                 return;
 221
 222         if (state == GL_TRUE) // state is non-zero, could be greater than reference (correct)
 223                 return;
 224
 225         if (state == GL_FALSE) // state is zero
 226         {
 227                 if (reference > 0) // and reference is greater than zero?
 228                 {
 229                         testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
 230                         if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 231                                 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 232                 }
 233         }
 234         else
 235         {
 236                 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE or GL_FALSE" << TestLog::EndMessage;
 237                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 238                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 239         }
 240 }
 241
 242 void GetBooleanVerifier::verifyIntegerLessOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference)
 243 {
 244         using tcu::TestLog;
 245
 246         StateQueryMemoryWriteGuard<GLboolean> state;
 247         glGetBooleanv(name, &state);
 248
 249         if (!state.verifyValidity(testCtx))
 250                 return;
 251
 252         if (state == GL_TRUE) // state is non-zero, could be less than reference (correct)
 253                 return;
 254
 255         if (state == GL_FALSE) // state is zero
 256         {
 257                 if (reference < 0) // and reference is less than zero?
 258                 {
 259                         testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
 260                         if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 261                                 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 262                 }
 263         }
 264         else
 265         {
 266                 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE or GL_FALSE" << TestLog::EndMessage;
 267                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 268                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 269         }
 270 }
 271
 272 void GetBooleanVerifier::verifyIntegerGreaterOrEqual2 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1)
 273 {
 274         using tcu::TestLog;
 275
 276         StateQueryMemoryWriteGuard<GLboolean[2]> boolVector;
 277         glGetBooleanv(name, boolVector);
 278
 279         if (!boolVector.verifyValidity(testCtx))
 280                 return;
 281
 282         const GLboolean referenceAsGLBoolean[2] =
 283         {
 284                 reference0 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
 285                 reference1 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE
 286         };
 287
 288         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(referenceAsGLBoolean); ++ndx)
 289         {
 290                 if (boolVector[ndx] == GL_TRUE) // state is non-zero, could be greater than any integer
 291                 {
 292                         continue;
 293                 }
 294                 else if (boolVector[ndx] == GL_FALSE) // state is zero
 295                 {
 296                         if (referenceAsGLBoolean[ndx] > 0) // and reference is greater than zero?
 297                         {
 298                                 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
 299                                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 300                                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 301                         }
 302                 }
 303                 else
 304                 {
 305                         testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE or GL_FALSE" << TestLog::EndMessage;
 306                         if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 307                                 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 308                 }
 309         }
 310 }
 311
 312 void GetBooleanVerifier::verifyIntegerAnyOf (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength)
 313 {
 314         using tcu::TestLog;
 315
 316         StateQueryMemoryWriteGuard<GLboolean> state;
 317         glGetBooleanv(name, &state);
 318
 319         if (!state.verifyValidity(testCtx))
 320                 return;
 321
 322         for (size_t ndx = 0; ndx < referencesLength; ++ndx)
 323         {
 324                 const GLboolean expectedGLState = references[ndx] ? GL_TRUE : GL_FALSE;
 325
 326                 if (state == expectedGLState)
 327                         return;
 328         }
 329
 330         testCtx.getLog() << TestLog::Message << "// ERROR: got " << (state==GL_TRUE ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
 331         if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 332                 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 333 }
 334
 335 void GetBooleanVerifier::verifyStencilMaskInitial (tcu::TestContext& testCtx, GLenum name, int stencilBits)
 336 {
 337         // if stencilBits == 0, the mask is allowed to be either GL_TRUE or GL_FALSE
 338         // otherwise it must be GL_TRUE
 339         using tcu::TestLog;
 340
 341         StateQueryMemoryWriteGuard<GLboolean> state;
 342         glGetBooleanv(name, &state);
 343
 344         if (!state.verifyValidity(testCtx))
 345                 return;
 346
 347         if (stencilBits > 0 && state != GL_TRUE)
 348         {
 349                 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
 350                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 351                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
 352         }
 353 }
 354
 355 //GetIntegerVerifier
 356
 357 class GetIntegerVerifier : public StateVerifier
 358 {
 359 public:
 360                         GetIntegerVerifier                      (const glw::Functions& gl, tcu::TestLog& log);
 361         void    verifyInteger                                           (tcu::TestContext& testCtx, GLenum name, GLint reference);
 362         void    verifyInteger4                                          (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3);
 363         void    verifyInteger4Mask                                      (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3);
 364         void    verifyIntegerGreaterOrEqual                     (tcu::TestContext& testCtx, GLenum name, GLint reference);
 365         void    verifyUnsignedIntegerGreaterOrEqual     (tcu::TestContext& testCtx, GLenum name, GLuint reference);
 366         void    verifyIntegerLessOrEqual                        (tcu::TestContext& testCtx, GLenum name, GLint reference);
 367         void    verifyIntegerGreaterOrEqual2            (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1);
 368         void    verifyIntegerAnyOf                                      (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength);
 369         void    verifyStencilMaskInitial                        (tcu::TestContext& testCtx, GLenum name, int stencilBits);
 370 };
 371
 372 GetIntegerVerifier::GetIntegerVerifier (const glw::Functions& gl, tcu::TestLog& log)
 373         : StateVerifier(gl, log, "_getinteger")
 374 {
 375 }
 376
 377 void GetIntegerVerifier::verifyInteger (tcu::TestContext& testCtx, GLenum name, GLint reference)
 378 {
 379         using tcu::TestLog;
 380
 381         StateQueryMemoryWriteGuard<GLint> state;
 382         glGetIntegerv(name, &state);
 383
 384         if (!state.verifyValidity(testCtx))
 385                 return;
 386
 387         if (state != reference)
 388         {
 389                 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state << TestLog::EndMessage;
 390                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 391                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 392         }
 393 }
 394
 395 void GetIntegerVerifier::verifyInteger4 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3)
 396 {
 397         verifyInteger4Mask(testCtx, name, reference0, true, reference1, true, reference2, true, reference3, true);
 398 }
 399
 400 void GetIntegerVerifier::verifyInteger4Mask (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3)
 401 {
 402         using tcu::TestLog;
 403
 404         StateQueryMemoryWriteGuard<GLint[4]> intVector4;
 405         glGetIntegerv(name, intVector4);
 406
 407         if (!intVector4.verifyValidity(testCtx))
 408                 return;
 409
 410         if ((enableRef0 && (intVector4[0] != reference0)) ||
 411                 (enableRef1 && (intVector4[1] != reference1)) ||
 412                 (enableRef2 && (intVector4[2] != reference2)) ||
 413                 (enableRef3 && (intVector4[3] != reference3)))
 414         {
 415                 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
 416                         << (enableRef0?"":"(") << reference0 << (enableRef0?"":")") << ", "
 417                         << (enableRef1?"":"(") << reference1 << (enableRef1?"":")") << ", "
 418                         << (enableRef2?"":"(") << reference2 << (enableRef2?"":")") << ", "
 419                         << (enableRef3?"":"(") << reference3 << (enableRef3?"":")")     << TestLog::EndMessage;
 420
 421
 422                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 423                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 424         }
 425 }
 426
 427 void GetIntegerVerifier::verifyIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference)
 428 {
 429         using tcu::TestLog;
 430
 431         StateQueryMemoryWriteGuard<GLint> state;
 432         glGetIntegerv(name, &state);
 433
 434         if (!state.verifyValidity(testCtx))
 435                 return;
 436
 437         if (state < reference)
 438         {
 439                 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << reference << "; got " << state << TestLog::EndMessage;
 440                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 441                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 442         }
 443 }
 444
 445 void GetIntegerVerifier::verifyUnsignedIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLuint reference)
 446 {
 447         using tcu::TestLog;
 448
 449         StateQueryMemoryWriteGuard<GLint> state;
 450         glGetIntegerv(name, &state);
 451
 452         if (!state.verifyValidity(testCtx))
 453                 return;
 454
 455         if (GLuint(state) < reference)
 456         {
 457                 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << reference << "; got " << GLuint(state) << TestLog::EndMessage;
 458                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 459                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 460         }
 461 }
 462
 463 void GetIntegerVerifier::verifyIntegerLessOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference)
 464 {
 465         using tcu::TestLog;
 466
 467         StateQueryMemoryWriteGuard<GLint> state;
 468         glGetIntegerv(name, &state);
 469
 470         if (!state.verifyValidity(testCtx))
 471                 return;
 472
 473         if (state > reference)
 474         {
 475                 testCtx.getLog() << TestLog::Message << "// ERROR: expected less or equal to " << reference << "; got " << state << TestLog::EndMessage;
 476                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 477                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 478         }
 479 }
 480
 481 void GetIntegerVerifier::verifyIntegerGreaterOrEqual2 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1)
 482 {
 483         using tcu::TestLog;
 484
 485         StateQueryMemoryWriteGuard<GLint[2]> intVector2;
 486         glGetIntegerv(name, intVector2);
 487
 488         if (!intVector2.verifyValidity(testCtx))
 489                 return;
 490
 491         if (intVector2[0] < reference0 || intVector2[1] < reference1)
 492         {
 493                 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << reference0 << ", " << reference1 << "; got " << intVector2[0] << ", " << intVector2[0] << TestLog::EndMessage;
 494                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 495                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 496         }
 497 }
 498
 499 void GetIntegerVerifier::verifyIntegerAnyOf (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength)
 500 {
 501         using tcu::TestLog;
 502
 503         StateQueryMemoryWriteGuard<GLint> state;
 504         glGetIntegerv(name, &state);
 505
 506         if (!state.verifyValidity(testCtx))
 507                 return;
 508
 509         for (size_t ndx = 0; ndx < referencesLength; ++ndx)
 510         {
 511                 const GLint expectedGLState = references[ndx];
 512
 513                 if (state == expectedGLState)
 514                         return;
 515         }
 516
 517         testCtx.getLog() << TestLog::Message << "// ERROR: got " << state << TestLog::EndMessage;
 518         if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 519                 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 520 }
 521
 522 void GetIntegerVerifier::verifyStencilMaskInitial (tcu::TestContext& testCtx, GLenum name, int stencilBits)
 523 {
 524         using tcu::TestLog;
 525
 526         StateQueryMemoryWriteGuard<GLint> state;
 527         glGetIntegerv(name, &state);
 528
 529         if (!state.verifyValidity(testCtx))
 530                 return;
 531
 532         const GLint reference = (1 << stencilBits) - 1;
 533
 534         if ((state & reference) != reference) // the least significant stencilBits bits should be on
 535         {
 536                 testCtx.getLog() << TestLog::Message << "// ERROR: expected minimum mask of " << reference << "; got " << state << TestLog::EndMessage;
 537                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 538                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid mask value");
 539         }
 540 }
 541
 542 //GetInteger64Verifier
 543
 544 class GetInteger64Verifier : public StateVerifier
 545 {
 546 public:
 547                         GetInteger64Verifier                    (const glw::Functions& gl, tcu::TestLog& log);
 548         void    verifyInteger                                           (tcu::TestContext& testCtx, GLenum name, GLint reference);
 549         void    verifyInteger4                                          (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3);
 550         void    verifyInteger4Mask                                      (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3);
 551         void    verifyIntegerGreaterOrEqual                     (tcu::TestContext& testCtx, GLenum name, GLint reference);
 552         void    verifyUnsignedIntegerGreaterOrEqual     (tcu::TestContext& testCtx, GLenum name, GLuint reference);
 553         void    verifyIntegerLessOrEqual                        (tcu::TestContext& testCtx, GLenum name, GLint reference);
 554         void    verifyIntegerGreaterOrEqual2            (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1);
 555         void    verifyIntegerAnyOf                                      (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength);
 556         void    verifyStencilMaskInitial                        (tcu::TestContext& testCtx, GLenum name, int stencilBits);
 557 };
 558
 559 GetInteger64Verifier::GetInteger64Verifier (const glw::Functions& gl, tcu::TestLog& log)
 560         : StateVerifier(gl, log, "_getinteger64")
 561 {
 562 }
 563
 564 void GetInteger64Verifier::verifyInteger (tcu::TestContext& testCtx, GLenum name, GLint reference)
 565 {
 566         using tcu::TestLog;
 567
 568         StateQueryMemoryWriteGuard<GLint64> state;
 569         glGetInteger64v(name, &state);
 570
 571         if (!state.verifyValidity(testCtx))
 572                 return;
 573
 574         if (state != GLint64(reference))
 575         {
 576                 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state << TestLog::EndMessage;
 577                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 578                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 579         }
 580 }
 581
 582 void GetInteger64Verifier::verifyInteger4 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3)
 583 {
 584         verifyInteger4Mask(testCtx, name, reference0, true, reference1, true, reference2, true, reference3, true);
 585 }
 586
 587 void GetInteger64Verifier::verifyInteger4Mask (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3)
 588 {
 589         using tcu::TestLog;
 590
 591         StateQueryMemoryWriteGuard<GLint64[4]> intVector4;
 592         glGetInteger64v(name, intVector4);
 593
 594         if (!intVector4.verifyValidity(testCtx))
 595                 return;
 596
 597         if ((enableRef0 && (intVector4[0] != GLint64(reference0))) ||
 598                 (enableRef1 && (intVector4[1] != GLint64(reference1))) ||
 599                 (enableRef2 && (intVector4[2] != GLint64(reference2))) ||
 600                 (enableRef3 && (intVector4[3] != GLint64(reference3))))
 601         {
 602                 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
 603                         << (enableRef0?"":"(") << reference0 << (enableRef0?"":")") << ", "
 604                         << (enableRef1?"":"(") << reference1 << (enableRef1?"":")") << ", "
 605                         << (enableRef2?"":"(") << reference2 << (enableRef2?"":")") << ", "
 606                         << (enableRef3?"":"(") << reference3 << (enableRef3?"":")")     << TestLog::EndMessage;
 607
 608                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 609                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 610         }
 611 }
 612
 613 void GetInteger64Verifier::verifyIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference)
 614 {
 615         using tcu::TestLog;
 616
 617         StateQueryMemoryWriteGuard<GLint64> state;
 618         glGetInteger64v(name, &state);
 619
 620         if (!state.verifyValidity(testCtx))
 621                 return;
 622
 623         if (state < GLint64(reference))
 624         {
 625                 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLint64(reference) << "; got " << state << TestLog::EndMessage;
 626                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 627                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 628         }
 629 }
 630
 631 void GetInteger64Verifier::verifyUnsignedIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLuint reference)
 632 {
 633         using tcu::TestLog;
 634
 635         StateQueryMemoryWriteGuard<GLint64> state;
 636         glGetInteger64v(name, &state);
 637
 638         if (!state.verifyValidity(testCtx))
 639                 return;
 640
 641         if (GLuint(state) < GLint64(reference))
 642         {
 643                 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLint64(reference) << "; got " << GLuint(state) << TestLog::EndMessage;
 644                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 645                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 646         }
 647 }
 648
 649 void GetInteger64Verifier::verifyIntegerLessOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference)
 650 {
 651         using tcu::TestLog;
 652
 653         StateQueryMemoryWriteGuard<GLint64> state;
 654         glGetInteger64v(name, &state);
 655
 656         if (!state.verifyValidity(testCtx))
 657                 return;
 658
 659         if (state > GLint64(reference))
 660         {
 661                 testCtx.getLog() << TestLog::Message << "// ERROR: expected less or equal to " << GLint64(reference) << "; got " << state << TestLog::EndMessage;
 662                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 663                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 664         }
 665 }
 666
 667 void GetInteger64Verifier::verifyIntegerGreaterOrEqual2 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1)
 668 {
 669         using tcu::TestLog;
 670
 671         StateQueryMemoryWriteGuard<GLint64[2]> intVector2;
 672         glGetInteger64v(name, intVector2);
 673
 674         if (!intVector2.verifyValidity(testCtx))
 675                 return;
 676
 677         if (intVector2[0] < GLint64(reference0) || intVector2[1] < GLint64(reference1))
 678         {
 679                 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLint64(reference0) << ", " << GLint64(reference1) << "; got " << intVector2[0] << ", " << intVector2[1] << TestLog::EndMessage;
 680                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 681                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 682         }
 683 }
 684
 685 void GetInteger64Verifier::verifyIntegerAnyOf (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength)
 686 {
 687         using tcu::TestLog;
 688
 689         StateQueryMemoryWriteGuard<GLint64> state;
 690         glGetInteger64v(name, &state);
 691
 692         if (!state.verifyValidity(testCtx))
 693                 return;
 694
 695         for (size_t ndx = 0; ndx < referencesLength; ++ndx)
 696         {
 697                 const GLint64 expectedGLState = GLint64(references[ndx]);
 698
 699                 if (state == expectedGLState)
 700                         return;
 701         }
 702
 703         testCtx.getLog() << TestLog::Message << "// ERROR: got " << state << TestLog::EndMessage;
 704         if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 705                 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
 706 }
 707
 708 void GetInteger64Verifier::verifyStencilMaskInitial (tcu::TestContext& testCtx, GLenum name, int stencilBits)
 709 {
 710         using tcu::TestLog;
 711
 712         StateQueryMemoryWriteGuard<GLint64> state;
 713         glGetInteger64v(name, &state);
 714
 715         if (!state.verifyValidity(testCtx))
 716                 return;
 717
 718         const GLint64 reference = (1ULL << stencilBits) - 1;
 719
 720         if ((state & reference) != reference) // the least significant stencilBits bits should be on
 721         {
 722                 testCtx.getLog() << TestLog::Message << "// ERROR: expected mimimum mask of " << reference << "; got " << state << TestLog::EndMessage;
 723                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 724                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid mask value");
 725         }
 726 }
 727
 728 //GetFloatVerifier
 729
 730 class GetFloatVerifier : public StateVerifier
 731 {
 732 public:
 733                         GetFloatVerifier                                (const glw::Functions& gl, tcu::TestLog& log);
 734         void    verifyInteger                                           (tcu::TestContext& testCtx, GLenum name, GLint reference);
 735         void    verifyInteger4                                          (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3);
 736         void    verifyInteger4Mask                                      (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3);
 737         void    verifyIntegerGreaterOrEqual                     (tcu::TestContext& testCtx, GLenum name, GLint reference);
 738         void    verifyUnsignedIntegerGreaterOrEqual     (tcu::TestContext& testCtx, GLenum name, GLuint reference);
 739         void    verifyIntegerLessOrEqual                        (tcu::TestContext& testCtx, GLenum name, GLint reference);
 740         void    verifyIntegerGreaterOrEqual2            (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1);
 741         void    verifyIntegerAnyOf                                      (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength);
 742         void    verifyStencilMaskInitial                        (tcu::TestContext& testCtx, GLenum name, int stencilBits);
 743 };
 744
 745 GetFloatVerifier::GetFloatVerifier (const glw::Functions& gl, tcu::TestLog& log)
 746         : StateVerifier(gl, log, "_getfloat")
 747 {
 748 }
 749
 750 void GetFloatVerifier::verifyInteger (tcu::TestContext& testCtx, GLenum name, GLint reference)
 751 {
 752         using tcu::TestLog;
 753
 754         const GLfloat referenceAsFloat = GLfloat(reference);
 755         DE_ASSERT(reference == GLint(referenceAsFloat)); // reference integer must have 1:1 mapping to float for this to work. Reference value is always such value in these tests
 756
 757         StateQueryMemoryWriteGuard<GLfloat> state;
 758         glGetFloatv(name, &state);
 759
 760         if (!state.verifyValidity(testCtx))
 761                 return;
 762
 763         if (state != referenceAsFloat)
 764         {
 765                 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << referenceAsFloat << "; got " << state << TestLog::EndMessage;
 766                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 767                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
 768         }
 769 }
 770
 771 void GetFloatVerifier::verifyInteger4 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3)
 772 {
 773         verifyInteger4Mask(testCtx, name, reference0, true, reference1, true, reference2, true, reference3, true);
 774 }
 775
 776 void GetFloatVerifier::verifyInteger4Mask (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3)
 777 {
 778         using tcu::TestLog;
 779
 780         StateQueryMemoryWriteGuard<GLfloat[4]> floatVector4;
 781         glGetFloatv(name, floatVector4);
 782
 783         if (!floatVector4.verifyValidity(testCtx))
 784                 return;
 785
 786         if ((enableRef0 && (floatVector4[0] != GLfloat(reference0))) ||
 787                 (enableRef1 && (floatVector4[1] != GLfloat(reference1))) ||
 788                 (enableRef2 && (floatVector4[2] != GLfloat(reference2))) ||
 789                 (enableRef3 && (floatVector4[3] != GLfloat(reference3))))
 790         {
 791                 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
 792                         << (enableRef0?"":"(") << GLfloat(reference0) << (enableRef0?"":")") << ", "
 793                         << (enableRef1?"":"(") << GLfloat(reference1) << (enableRef1?"":")") << ", "
 794                         << (enableRef2?"":"(") << GLfloat(reference2) << (enableRef2?"":")") << ", "
 795                         << (enableRef3?"":"(") << GLfloat(reference3) << (enableRef3?"":")") << TestLog::EndMessage;
 796
 797                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 798                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
 799         }
 800 }
 801
 802 void GetFloatVerifier::verifyIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference)
 803 {
 804         using tcu::TestLog;
 805
 806         StateQueryMemoryWriteGuard<GLfloat> state;
 807         glGetFloatv(name, &state);
 808
 809         if (!state.verifyValidity(testCtx))
 810                 return;
 811
 812         if (state < GLfloat(reference))
 813         {
 814                 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLfloat(reference) << "; got " << state << TestLog::EndMessage;
 815                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 816                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
 817         }
 818 }
 819
 820 void GetFloatVerifier::verifyUnsignedIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLuint reference)
 821 {
 822         using tcu::TestLog;
 823
 824         StateQueryMemoryWriteGuard<GLfloat> state;
 825         glGetFloatv(name, &state);
 826
 827         if (!state.verifyValidity(testCtx))
 828                 return;
 829
 830         if (GLuint(state) < GLfloat(reference))
 831         {
 832                 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLfloat(reference) << "; got " << GLuint(state) << TestLog::EndMessage;
 833                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 834                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
 835         }
 836 }
 837
 838 void GetFloatVerifier::verifyIntegerLessOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference)
 839 {
 840         using tcu::TestLog;
 841
 842         StateQueryMemoryWriteGuard<GLfloat> state;
 843         glGetFloatv(name, &state);
 844
 845         if (!state.verifyValidity(testCtx))
 846                 return;
 847
 848         if (state > GLfloat(reference))
 849         {
 850                 testCtx.getLog() << TestLog::Message << "// ERROR: expected less or equal to " << GLfloat(reference) << "; got " << state << TestLog::EndMessage;
 851                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 852                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
 853         }
 854 }
 855
 856 void GetFloatVerifier::verifyIntegerGreaterOrEqual2 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1)
 857 {
 858         using tcu::TestLog;
 859
 860         StateQueryMemoryWriteGuard<GLfloat[2]> floatVector2;
 861         glGetFloatv(name, floatVector2);
 862
 863         if (!floatVector2.verifyValidity(testCtx))
 864                 return;
 865
 866         if (floatVector2[0] < GLfloat(reference0) || floatVector2[1] < GLfloat(reference1))
 867         {
 868                 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLfloat(reference0) << ", " << GLfloat(reference1) << "; got " << floatVector2[0] << ", " << floatVector2[1] << TestLog::EndMessage;
 869                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 870                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
 871         }
 872 }
 873
 874 void GetFloatVerifier::verifyIntegerAnyOf (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength)
 875 {
 876         using tcu::TestLog;
 877
 878         StateQueryMemoryWriteGuard<GLfloat> state;
 879         glGetFloatv(name, &state);
 880
 881         if (!state.verifyValidity(testCtx))
 882                 return;
 883
 884         for (size_t ndx = 0; ndx < referencesLength; ++ndx)
 885         {
 886                 const GLfloat expectedGLState = GLfloat(references[ndx]);
 887                 DE_ASSERT(references[ndx] == GLint(expectedGLState)); // reference integer must have 1:1 mapping to float for this to work. Reference value is always such value in these tests
 888
 889                 if (state == expectedGLState)
 890                         return;
 891         }
 892
 893         testCtx.getLog() << TestLog::Message << "// ERROR: got " << state << TestLog::EndMessage;
 894         if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 895                 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
 896 }
 897
 898 void GetFloatVerifier::verifyStencilMaskInitial (tcu::TestContext& testCtx, GLenum name, int stencilBits)
 899 {
 900         // checking the mask bits with float doesn't make much sense because of conversion errors
 901         // just verify that the value is greater or equal to the minimum value
 902         const GLint reference = (1 << stencilBits) - 1;
 903         verifyIntegerGreaterOrEqual(testCtx, name, reference);
 904 }
 905
 906 } // IntegerStateQueryVerifiers
 907
 908 namespace
 909 {
 910
 911 using namespace IntegerStateQueryVerifiers;
 912 using namespace deqp::gls::StateQueryUtil;
 913
 914 class ConstantMinimumValueTestCase : public ApiCase
 915 {
 916 public:
 917         ConstantMinimumValueTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum targetName, GLint minValue)
 918                 : ApiCase               (context, name, description)
 919                 , m_targetName  (targetName)
 920                 , m_minValue    (minValue)
 921                 , m_verifier    (verifier)
 922         {
 923         }
 924
 925         void test (void)
 926         {
 927                 m_verifier->verifyUnsignedIntegerGreaterOrEqual(m_testCtx, m_targetName, m_minValue);
 928                 expectError(GL_NO_ERROR);
 929         }
 930
 931 private:
 932         GLenum                  m_targetName;
 933         GLint                   m_minValue;
 934         StateVerifier*  m_verifier;
 935 };
 936
 937 class ConstantMaximumValueTestCase : public ApiCase
 938 {
 939 public:
 940         ConstantMaximumValueTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum targetName, GLint minValue)
 941                 : ApiCase               (context, name, description)
 942                 , m_targetName  (targetName)
 943                 , m_minValue    (minValue)
 944                 , m_verifier    (verifier)
 945         {
 946         }
 947
 948         void test (void)
 949         {
 950                 m_verifier->verifyIntegerLessOrEqual(m_testCtx, m_targetName, m_minValue);
 951                 expectError(GL_NO_ERROR);
 952         }
 953
 954 private:
 955         GLenum                  m_targetName;
 956         GLint                   m_minValue;
 957         StateVerifier*  m_verifier;
 958 };
 959
 960 class SampleBuffersTestCase : public ApiCase
 961 {
 962 public:
 963         SampleBuffersTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
 964                 : ApiCase               (context, name, description)
 965                 , m_verifier    (verifier)
 966         {
 967         }
 968
 969         void test (void)
 970         {
 971                 const int expectedSampleBuffers = (m_context.getRenderTarget().getNumSamples() > 1) ? 1 : 0;
 972
 973                 m_log << tcu::TestLog::Message << "Sample count is " << (m_context.getRenderTarget().getNumSamples()) << ", expecting GL_SAMPLE_BUFFERS to be " << expectedSampleBuffers << tcu::TestLog::EndMessage;
 974
 975                 m_verifier->verifyInteger(m_testCtx, GL_SAMPLE_BUFFERS, expectedSampleBuffers);
 976                 expectError(GL_NO_ERROR);
 977         }
 978
 979 private:
 980         StateVerifier*  m_verifier;
 981 };
 982
 983 class SamplesTestCase : public ApiCase
 984 {
 985 public:
 986         SamplesTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
 987                 : ApiCase               (context, name, description)
 988                 , m_verifier    (verifier)
 989         {
 990         }
 991
 992         void test (void)
 993         {
 994                 // MSAA?
 995                 if (m_context.getRenderTarget().getNumSamples() > 1)
 996                 {
 997                         m_log << tcu::TestLog::Message << "Sample count is " << (m_context.getRenderTarget().getNumSamples()) << tcu::TestLog::EndMessage;
 998
 999                         m_verifier->verifyInteger(m_testCtx, GL_SAMPLES, m_context.getRenderTarget().getNumSamples());
1000                         expectError(GL_NO_ERROR);
1001                 }
1002                 else
1003                 {
1004                         const glw::GLint validSamples[] = {0, 1};
1005
1006                         m_log << tcu::TestLog::Message << "Expecting GL_SAMPLES to be 0 or 1" << tcu::TestLog::EndMessage;
1007
1008                         m_verifier->verifyIntegerAnyOf(m_testCtx, GL_SAMPLES, validSamples, DE_LENGTH_OF_ARRAY(validSamples));
1009                         expectError(GL_NO_ERROR);
1010                 }
1011         }
1012
1013 private:
1014         StateVerifier*  m_verifier;
1015 };
1016
1017 class HintTestCase : public ApiCase
1018 {
1019 public:
1020         HintTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum targetName)
1021                 : ApiCase               (context, name, description)
1022                 , m_targetName  (targetName)
1023                 , m_verifier    (verifier)
1024         {
1025         }
1026
1027         void test (void)
1028         {
1029                 m_verifier->verifyInteger(m_testCtx, m_targetName, GL_DONT_CARE);
1030                 expectError(GL_NO_ERROR);
1031
1032                 glHint(m_targetName, GL_NICEST);
1033                 m_verifier->verifyInteger(m_testCtx, m_targetName, GL_NICEST);
1034                 expectError(GL_NO_ERROR);
1035
1036                 glHint(m_targetName, GL_FASTEST);
1037                 m_verifier->verifyInteger(m_testCtx, m_targetName, GL_FASTEST);
1038                 expectError(GL_NO_ERROR);
1039
1040                 glHint(m_targetName, GL_DONT_CARE);
1041                 m_verifier->verifyInteger(m_testCtx, m_targetName, GL_DONT_CARE);
1042                 expectError(GL_NO_ERROR);
1043         }
1044
1045 private:
1046         GLenum          m_targetName;
1047         StateVerifier*  m_verifier;
1048 };
1049
1050 class DepthFuncTestCase : public ApiCase
1051 {
1052 public:
1053         DepthFuncTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
1054                 : ApiCase               (context, name, description)
1055                 , m_verifier    (verifier)
1056         {
1057         }
1058
1059         void test (void)
1060         {
1061                 m_verifier->verifyInteger(m_testCtx, GL_DEPTH_FUNC, GL_LESS);
1062                 expectError(GL_NO_ERROR);
1063
1064                 const GLenum depthFunctions[] = {GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL, GL_EQUAL, GL_GREATER, GL_GEQUAL, GL_NOTEQUAL};
1065                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthFunctions); ndx++)
1066                 {
1067                         glDepthFunc(depthFunctions[ndx]);
1068                         expectError(GL_NO_ERROR);
1069
1070                         m_verifier->verifyInteger(m_testCtx, GL_DEPTH_FUNC, depthFunctions[ndx]);
1071                         expectError(GL_NO_ERROR);
1072                 }
1073         }
1074
1075 private:
1076         StateVerifier*  m_verifier;
1077 };
1078
1079 class CullFaceTestCase : public ApiCase
1080 {
1081 public:
1082         CullFaceTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
1083                 : ApiCase               (context, name, description)
1084                 , m_verifier    (verifier)
1085         {
1086         }
1087
1088         void test (void)
1089         {
1090                 m_verifier->verifyInteger(m_testCtx, GL_CULL_FACE_MODE, GL_BACK);
1091                 expectError(GL_NO_ERROR);
1092
1093                 const GLenum cullFaces[] = {GL_FRONT, GL_BACK, GL_FRONT_AND_BACK};
1094                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cullFaces); ndx++)
1095                 {
1096                         glCullFace(cullFaces[ndx]);
1097                         expectError(GL_NO_ERROR);
1098
1099                         m_verifier->verifyInteger(m_testCtx, GL_CULL_FACE_MODE, cullFaces[ndx]);
1100                         expectError(GL_NO_ERROR);
1101                 }
1102         }
1103
1104 private:
1105         StateVerifier*  m_verifier;
1106 };
1107
1108 class FrontFaceTestCase : public ApiCase
1109 {
1110 public:
1111         FrontFaceTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
1112                 : ApiCase               (context, name, description)
1113                 , m_verifier    (verifier)
1114         {
1115         }
1116
1117         void test (void)
1118         {
1119                 m_verifier->verifyInteger(m_testCtx, GL_FRONT_FACE, GL_CCW);
1120                 expectError(GL_NO_ERROR);
1121
1122                 const GLenum frontFaces[] = {GL_CW, GL_CCW};
1123                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(frontFaces); ndx++)
1124                 {
1125                         glFrontFace(frontFaces[ndx]);
1126                         expectError(GL_NO_ERROR);
1127
1128                         m_verifier->verifyInteger(m_testCtx, GL_FRONT_FACE, frontFaces[ndx]);
1129                         expectError(GL_NO_ERROR);
1130                 }
1131         }
1132
1133 private:
1134         StateVerifier*  m_verifier;
1135 };
1136
1137 class ViewPortTestCase : public ApiCase
1138 {
1139 public:
1140         ViewPortTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
1141                 : ApiCase               (context, name, description)
1142                 , m_verifier    (verifier)
1143         {
1144         }
1145
1146         void test (void)
1147         {
1148                 de::Random rnd(0xabcdef);
1149
1150                 GLint maxViewportDimensions[2] = {0};
1151                 GLfloat viewportBoundsRange[2] = {0.0f};
1152                 GLboolean hasViewportArray = false;
1153                 glGetIntegerv(GL_MAX_VIEWPORT_DIMS, maxViewportDimensions);
1154                 hasViewportArray = m_context.getContextInfo().isExtensionSupported("GL_OES_viewport_array") ||
1155                                                    m_context.getContextInfo().isExtensionSupported("GL_NV_viewport_array");
1156                 if (hasViewportArray)
1157                 {
1158                         glGetFloatv(GL_VIEWPORT_BOUNDS_RANGE, viewportBoundsRange);
1159                 }
1160
1161                 // verify initial value of first two values
1162                 m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT, 0, 0, m_context.getRenderTarget().getWidth(), m_context.getRenderTarget().getHeight());
1163                 expectError(GL_NO_ERROR);
1164
1165                 const int numIterations = 120;
1166                 for (int i = 0; i < numIterations; ++i)
1167                 {
1168                         GLint x                 = rnd.getInt(-64000, 64000);
1169                         GLint y                 = rnd.getInt(-64000, 64000);
1170                         GLsizei width   = rnd.getInt(0, maxViewportDimensions[0]);
1171                         GLsizei height  = rnd.getInt(0, maxViewportDimensions[1]);
1172
1173                         glViewport(x, y, width, height);
1174
1175                         if (hasViewportArray)
1176                         {
1177                                 m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT,
1178                                                                                    de::clamp(x, deFloorFloatToInt32(viewportBoundsRange[0]), deFloorFloatToInt32(viewportBoundsRange[1])),
1179                                                                                    de::clamp(y, deFloorFloatToInt32(viewportBoundsRange[0]), deFloorFloatToInt32(viewportBoundsRange[1])),
1180                                                                                    width, height);
1181                         }
1182                         else
1183                         {
1184                                 m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT, x, y, width, height);
1185                         }
1186
1187                         expectError(GL_NO_ERROR);
1188                 }
1189         }
1190
1191 private:
1192         StateVerifier*  m_verifier;
1193 };
1194
1195 class ScissorBoxTestCase : public ApiCase
1196 {
1197 public:
1198         ScissorBoxTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
1199                 : ApiCase               (context, name, description)
1200                 , m_verifier    (verifier)
1201         {
1202         }
1203
1204         void test (void)
1205         {
1206                 de::Random rnd(0xabcdef);
1207
1208                 // verify initial value of first two values
1209                 m_verifier->verifyInteger4Mask(m_testCtx, GL_SCISSOR_BOX, 0, true, 0, true, 0, false, 0, false);
1210                 expectError(GL_NO_ERROR);
1211
1212                 const int numIterations = 120;
1213                 for (int i = 0; i < numIterations; ++i)
1214                 {
1215                         GLint left              = rnd.getInt(-64000, 64000);
1216                         GLint bottom    = rnd.getInt(-64000, 64000);
1217                         GLsizei width   = rnd.getInt(0, 64000);
1218                         GLsizei height  = rnd.getInt(0, 64000);
1219
1220                         glScissor(left, bottom, width, height);
1221                         m_verifier->verifyInteger4(m_testCtx, GL_SCISSOR_BOX, left, bottom, width, height);
1222                         expectError(GL_NO_ERROR);
1223                 }
1224         }
1225 private:
1226         StateVerifier*  m_verifier;
1227 };
1228
1229 class MaxViewportDimsTestCase : public ApiCase
1230 {
1231 public:
1232         MaxViewportDimsTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
1233                 : ApiCase               (context, name, description)
1234                 , m_verifier    (verifier)
1235         {
1236         }
1237
1238         void test (void)
1239         {
1240                 m_verifier->verifyIntegerGreaterOrEqual2(m_testCtx, GL_MAX_VIEWPORT_DIMS, m_context.getRenderTarget().getWidth(), m_context.getRenderTarget().getHeight());
1241                 expectError(GL_NO_ERROR);
1242         }
1243 private:
1244         StateVerifier*  m_verifier;
1245 };
1246
1247 class StencilRefTestCase : public ApiCase
1248 {
1249 public:
1250         StencilRefTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName)
1251                 : ApiCase                       (context, name, description)
1252                 , m_verifier            (verifier)
1253                 , m_testTargetName      (testTargetName)
1254         {
1255         }
1256
1257         void test (void)
1258         {
1259                 m_verifier->verifyInteger(m_testCtx, m_testTargetName, 0);
1260                 expectError(GL_NO_ERROR);
1261
1262                 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1263
1264                 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1265                 {
1266                         const int ref = 1 << stencilBit;
1267
1268                         glStencilFunc(GL_ALWAYS, ref, 0); // mask should not affect the REF
1269                         expectError(GL_NO_ERROR);
1270
1271                         m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref);
1272                         expectError(GL_NO_ERROR);
1273
1274                         glStencilFunc(GL_ALWAYS, ref, ref);
1275                         expectError(GL_NO_ERROR);
1276
1277                         m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref);
1278                         expectError(GL_NO_ERROR);
1279                 }
1280         }
1281
1282 private:
1283         StateVerifier*  m_verifier;
1284         GLenum          m_testTargetName;
1285 };
1286
1287 class StencilRefSeparateTestCase : public ApiCase
1288 {
1289 public:
1290         StencilRefSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, GLenum stencilFuncTargetFace)
1291                 : ApiCase                                       (context, name, description)
1292                 , m_verifier                            (verifier)
1293                 , m_testTargetName                      (testTargetName)
1294                 , m_stencilFuncTargetFace       (stencilFuncTargetFace)
1295         {
1296         }
1297
1298         void test (void)
1299         {
1300                 m_verifier->verifyInteger(m_testCtx, m_testTargetName, 0);
1301                 expectError(GL_NO_ERROR);
1302
1303                 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1304
1305                 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1306                 {
1307                         const int ref = 1 << stencilBit;
1308
1309                         glStencilFuncSeparate(m_stencilFuncTargetFace, GL_ALWAYS, ref, 0);
1310                         expectError(GL_NO_ERROR);
1311
1312                         m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref);
1313                         expectError(GL_NO_ERROR);
1314
1315                         glStencilFuncSeparate(m_stencilFuncTargetFace, GL_ALWAYS, ref, ref);
1316                         expectError(GL_NO_ERROR);
1317
1318                         m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref);
1319                         expectError(GL_NO_ERROR);
1320                 }
1321         }
1322 private:
1323         StateVerifier*  m_verifier;
1324         GLenum          m_testTargetName;
1325         GLenum          m_stencilFuncTargetFace;
1326 };
1327
1328 class StencilOpTestCase : public ApiCase
1329 {
1330 public:
1331         StencilOpTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum stencilOpName)
1332                 : ApiCase                                       (context, name, description)
1333                 , m_verifier                            (verifier)
1334                 , m_stencilOpName                       (stencilOpName)
1335         {
1336         }
1337
1338         void test (void)
1339         {
1340                 m_verifier->verifyInteger(m_testCtx, m_stencilOpName, GL_KEEP);
1341                 expectError(GL_NO_ERROR);
1342
1343                 const GLenum stencilOpValues[] = {GL_KEEP, GL_ZERO, GL_REPLACE, GL_INCR, GL_DECR, GL_INVERT, GL_INCR_WRAP, GL_DECR_WRAP};
1344
1345                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stencilOpValues); ++ndx)
1346                 {
1347                         SetStencilOp(stencilOpValues[ndx]);
1348                         expectError(GL_NO_ERROR);
1349
1350                         m_verifier->verifyInteger(m_testCtx, m_stencilOpName, stencilOpValues[ndx]);
1351                         expectError(GL_NO_ERROR);
1352                 }
1353         }
1354
1355 protected:
1356         virtual void SetStencilOp (GLenum stencilOpValue)
1357         {
1358                 switch (m_stencilOpName)
1359                 {
1360                 case GL_STENCIL_FAIL:
1361                 case GL_STENCIL_BACK_FAIL:
1362                         glStencilOp(stencilOpValue, GL_KEEP, GL_KEEP);
1363                         break;
1364
1365                 case GL_STENCIL_PASS_DEPTH_FAIL:
1366                 case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
1367                         glStencilOp(GL_KEEP, stencilOpValue, GL_KEEP);
1368                         break;
1369
1370                 case GL_STENCIL_PASS_DEPTH_PASS:
1371                 case GL_STENCIL_BACK_PASS_DEPTH_PASS:
1372                         glStencilOp(GL_KEEP, GL_KEEP, stencilOpValue);
1373                         break;
1374
1375                 default:
1376                         DE_ASSERT(false && "should not happen");
1377                         break;
1378                 }
1379         }
1380
1381         StateVerifier*                          m_verifier;
1382         GLenum                                  m_stencilOpName;
1383 };
1384
1385
1386 class StencilOpSeparateTestCase : public StencilOpTestCase
1387 {
1388 public:
1389         StencilOpSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum stencilOpName, GLenum stencilOpFace)
1390                 : StencilOpTestCase             (context, verifier, name, description, stencilOpName)
1391                 , m_stencilOpFace               (stencilOpFace)
1392         {
1393         }
1394
1395 private:
1396         void SetStencilOp (GLenum stencilOpValue)
1397         {
1398                 switch (m_stencilOpName)
1399                 {
1400                 case GL_STENCIL_FAIL:
1401                 case GL_STENCIL_BACK_FAIL:
1402                         glStencilOpSeparate(m_stencilOpFace, stencilOpValue, GL_KEEP, GL_KEEP);
1403                         break;
1404
1405                 case GL_STENCIL_PASS_DEPTH_FAIL:
1406                 case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
1407                         glStencilOpSeparate(m_stencilOpFace, GL_KEEP, stencilOpValue, GL_KEEP);
1408                         break;
1409
1410                 case GL_STENCIL_PASS_DEPTH_PASS:
1411                 case GL_STENCIL_BACK_PASS_DEPTH_PASS:
1412                         glStencilOpSeparate(m_stencilOpFace, GL_KEEP, GL_KEEP, stencilOpValue);
1413                         break;
1414
1415                 default:
1416                         DE_ASSERT(false && "should not happen");
1417                         break;
1418                 }
1419         }
1420
1421         GLenum          m_stencilOpFace;
1422 };
1423
1424 class StencilFuncTestCase : public ApiCase
1425 {
1426 public:
1427         StencilFuncTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
1428                 : ApiCase               (context, name, description)
1429                 , m_verifier    (verifier)
1430         {
1431         }
1432
1433         void test (void)
1434         {
1435                 m_verifier->verifyInteger(m_testCtx, GL_STENCIL_FUNC, GL_ALWAYS);
1436                 expectError(GL_NO_ERROR);
1437
1438                 const GLenum stencilfuncValues[] = {GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL, GL_EQUAL, GL_GEQUAL, GL_GREATER, GL_NOTEQUAL};
1439
1440                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stencilfuncValues); ++ndx)
1441                 {
1442                         glStencilFunc(stencilfuncValues[ndx], 0, 0);
1443                         expectError(GL_NO_ERROR);
1444
1445                         m_verifier->verifyInteger(m_testCtx, GL_STENCIL_FUNC, stencilfuncValues[ndx]);
1446                         expectError(GL_NO_ERROR);
1447
1448                         m_verifier->verifyInteger(m_testCtx, GL_STENCIL_BACK_FUNC, stencilfuncValues[ndx]);
1449                         expectError(GL_NO_ERROR);
1450                 }
1451         }
1452 private:
1453         StateVerifier*  m_verifier;
1454 };
1455
1456 class StencilFuncSeparateTestCase : public ApiCase
1457 {
1458 public:
1459         StencilFuncSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum stencilFuncName, GLenum stencilFuncFace)
1460                 : ApiCase                       (context, name, description)
1461                 , m_verifier            (verifier)
1462                 , m_stencilFuncName     (stencilFuncName)
1463                 , m_stencilFuncFace     (stencilFuncFace)
1464         {
1465         }
1466
1467         void test (void)
1468         {
1469                 m_verifier->verifyInteger(m_testCtx, m_stencilFuncName, GL_ALWAYS);
1470                 expectError(GL_NO_ERROR);
1471
1472                 const GLenum stencilfuncValues[] = {GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL, GL_EQUAL, GL_GEQUAL, GL_GREATER, GL_NOTEQUAL};
1473
1474                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stencilfuncValues); ++ndx)
1475                 {
1476                         glStencilFuncSeparate(m_stencilFuncFace, stencilfuncValues[ndx], 0, 0);
1477                         expectError(GL_NO_ERROR);
1478
1479                         m_verifier->verifyInteger(m_testCtx, m_stencilFuncName, stencilfuncValues[ndx]);
1480                         expectError(GL_NO_ERROR);
1481                 }
1482         }
1483 private:
1484         StateVerifier*  m_verifier;
1485         GLenum          m_stencilFuncName;
1486         GLenum          m_stencilFuncFace;
1487 };
1488
1489 class StencilMaskTestCase : public ApiCase
1490 {
1491 public:
1492         StencilMaskTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName)
1493                 : ApiCase                       (context, name, description)
1494                 , m_verifier            (verifier)
1495                 , m_testTargetName      (testTargetName)
1496         {
1497         }
1498
1499         void test (void)
1500         {
1501                 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1502
1503                 m_verifier->verifyStencilMaskInitial(m_testCtx, m_testTargetName, stencilBits);
1504                 expectError(GL_NO_ERROR);
1505
1506                 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1507                 {
1508                         const int mask = 1 << stencilBit;
1509
1510                         glStencilFunc(GL_ALWAYS, 0, mask);
1511                         expectError(GL_NO_ERROR);
1512
1513                         m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask);
1514                         expectError(GL_NO_ERROR);
1515                 }
1516         }
1517 private:
1518         StateVerifier*  m_verifier;
1519         GLenum          m_testTargetName;
1520 };
1521
1522 class StencilMaskSeparateTestCase : public ApiCase
1523 {
1524 public:
1525         StencilMaskSeparateTestCase     (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, GLenum stencilFuncTargetFace)
1526                 : ApiCase                                       (context, name, description)
1527                 , m_verifier                            (verifier)
1528                 , m_testTargetName                      (testTargetName)
1529                 , m_stencilFuncTargetFace       (stencilFuncTargetFace)
1530         {
1531         }
1532
1533         void test (void)
1534         {
1535                 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1536
1537                 m_verifier->verifyStencilMaskInitial(m_testCtx, m_testTargetName, stencilBits);
1538                 expectError(GL_NO_ERROR);
1539
1540                 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1541                 {
1542                         const int mask = 1 << stencilBit;
1543
1544                         glStencilFuncSeparate(m_stencilFuncTargetFace, GL_ALWAYS, 0, mask);
1545                         expectError(GL_NO_ERROR);
1546
1547                         m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask);
1548                         expectError(GL_NO_ERROR);
1549                 }
1550         }
1551 private:
1552         StateVerifier*  m_verifier;
1553         GLenum          m_testTargetName;
1554         GLenum          m_stencilFuncTargetFace;
1555 };
1556
1557 class StencilWriteMaskTestCase : public ApiCase
1558 {
1559 public:
1560         StencilWriteMaskTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName)
1561                 : ApiCase                       (context, name, description)
1562                 , m_verifier            (verifier)
1563                 , m_testTargetName      (testTargetName)
1564         {
1565         }
1566
1567         void test (void)
1568         {
1569                 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1570
1571                 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1572                 {
1573                         const int mask = 1 << stencilBit;
1574
1575                         glStencilMask(mask);
1576                         expectError(GL_NO_ERROR);
1577
1578                         m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask);
1579                         expectError(GL_NO_ERROR);
1580                 }
1581         }
1582 private:
1583         StateVerifier*  m_verifier;
1584         GLenum          m_testTargetName;
1585 };
1586
1587 class StencilWriteMaskSeparateTestCase : public ApiCase
1588 {
1589 public:
1590         StencilWriteMaskSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, GLenum stencilTargetFace)
1591                 : ApiCase                               (context, name, description)
1592                 , m_verifier                    (verifier)
1593                 , m_testTargetName              (testTargetName)
1594                 , m_stencilTargetFace   (stencilTargetFace)
1595         {
1596         }
1597
1598         void test (void)
1599         {
1600                 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1601
1602                 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1603                 {
1604                         const int mask = 1 << stencilBit;
1605
1606                         glStencilMaskSeparate(m_stencilTargetFace, mask);
1607                         expectError(GL_NO_ERROR);
1608
1609                         m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask);
1610                         expectError(GL_NO_ERROR);
1611                 }
1612         }
1613 private:
1614         StateVerifier*  m_verifier;
1615         GLenum          m_testTargetName;
1616         GLenum          m_stencilTargetFace;
1617 };
1618
1619 class PixelStoreTestCase : public ApiCase
1620 {
1621 public:
1622         PixelStoreTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue)
1623                 : ApiCase                       (context, name, description)
1624                 , m_verifier            (verifier)
1625                 , m_testTargetName      (testTargetName)
1626                 , m_initialValue        (initialValue)
1627         {
1628         }
1629
1630         void test (void)
1631         {
1632                 de::Random rnd(0xabcdef);
1633
1634                 m_verifier->verifyInteger(m_testCtx, m_testTargetName, m_initialValue);
1635                 expectError(GL_NO_ERROR);
1636
1637                 const int numIterations = 120;
1638                 for (int i = 0; i < numIterations; ++i)
1639                 {
1640                         const int referenceValue = rnd.getInt(0, 64000);
1641
1642                         glPixelStorei(m_testTargetName, referenceValue);
1643                         expectError(GL_NO_ERROR);
1644
1645                         m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue);
1646                         expectError(GL_NO_ERROR);
1647                 }
1648         }
1649
1650 private:
1651         StateVerifier*  m_verifier;
1652         GLenum          m_testTargetName;
1653         int                     m_initialValue;
1654 };
1655
1656 class PixelStoreAlignTestCase : public ApiCase
1657 {
1658 public:
1659         PixelStoreAlignTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName)
1660                 : ApiCase                       (context, name, description)
1661                 , m_verifier            (verifier)
1662                 , m_testTargetName      (testTargetName)
1663         {
1664         }
1665
1666         void test (void)
1667         {
1668                 m_verifier->verifyInteger(m_testCtx, m_testTargetName, 4);
1669                 expectError(GL_NO_ERROR);
1670
1671                 const int alignments[] = {1, 2, 4, 8};
1672
1673                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(alignments); ++ndx)
1674                 {
1675                         const int referenceValue = alignments[ndx];
1676
1677                         glPixelStorei(m_testTargetName, referenceValue);
1678                         expectError(GL_NO_ERROR);
1679
1680                         m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue);
1681                         expectError(GL_NO_ERROR);
1682                 }
1683         }
1684
1685 private:
1686         StateVerifier*  m_verifier;
1687         GLenum          m_testTargetName;
1688 };
1689
1690 class BlendFuncTestCase : public ApiCase
1691 {
1692 public:
1693         BlendFuncTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue)
1694                 : ApiCase                       (context, name, description)
1695                 , m_verifier            (verifier)
1696                 , m_testTargetName      (testTargetName)
1697                 , m_initialValue        (initialValue)
1698         {
1699         }
1700
1701         void test (void)
1702         {
1703                 m_verifier->verifyInteger(m_testCtx, m_testTargetName, m_initialValue);
1704                 expectError(GL_NO_ERROR);
1705
1706                 const GLenum blendFuncValues[] =
1707                 {
1708                         GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR,
1709                         GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_CONSTANT_COLOR,
1710                         GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA,
1711                         GL_SRC_ALPHA_SATURATE
1712                 };
1713
1714                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(blendFuncValues); ++ndx)
1715                 {
1716                         const GLenum referenceValue = blendFuncValues[ndx];
1717
1718                         SetBlendFunc(referenceValue);
1719                         expectError(GL_NO_ERROR);
1720
1721                         m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue);
1722                         expectError(GL_NO_ERROR);
1723                 }
1724         }
1725 protected:
1726         virtual void SetBlendFunc (GLenum func)
1727         {
1728                 switch (m_testTargetName)
1729                 {
1730                 case GL_BLEND_SRC_RGB:
1731                 case GL_BLEND_SRC_ALPHA:
1732                         glBlendFunc(func, GL_ZERO);
1733                         break;
1734
1735                 case GL_BLEND_DST_RGB:
1736                 case GL_BLEND_DST_ALPHA:
1737                         glBlendFunc(GL_ZERO, func);
1738                         break;
1739
1740                 default:
1741                         DE_ASSERT(false && "should not happen");
1742                         break;
1743                 }
1744         }
1745
1746         StateVerifier*          m_verifier;
1747         GLenum                  m_testTargetName;
1748         int                             m_initialValue;
1749 };
1750
1751 class BlendFuncSeparateTestCase : public BlendFuncTestCase
1752 {
1753 public:
1754         BlendFuncSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue)
1755                 : BlendFuncTestCase     (context, verifier, name, description, testTargetName, initialValue)
1756         {
1757         }
1758
1759         void SetBlendFunc (GLenum func)
1760         {
1761                 switch (m_testTargetName)
1762                 {
1763                 case GL_BLEND_SRC_RGB:
1764                         glBlendFuncSeparate(func, GL_ZERO, GL_ZERO, GL_ZERO);
1765                         break;
1766
1767                 case GL_BLEND_DST_RGB:
1768                         glBlendFuncSeparate(GL_ZERO, func, GL_ZERO, GL_ZERO);
1769                         break;
1770
1771                 case GL_BLEND_SRC_ALPHA:
1772                         glBlendFuncSeparate(GL_ZERO, GL_ZERO, func, GL_ZERO);
1773                         break;
1774
1775                 case GL_BLEND_DST_ALPHA:
1776                         glBlendFuncSeparate(GL_ZERO, GL_ZERO, GL_ZERO, func);
1777                         break;
1778
1779                 default:
1780                         DE_ASSERT(false && "should not happen");
1781                         break;
1782                 }
1783         }
1784 };
1785
1786 class BlendEquationTestCase : public ApiCase
1787 {
1788 public:
1789         BlendEquationTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue)
1790                 : ApiCase                       (context, name, description)
1791                 , m_verifier            (verifier)
1792                 , m_testTargetName      (testTargetName)
1793                 , m_initialValue        (initialValue)
1794         {
1795         }
1796
1797         void test (void)
1798         {
1799                 m_verifier->verifyInteger(m_testCtx, m_testTargetName, m_initialValue);
1800                 expectError(GL_NO_ERROR);
1801
1802                 const GLenum blendFuncValues[] =
1803                 {
1804                         GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX
1805                 };
1806
1807                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(blendFuncValues); ++ndx)
1808                 {
1809                         const GLenum referenceValue = blendFuncValues[ndx];
1810
1811                         SetBlendEquation(referenceValue);
1812                         expectError(GL_NO_ERROR);
1813
1814                         m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue);
1815                         expectError(GL_NO_ERROR);
1816                 }
1817         }
1818 protected:
1819         virtual void SetBlendEquation (GLenum equation)
1820         {
1821                 glBlendEquation(equation);
1822         }
1823
1824         StateVerifier*          m_verifier;
1825         GLenum                  m_testTargetName;
1826         int                             m_initialValue;
1827 };
1828 class BlendEquationSeparateTestCase : public BlendEquationTestCase
1829 {
1830 public:
1831         BlendEquationSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue)
1832                 : BlendEquationTestCase (context, verifier, name, description, testTargetName, initialValue)
1833         {
1834         }
1835
1836 protected:
1837         void SetBlendEquation (GLenum equation)
1838         {
1839                 switch (m_testTargetName)
1840                 {
1841                 case GL_BLEND_EQUATION_RGB:
1842                         glBlendEquationSeparate(equation, GL_FUNC_ADD);
1843                         break;
1844
1845                 case GL_BLEND_EQUATION_ALPHA:
1846                         glBlendEquationSeparate(GL_FUNC_ADD, equation);
1847                         break;
1848
1849                 default:
1850                         DE_ASSERT(false && "should not happen");
1851                         break;
1852                 }
1853         }
1854 };
1855
1856 class ImplementationArrayTestCase : public ApiCase
1857 {
1858 public:
1859         ImplementationArrayTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, GLenum testTargetLengthTargetName, int minValue)
1860                 : ApiCase                                               (context, name, description)
1861                 , m_verifier                                    (verifier)
1862                 , m_testTargetName                              (testTargetName)
1863                 , m_testTargetLengthTargetName  (testTargetLengthTargetName)
1864                 , m_minValue                                    (minValue)
1865         {
1866         }
1867
1868         void test (void)
1869         {
1870                 m_verifier->verifyIntegerGreaterOrEqual(m_testCtx, m_testTargetLengthTargetName, m_minValue);
1871                 expectError(GL_NO_ERROR);
1872
1873                 GLint targetArrayLength = 0;
1874                 glGetIntegerv(m_testTargetLengthTargetName, &targetArrayLength);
1875                 expectError(GL_NO_ERROR);
1876
1877                 if (targetArrayLength)
1878                 {
1879                         std::vector<GLint> queryResult;
1880                         queryResult.resize(targetArrayLength, 0);
1881
1882                         glGetIntegerv(m_testTargetName, &queryResult[0]);
1883                         expectError(GL_NO_ERROR);
1884                 }
1885         }
1886
1887 private:
1888         StateVerifier*          m_verifier;
1889         GLenum                  m_testTargetName;
1890         GLenum                  m_testTargetLengthTargetName;
1891         int                             m_minValue;
1892 };
1893
1894 class BindingTest : public TestCase
1895 {
1896 public:
1897                                                 BindingTest     (Context&                                       context,
1898                                                                          const char*                            name,
1899                                                                          const char*                            desc,
1900                                                                          QueryType                                      type);
1901
1902         IterateResult           iterate         (void);
1903
1904         virtual void            test            (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const = 0;
1905
1906 protected:
1907         const QueryType         m_type;
1908 };
1909
1910 BindingTest::BindingTest (Context&              context,
1911                                                   const char*   name,
1912                                                   const char*   desc,
1913                                                   QueryType             type)
1914         : TestCase      (context, name, desc)
1915         , m_type        (type)
1916 {
1917 }
1918
1919 BindingTest::IterateResult BindingTest::iterate (void)
1920 {
1921         glu::CallLogWrapper             gl              (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
1922         tcu::ResultCollector    result  (m_context.getTestContext().getLog(), " // ERROR: ");
1923
1924         gl.enableLogging(true);
1925
1926         test(gl, result);
1927
1928         result.setTestContextResult(m_testCtx);
1929         return STOP;
1930 }
1931
1932 class TransformFeedbackBindingTestCase : public BindingTest
1933 {
1934 public:
1935         TransformFeedbackBindingTestCase (Context& context, QueryType type, const char* name)
1936                 : BindingTest(context, name, "GL_TRANSFORM_FEEDBACK_BINDING", type)
1937         {
1938         }
1939
1940         void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1941         {
1942                 static const char* transformFeedbackTestVertSource =
1943                         "#version 300 es\n"
1944                         "void main (void)\n"
1945                         "{\n"
1946                         "       gl_Position = vec4(0.0);\n"
1947                         "}\n\0";
1948                 static const char* transformFeedbackTestFragSource =
1949                         "#version 300 es\n"
1950                         "layout(location = 0) out mediump vec4 fragColor;"
1951                         "void main (void)\n"
1952                         "{\n"
1953                         "       fragColor = vec4(0.0);\n"
1954                         "}\n\0";
1955
1956                 GLuint  shaderVert;
1957                 GLuint  shaderFrag;
1958                 GLuint  shaderProg;
1959                 GLuint  transformfeedback = 0;
1960                 GLuint  feedbackBufferId = 0;
1961
1962                 {
1963                         const tcu::ScopedLogSection section(gl.getLog(), "Initial", "Initial");
1964                         verifyStateInteger(result, gl, GL_TRANSFORM_FEEDBACK_BINDING, 0, m_type);
1965                 }
1966
1967                 gl.glGenTransformFeedbacks(1, &transformfeedback);
1968                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenTransformFeedbacks");
1969
1970                 {
1971                         const tcu::ScopedLogSection section(gl.getLog(), "VertexShader", "Vertex Shader");
1972
1973                         GLint compileStatus = -1;
1974
1975                         shaderVert = gl.glCreateShader(GL_VERTEX_SHADER);
1976                         gl.glShaderSource(shaderVert, 1, &transformFeedbackTestVertSource, DE_NULL);
1977                         gl.glCompileShader(shaderVert);
1978                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glCompileShader");
1979
1980                         gl.glGetShaderiv(shaderVert, GL_COMPILE_STATUS, &compileStatus);
1981                         if (compileStatus != GL_TRUE)
1982                                 result.fail("expected GL_TRUE");
1983                 }
1984                 {
1985                         const tcu::ScopedLogSection section(gl.getLog(), "FragmentShader", "Fragment Shader");
1986
1987                         GLint compileStatus = -1;
1988
1989                         shaderFrag = gl.glCreateShader(GL_FRAGMENT_SHADER);
1990                         gl.glShaderSource(shaderFrag, 1, &transformFeedbackTestFragSource, DE_NULL);
1991                         gl.glCompileShader(shaderFrag);
1992                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glCompileShader");
1993
1994                         gl.glGetShaderiv(shaderFrag, GL_COMPILE_STATUS, &compileStatus);
1995                         if (compileStatus != GL_TRUE)
1996                                 result.fail("expected GL_TRUE");
1997                 }
1998                 {
1999                         const tcu::ScopedLogSection section(gl.getLog(), "Program", "Create and bind program");
2000
2001                         const char*     transform_feedback_outputs      = "gl_Position";
2002                         GLint           linkStatus                                      = -1;
2003
2004                         shaderProg = gl.glCreateProgram();
2005                         gl.glAttachShader(shaderProg, shaderVert);
2006                         gl.glAttachShader(shaderProg, shaderFrag);
2007                         gl.glTransformFeedbackVaryings(shaderProg, 1, &transform_feedback_outputs, GL_INTERLEAVED_ATTRIBS);
2008                         gl.glLinkProgram(shaderProg);
2009                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glLinkProgram");
2010
2011                         gl.glGetProgramiv(shaderProg, GL_LINK_STATUS, &linkStatus);
2012                         if (linkStatus != GL_TRUE)
2013                                 result.fail("expected GL_TRUE");
2014                 }
2015
2016                 gl.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformfeedback);
2017                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTransformFeedback");
2018
2019                 gl.glGenBuffers(1, &feedbackBufferId);
2020                 gl.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackBufferId);
2021                 gl.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_DYNAMIC_READ);
2022                 gl.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, feedbackBufferId);
2023                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind buffers");
2024
2025                 gl.glUseProgram(shaderProg);
2026
2027                 verifyStateInteger(result, gl, GL_TRANSFORM_FEEDBACK_BINDING, transformfeedback, m_type);
2028
2029                 gl.glUseProgram(0);
2030                 gl.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
2031                 gl.glDeleteTransformFeedbacks(1, &transformfeedback);
2032
2033                 verifyStateInteger(result, gl, GL_TRANSFORM_FEEDBACK_BINDING, 0, m_type);
2034
2035                 gl.glDeleteBuffers(1, &feedbackBufferId);
2036                 gl.glDeleteShader(shaderVert);
2037                 gl.glDeleteShader(shaderFrag);
2038                 gl.glDeleteProgram(shaderProg);
2039                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteProgram");
2040         }
2041 };
2042
2043 class CurrentProgramBindingTestCase : public BindingTest
2044 {
2045 public:
2046         CurrentProgramBindingTestCase (Context& context, QueryType type, const char* name, const char* description)
2047                 : BindingTest(context, name, description, type)
2048         {
2049         }
2050
2051         void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2052         {
2053                 static const char* testVertSource =
2054                         "#version 300 es\n"
2055                         "void main (void)\n"
2056                         "{\n"
2057                         "       gl_Position = vec4(0.0);\n"
2058                         "}\n\0";
2059                 static const char* testFragSource =
2060                         "#version 300 es\n"
2061                         "layout(location = 0) out mediump vec4 fragColor;"
2062                         "void main (void)\n"
2063                         "{\n"
2064                         "       fragColor = vec4(0.0);\n"
2065                         "}\n\0";
2066
2067                 GLuint  shaderVert;
2068                 GLuint  shaderFrag;
2069                 GLuint  shaderProg;
2070
2071                 {
2072                         const tcu::ScopedLogSection section(gl.getLog(), "Initial", "Initial");
2073
2074                         verifyStateInteger(result, gl, GL_CURRENT_PROGRAM, 0, m_type);
2075                 }
2076                 {
2077                         const tcu::ScopedLogSection section(gl.getLog(), "VertexShader", "Vertex Shader");
2078
2079                         GLint compileStatus = -1;
2080
2081                         shaderVert = gl.glCreateShader(GL_VERTEX_SHADER);
2082                         gl.glShaderSource(shaderVert, 1, &testVertSource, DE_NULL);
2083                         gl.glCompileShader(shaderVert);
2084                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glCompileShader");
2085
2086                         gl.glGetShaderiv(shaderVert, GL_COMPILE_STATUS, &compileStatus);
2087                         if (compileStatus != GL_TRUE)
2088                                 result.fail("expected GL_TRUE");
2089                 }
2090                 {
2091                         const tcu::ScopedLogSection section(gl.getLog(), "FragmentShader", "Fragment Shader");
2092
2093                         GLint compileStatus = -1;
2094
2095                         shaderFrag = gl.glCreateShader(GL_FRAGMENT_SHADER);
2096                         gl.glShaderSource(shaderFrag, 1, &testFragSource, DE_NULL);
2097                         gl.glCompileShader(shaderFrag);
2098                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glCompileShader");
2099
2100                         gl.glGetShaderiv(shaderFrag, GL_COMPILE_STATUS, &compileStatus);
2101                         if (compileStatus != GL_TRUE)
2102                                 result.fail("expected GL_TRUE");
2103                 }
2104                 {
2105                         const tcu::ScopedLogSection section(gl.getLog(), "Program", "Create and bind program");
2106
2107                         GLint linkStatus = -1;
2108
2109                         shaderProg = gl.glCreateProgram();
2110                         gl.glAttachShader(shaderProg, shaderVert);
2111                         gl.glAttachShader(shaderProg, shaderFrag);
2112                         gl.glLinkProgram(shaderProg);
2113                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glLinkProgram");
2114
2115                         gl.glGetProgramiv(shaderProg, GL_LINK_STATUS, &linkStatus);
2116                         if (linkStatus != GL_TRUE)
2117                                 result.fail("expected GL_TRUE");
2118
2119                         gl.glUseProgram(shaderProg);
2120                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glUseProgram");
2121
2122                         verifyStateInteger(result, gl, GL_CURRENT_PROGRAM, shaderProg, m_type);
2123                 }
2124                 {
2125                         const tcu::ScopedLogSection section(gl.getLog(), "Delete", "Delete program while in use");
2126
2127                         gl.glDeleteShader(shaderVert);
2128                         gl.glDeleteShader(shaderFrag);
2129                         gl.glDeleteProgram(shaderProg);
2130                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteProgram");
2131
2132                         verifyStateInteger(result, gl, GL_CURRENT_PROGRAM, shaderProg, m_type);
2133                 }
2134                 {
2135                         const tcu::ScopedLogSection section(gl.getLog(), "Unbind", "Unbind program");
2136                         gl.glUseProgram(0);
2137                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glUseProgram");
2138
2139                         verifyStateInteger(result, gl, GL_CURRENT_PROGRAM, 0, m_type);
2140                 }
2141         }
2142 };
2143
2144 class VertexArrayBindingTestCase : public BindingTest
2145 {
2146 public:
2147         VertexArrayBindingTestCase (Context& context, QueryType type, const char* name, const char* description)
2148                 : BindingTest(context, name, description, type)
2149         {
2150         }
2151
2152         void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2153         {
2154                 verifyStateInteger(result, gl, GL_VERTEX_ARRAY_BINDING, 0, m_type);
2155
2156                 GLuint vertexArrayObject = 0;
2157                 gl.glGenVertexArrays(1, &vertexArrayObject);
2158                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenVertexArrays");
2159
2160                 gl.glBindVertexArray(vertexArrayObject);
2161                 verifyStateInteger(result, gl, GL_VERTEX_ARRAY_BINDING, vertexArrayObject, m_type);
2162
2163                 gl.glDeleteVertexArrays(1, &vertexArrayObject);
2164                 verifyStateInteger(result, gl, GL_VERTEX_ARRAY_BINDING, 0, m_type);
2165         }
2166 };
2167
2168 class BufferBindingTestCase : public BindingTest
2169 {
2170 public:
2171         BufferBindingTestCase (Context& context, QueryType type, const char* name, const char* description, GLenum bufferBindingName, GLenum bufferType)
2172                 : BindingTest                   (context, name, description, type)
2173                 , m_bufferBindingName   (bufferBindingName)
2174                 , m_bufferType                  (bufferType)
2175         {
2176         }
2177
2178         void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2179         {
2180                 verifyStateInteger(result, gl, m_bufferBindingName, 0, m_type);
2181
2182                 GLuint bufferObject = 0;
2183                 gl.glGenBuffers(1, &bufferObject);
2184                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenBuffers");
2185
2186                 gl.glBindBuffer(m_bufferType, bufferObject);
2187                 verifyStateInteger(result, gl, m_bufferBindingName, bufferObject, m_type);
2188
2189                 gl.glDeleteBuffers(1, &bufferObject);
2190                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteBuffers");
2191
2192                 verifyStateInteger(result, gl, m_bufferBindingName, 0, m_type);
2193         }
2194
2195 private:
2196         const GLenum    m_bufferBindingName;
2197         const GLenum    m_bufferType;
2198 };
2199
2200 class ElementArrayBufferBindingTestCase : public BindingTest
2201 {
2202 public:
2203         ElementArrayBufferBindingTestCase (Context& context, QueryType type, const char* name)
2204                 : BindingTest(context, name, "GL_ELEMENT_ARRAY_BUFFER_BINDING", type)
2205         {
2206         }
2207
2208         void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2209         {
2210                 // Test with default VAO
2211                 {
2212                         const tcu::ScopedLogSection section(gl.getLog(), "DefaultVAO", "Test with default VAO");
2213
2214                         verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, 0, m_type);
2215
2216                         GLuint bufferObject = 0;
2217                         gl.glGenBuffers(1, &bufferObject);
2218                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenBuffers");
2219
2220                         gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferObject);
2221                         verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, bufferObject, m_type);
2222
2223                         gl.glDeleteBuffers(1, &bufferObject);
2224                         verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, 0, m_type);
2225                 }
2226
2227                 // Test with multiple VAOs
2228                 {
2229                         const tcu::ScopedLogSection section(gl.getLog(), "WithVAO", "Test with VAO");
2230
2231                         GLuint vaos[2]          = {0};
2232                         GLuint buffers[2]       = {0};
2233
2234                         gl.glGenVertexArrays(2, vaos);
2235                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenVertexArrays");
2236
2237                         gl.glGenBuffers(2, buffers);
2238                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenBuffers");
2239
2240                         // initial
2241                         gl.glBindVertexArray(vaos[0]);
2242                         verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, 0, m_type);
2243
2244                         // after setting
2245                         gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[0]);
2246                         verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, buffers[0], m_type);
2247
2248                         // initial of vao 2
2249                         gl.glBindVertexArray(vaos[1]);
2250                         verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, 0, m_type);
2251
2252                         // after setting to 2
2253                         gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]);
2254                         verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, buffers[1], m_type);
2255
2256                         // vao 1 still has buffer 1 bound?
2257                         gl.glBindVertexArray(vaos[0]);
2258                         verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, buffers[0], m_type);
2259
2260                         // deleting clears from bound vaos ...
2261                         gl.glDeleteBuffers(2, buffers);
2262                         verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, 0, m_type);
2263
2264                         // ... but does not from non-bound vaos?
2265                         gl.glBindVertexArray(vaos[1]);
2266                         verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, buffers[1], m_type);
2267
2268                         gl.glDeleteVertexArrays(2, vaos);
2269                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteVertexArrays");
2270                 }
2271         }
2272 };
2273
2274 class StencilClearValueTestCase : public ApiCase
2275 {
2276 public:
2277         StencilClearValueTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
2278                 : ApiCase               (context, name, description)
2279                 , m_verifier    (verifier)
2280         {
2281         }
2282
2283         void test (void)
2284         {
2285                 m_verifier->verifyInteger(m_testCtx, GL_STENCIL_CLEAR_VALUE, 0);
2286                 expectError(GL_NO_ERROR);
2287
2288                 const int stencilBits = m_context.getRenderTarget().getStencilBits();
2289
2290                 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
2291                 {
2292                         const int ref = 1 << stencilBit;
2293
2294                         glClearStencil(ref); // mask should not affect the REF
2295                         expectError(GL_NO_ERROR);
2296
2297                         m_verifier->verifyInteger(m_testCtx, GL_STENCIL_CLEAR_VALUE, ref);
2298                         expectError(GL_NO_ERROR);
2299                 }
2300         }
2301
2302 private:
2303         StateVerifier*  m_verifier;
2304 };
2305
2306 class ActiveTextureTestCase : public ApiCase
2307 {
2308 public:
2309         ActiveTextureTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
2310                 : ApiCase               (context, name, description)
2311                 , m_verifier    (verifier)
2312         {
2313         }
2314
2315         void test (void)
2316         {
2317                 m_verifier->verifyInteger(m_testCtx, GL_ACTIVE_TEXTURE, GL_TEXTURE0);
2318                 expectError(GL_NO_ERROR);
2319
2320                 GLint textureUnits = 0;
2321                 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &textureUnits);
2322                 expectError(GL_NO_ERROR);
2323
2324                 for (int ndx = 0; ndx < textureUnits; ++ndx)
2325                 {
2326                         glActiveTexture(GL_TEXTURE0 + ndx);
2327                         expectError(GL_NO_ERROR);
2328
2329                         m_verifier->verifyInteger(m_testCtx, GL_ACTIVE_TEXTURE, GL_TEXTURE0 + ndx);
2330                         expectError(GL_NO_ERROR);
2331                 }
2332         }
2333
2334 private:
2335         StateVerifier*          m_verifier;
2336 };
2337
2338 class RenderbufferBindingTestCase : public BindingTest
2339 {
2340 public:
2341         RenderbufferBindingTestCase (Context& context, QueryType type, const char* name, const char* description)
2342                 : BindingTest(context, name, description, type)
2343         {
2344         }
2345
2346         void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2347         {
2348                 verifyStateInteger(result, gl, GL_RENDERBUFFER_BINDING, 0, m_type);
2349
2350                 GLuint renderBuffer = 0;
2351                 gl.glGenRenderbuffers(1, &renderBuffer);
2352                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenRenderbuffers");
2353
2354                 gl.glBindRenderbuffer(GL_RENDERBUFFER, renderBuffer);
2355                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindRenderbuffer");
2356
2357                 verifyStateInteger(result, gl, GL_RENDERBUFFER_BINDING, renderBuffer, m_type);
2358
2359                 gl.glDeleteRenderbuffers(1, &renderBuffer);
2360                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteRenderbuffers");
2361
2362                 verifyStateInteger(result, gl, GL_RENDERBUFFER_BINDING, 0, m_type);
2363         }
2364 };
2365
2366 class SamplerObjectBindingTestCase : public BindingTest
2367 {
2368 public:
2369         SamplerObjectBindingTestCase (Context& context, QueryType type, const char* name, const char* description)
2370                 : BindingTest(context, name, description, type)
2371         {
2372         }
2373
2374         void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2375         {
2376                 verifyStateInteger(result, gl, GL_SAMPLER_BINDING, 0, m_type);
2377
2378                 {
2379                         const tcu::ScopedLogSection section(gl.getLog(), "SingleUnit", "Single unit");
2380
2381                         GLuint sampler = 0;
2382                         gl.glGenSamplers(1, &sampler);
2383                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenSamplers");
2384
2385                         gl.glBindSampler(0, sampler);
2386                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindSampler");
2387
2388                         verifyStateInteger(result, gl, GL_SAMPLER_BINDING, sampler, m_type);
2389
2390                         gl.glDeleteSamplers(1, &sampler);
2391                         verifyStateInteger(result, gl, GL_SAMPLER_BINDING, 0, m_type);
2392                 }
2393
2394                 {
2395                         const tcu::ScopedLogSection section(gl.getLog(), "MultipleUnits", "Multiple units");
2396
2397                         GLuint samplerA = 0;
2398                         GLuint samplerB = 0;
2399                         gl.glGenSamplers(1, &samplerA);
2400                         gl.glGenSamplers(1, &samplerB);
2401                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenSamplers");
2402
2403                         gl.glBindSampler(1, samplerA);
2404                         gl.glBindSampler(2, samplerB);
2405                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindSampler");
2406
2407                         verifyStateInteger(result, gl, GL_SAMPLER_BINDING, 0, m_type);
2408
2409                         gl.glActiveTexture(GL_TEXTURE1);
2410                         verifyStateInteger(result, gl, GL_SAMPLER_BINDING, samplerA, m_type);
2411
2412                         gl.glActiveTexture(GL_TEXTURE2);
2413                         verifyStateInteger(result, gl, GL_SAMPLER_BINDING, samplerB, m_type);
2414
2415                         gl.glDeleteSamplers(1, &samplerB);
2416                         gl.glDeleteSamplers(1, &samplerA);
2417                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteSamplers");
2418                 }
2419         }
2420 };
2421
2422 class TextureBindingTestCase : public BindingTest
2423 {
2424 public:
2425         TextureBindingTestCase (Context& context, QueryType type, const char* name, const char* description, GLenum testBindingName, GLenum textureType)
2426                 : BindingTest                   (context, name, description, type)
2427                 , m_testBindingName             (testBindingName)
2428                 , m_textureType                 (textureType)
2429         {
2430         }
2431
2432         void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2433         {
2434                 verifyStateInteger(result, gl, m_testBindingName, 0, m_type);
2435
2436                 GLuint texture = 0;
2437                 gl.glGenTextures(1, &texture);
2438                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenTextures");
2439
2440                 gl.glBindTexture(m_textureType, texture);
2441                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");
2442
2443                 verifyStateInteger(result, gl, m_testBindingName, texture, m_type);
2444
2445                 gl.glDeleteTextures(1, &texture);
2446                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
2447
2448                 verifyStateInteger(result, gl, m_testBindingName, 0, m_type);
2449         }
2450 private:
2451         const GLenum    m_testBindingName;
2452         const GLenum    m_textureType;
2453 };
2454
2455 class FrameBufferBindingTestCase : public BindingTest
2456 {
2457 public:
2458         FrameBufferBindingTestCase (Context& context, QueryType type, const char* name, const char* description)
2459                 : BindingTest(context, name, description, type)
2460         {
2461         }
2462
2463         void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2464         {
2465                 verifyStateInteger(result, gl, GL_DRAW_FRAMEBUFFER_BINDING,     0, m_type);
2466                 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING,          0, m_type);
2467                 verifyStateInteger(result, gl, GL_READ_FRAMEBUFFER_BINDING,     0, m_type);
2468
2469                 GLuint framebufferId = 0;
2470                 gl.glGenFramebuffers(1, &framebufferId);
2471                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenFramebuffers");
2472
2473                 gl.glBindFramebuffer(GL_FRAMEBUFFER, framebufferId);
2474                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind GL_FRAMEBUFFER");
2475
2476                 verifyStateInteger(result, gl, GL_DRAW_FRAMEBUFFER_BINDING,     framebufferId, m_type);
2477                 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING,          framebufferId, m_type);
2478                 verifyStateInteger(result, gl, GL_READ_FRAMEBUFFER_BINDING,     framebufferId, m_type);
2479
2480                 gl.glBindFramebuffer(GL_FRAMEBUFFER, 0);
2481                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "unbind GL_FRAMEBUFFER");
2482
2483                 verifyStateInteger(result, gl, GL_DRAW_FRAMEBUFFER_BINDING,     0, m_type);
2484                 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING,          0, m_type);
2485                 verifyStateInteger(result, gl, GL_READ_FRAMEBUFFER_BINDING,     0, m_type);
2486
2487                 gl.glBindFramebuffer(GL_READ_FRAMEBUFFER, framebufferId);
2488                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind GL_READ_FRAMEBUFFER");
2489
2490                 verifyStateInteger(result, gl, GL_DRAW_FRAMEBUFFER_BINDING,     0,                              m_type);
2491                 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING,          0,                              m_type);
2492                 verifyStateInteger(result, gl, GL_READ_FRAMEBUFFER_BINDING,     framebufferId,  m_type);
2493
2494                 gl.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebufferId);
2495                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind GL_DRAW_FRAMEBUFFER");
2496
2497                 verifyStateInteger(result, gl, GL_DRAW_FRAMEBUFFER_BINDING,     framebufferId, m_type);
2498                 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING,          framebufferId, m_type);
2499                 verifyStateInteger(result, gl, GL_READ_FRAMEBUFFER_BINDING,     framebufferId, m_type);
2500
2501                 gl.glDeleteFramebuffers(1, &framebufferId);
2502                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteFramebuffers");
2503
2504                 verifyStateInteger(result, gl, GL_DRAW_FRAMEBUFFER_BINDING,     0, m_type);
2505                 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING,          0, m_type);
2506                 verifyStateInteger(result, gl, GL_READ_FRAMEBUFFER_BINDING,     0, m_type);
2507         }
2508 };
2509
2510 class ImplementationColorReadTestCase : public ApiCase
2511 {
2512 public:
2513         ImplementationColorReadTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
2514                 : ApiCase               (context, name, description)
2515                 , m_verifier    (verifier)
2516         {
2517         }
2518
2519         void test (void)
2520         {
2521                 const GLint defaultColorTypes[] =
2522                 {
2523                         GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT,
2524                         GL_UNSIGNED_INT, GL_INT, GL_HALF_FLOAT, GL_FLOAT, GL_UNSIGNED_SHORT_5_6_5,
2525                         GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_5_5_5_1,
2526                         GL_UNSIGNED_INT_2_10_10_10_REV, GL_UNSIGNED_INT_10F_11F_11F_REV
2527                 };
2528                 const GLint defaultColorFormats[] =
2529                 {
2530                         GL_RGBA, GL_RGBA_INTEGER, GL_RGB, GL_RGB_INTEGER,
2531                         GL_RG, GL_RG_INTEGER, GL_RED, GL_RED_INTEGER
2532                 };
2533
2534                 std::vector<GLint> validColorTypes;
2535                 std::vector<GLint> validColorFormats;
2536
2537                 // Defined by the spec
2538
2539                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(defaultColorTypes); ++ndx)
2540                         validColorTypes.push_back(defaultColorTypes[ndx]);
2541                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(defaultColorFormats); ++ndx)
2542                         validColorFormats.push_back(defaultColorFormats[ndx]);
2543
2544                 // Extensions
2545
2546                 if (m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_format_BGRA8888") ||
2547                         m_context.getContextInfo().isExtensionSupported("GL_APPLE_texture_format_BGRA8888"))
2548                         validColorFormats.push_back(GL_BGRA);
2549
2550                 if (m_context.getContextInfo().isExtensionSupported("GL_EXT_read_format_bgra"))
2551                 {
2552                         validColorFormats.push_back(GL_BGRA);
2553                         validColorTypes.push_back(GL_UNSIGNED_SHORT_4_4_4_4_REV);
2554                         validColorTypes.push_back(GL_UNSIGNED_SHORT_1_5_5_5_REV);
2555                 }
2556
2557                 if (m_context.getContextInfo().isExtensionSupported("GL_IMG_read_format"))
2558                 {
2559                         validColorFormats.push_back(GL_BGRA);
2560                         validColorTypes.push_back(GL_UNSIGNED_SHORT_4_4_4_4_REV);
2561                 }
2562
2563                 if (m_context.getContextInfo().isExtensionSupported("GL_NV_sRGB_formats"))
2564                 {
2565                         validColorFormats.push_back(GL_SLUMINANCE_NV);
2566                         validColorFormats.push_back(GL_SLUMINANCE_ALPHA_NV);
2567                 }
2568
2569                 if (m_context.getContextInfo().isExtensionSupported("GL_NV_bgr"))
2570                 {
2571                         validColorFormats.push_back(GL_BGR_NV);
2572                 }
2573
2574                 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_IMPLEMENTATION_COLOR_READ_TYPE,    &validColorTypes[0],    validColorTypes.size());
2575                 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_IMPLEMENTATION_COLOR_READ_FORMAT,  &validColorFormats[0],  validColorFormats.size());
2576                 expectError(GL_NO_ERROR);
2577         }
2578
2579 private:
2580         StateVerifier*  m_verifier;
2581 };
2582
2583 class ReadBufferCase : public ApiCase
2584 {
2585 public:
2586         ReadBufferCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
2587                 : ApiCase               (context, name, description)
2588                 , m_verifier    (verifier)
2589         {
2590         }
2591
2592         void test (void)
2593         {
2594                 const GLint validInitialValues[] = {GL_BACK, GL_NONE};
2595                 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_READ_BUFFER, validInitialValues, DE_LENGTH_OF_ARRAY(validInitialValues));
2596                 expectError(GL_NO_ERROR);
2597
2598                 glReadBuffer(GL_NONE);
2599                 m_verifier->verifyInteger(m_testCtx, GL_READ_BUFFER, GL_NONE);
2600                 expectError(GL_NO_ERROR);
2601
2602                 glReadBuffer(GL_BACK);
2603                 m_verifier->verifyInteger(m_testCtx, GL_READ_BUFFER, GL_BACK);
2604                 expectError(GL_NO_ERROR);
2605
2606                 // test GL_READ_BUFFER with framebuffers
2607
2608                 GLuint framebufferId = 0;
2609                 glGenFramebuffers(1, &framebufferId);
2610                 expectError(GL_NO_ERROR);
2611
2612                 GLuint renderbuffer_id = 0;
2613                 glGenRenderbuffers(1, &renderbuffer_id);
2614                 expectError(GL_NO_ERROR);
2615
2616                 glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer_id);
2617                 expectError(GL_NO_ERROR);
2618
2619                 glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 128, 128);
2620                 expectError(GL_NO_ERROR);
2621
2622                 glBindFramebuffer(GL_READ_FRAMEBUFFER, framebufferId);
2623                 expectError(GL_NO_ERROR);
2624
2625                 glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffer_id);
2626                 expectError(GL_NO_ERROR);
2627
2628                 m_verifier->verifyInteger(m_testCtx, GL_READ_BUFFER, GL_COLOR_ATTACHMENT0);
2629
2630                 glDeleteFramebuffers(1, &framebufferId);
2631                 glDeleteRenderbuffers(1, &renderbuffer_id);
2632                 expectError(GL_NO_ERROR);
2633
2634                 m_verifier->verifyInteger(m_testCtx, GL_READ_BUFFER, GL_BACK);
2635                 expectError(GL_NO_ERROR);
2636         }
2637 private:
2638         StateVerifier*  m_verifier;
2639 };
2640
2641 class DrawBufferCase : public ApiCase
2642 {
2643 public:
2644         DrawBufferCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
2645                 : ApiCase               (context, name, description)
2646                 , m_verifier    (verifier)
2647         {
2648         }
2649
2650         void test (void)
2651         {
2652                 const GLint validInitialValues[] = {GL_BACK, GL_NONE};
2653                 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_DRAW_BUFFER0, validInitialValues, DE_LENGTH_OF_ARRAY(validInitialValues));
2654                 expectError(GL_NO_ERROR);
2655
2656                 GLenum bufs = GL_NONE;
2657                 glDrawBuffers(1, &bufs);
2658                 m_verifier->verifyInteger(m_testCtx, GL_DRAW_BUFFER0, GL_NONE);
2659                 expectError(GL_NO_ERROR);
2660
2661                 bufs = GL_BACK;
2662                 glDrawBuffers(1, &bufs);
2663                 m_verifier->verifyInteger(m_testCtx, GL_DRAW_BUFFER0, GL_BACK);
2664                 expectError(GL_NO_ERROR);
2665
2666                 // test GL_DRAW_BUFFER with framebuffers
2667
2668                 GLuint framebufferId = 0;
2669                 glGenFramebuffers(1, &framebufferId);
2670                 expectError(GL_NO_ERROR);
2671
2672                 GLuint renderbuffer_ids[2] = {0};
2673                 glGenRenderbuffers(2, renderbuffer_ids);
2674                 expectError(GL_NO_ERROR);
2675
2676                 glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer_ids[0]);
2677                 expectError(GL_NO_ERROR);
2678                 glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 128, 128);
2679                 expectError(GL_NO_ERROR);
2680
2681                 glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer_ids[1]);
2682                 expectError(GL_NO_ERROR);
2683                 glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 128, 128);
2684                 expectError(GL_NO_ERROR);
2685
2686                 glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebufferId);
2687                 expectError(GL_NO_ERROR);
2688
2689                 glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffer_ids[0]);
2690                 expectError(GL_NO_ERROR);
2691                 glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_RENDERBUFFER, renderbuffer_ids[1]);
2692                 expectError(GL_NO_ERROR);
2693
2694                 // only the initial state the draw buffer for fragment color zero is defined
2695                 m_verifier->verifyInteger(m_testCtx, GL_DRAW_BUFFER0, GL_COLOR_ATTACHMENT0);
2696
2697                 GLenum bufTargets[2] = {GL_NONE, GL_COLOR_ATTACHMENT1};
2698                 glDrawBuffers(2, bufTargets);
2699                 m_verifier->verifyInteger(m_testCtx, GL_DRAW_BUFFER0, GL_NONE);
2700                 m_verifier->verifyInteger(m_testCtx, GL_DRAW_BUFFER1, GL_COLOR_ATTACHMENT1);
2701
2702                 glDeleteFramebuffers(1, &framebufferId);
2703                 glDeleteRenderbuffers(2, renderbuffer_ids);
2704                 expectError(GL_NO_ERROR);
2705
2706                 m_verifier->verifyInteger(m_testCtx, GL_DRAW_BUFFER0, GL_BACK);
2707                 expectError(GL_NO_ERROR);
2708         }
2709 private:
2710         StateVerifier*  m_verifier;
2711 };
2712
2713 static const char* getQueryTypeSuffix (QueryType type)
2714 {
2715         switch (type)
2716         {
2717                 case QUERY_BOOLEAN:             return "_getboolean";
2718                 case QUERY_INTEGER:             return "_getinteger";
2719                 case QUERY_INTEGER64:   return "_getinteger64";
2720                 case QUERY_FLOAT:               return "_getfloat";
2721                 default:
2722                         DE_ASSERT(DE_FALSE);
2723                         return DE_NULL;
2724         }
2725 }
2726
2727 #define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK)                                                                                                \
2728         for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++)        \
2729         {                                                                                                                                                                                       \
2730                 StateVerifier* verifier = (VERIFIERS)[_verifierNdx];                                                                    \
2731                 CODE_BLOCK;                                                                                                                                                             \
2732         }
2733
2734 #define FOR_EACH_QUERYTYPE(QUERYTYPES, CODE_BLOCK)                                                                                                      \
2735         for (int _queryTypeNdx = 0; _queryTypeNdx < DE_LENGTH_OF_ARRAY(QUERYTYPES); _queryTypeNdx++)    \
2736         {                                                                                                                                                                                               \
2737                 const QueryType queryType = (QUERYTYPES)[_queryTypeNdx];                                                                        \
2738                 CODE_BLOCK;                                                                                                                                                                     \
2739         }
2740
2741 } // anonymous
2742
2743 IntegerStateQueryTests::IntegerStateQueryTests (Context& context)
2744         : TestCaseGroup                 (context, "integers", "Integer Values")
2745         , m_verifierBoolean             (DE_NULL)
2746         , m_verifierInteger             (DE_NULL)
2747         , m_verifierInteger64   (DE_NULL)
2748         , m_verifierFloat               (DE_NULL)
2749 {
2750 }
2751
2752 IntegerStateQueryTests::~IntegerStateQueryTests (void)
2753 {
2754         deinit();
2755 }
2756
2757 void IntegerStateQueryTests::init (void)
2758 {
2759         static const QueryType queryTypes[] =
2760         {
2761                 QUERY_BOOLEAN,
2762                 QUERY_INTEGER,
2763                 QUERY_INTEGER64,
2764                 QUERY_FLOAT,
2765         };
2766
2767         DE_ASSERT(m_verifierBoolean == DE_NULL);
2768         DE_ASSERT(m_verifierInteger == DE_NULL);
2769         DE_ASSERT(m_verifierInteger64 == DE_NULL);
2770         DE_ASSERT(m_verifierFloat == DE_NULL);
2771
2772         m_verifierBoolean               = new GetBooleanVerifier        (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
2773         m_verifierInteger               = new GetIntegerVerifier        (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
2774         m_verifierInteger64             = new GetInteger64Verifier      (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
2775         m_verifierFloat                 = new GetFloatVerifier          (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
2776
2777         const struct LimitedStateInteger
2778         {
2779                 const char*             name;
2780                 const char*             description;
2781                 GLenum                  targetName;
2782                 GLint                   value;
2783         } implementationMinLimits[] =
2784         {
2785                 { "subpixel_bits",                                                                      "SUBPIXEL_BITS has minimum value of 4",                                                                         GL_SUBPIXEL_BITS,                                                                       4       },
2786                 { "max_3d_texture_size",                                                        "MAX_3D_TEXTURE_SIZE has minimum value of 256",                                                         GL_MAX_3D_TEXTURE_SIZE,                                                         256     },
2787                 { "max_texture_size",                                                           "MAX_TEXTURE_SIZE has minimum value of 2048",                                                           GL_MAX_TEXTURE_SIZE,                                                            2048},
2788                 { "max_array_texture_layers",                                           "MAX_ARRAY_TEXTURE_LAYERS has minimum value of 256",                                            GL_MAX_ARRAY_TEXTURE_LAYERS,                                            256     },
2789                 { "max_cube_map_texture_size",                                          "MAX_CUBE_MAP_TEXTURE_SIZE has minimum value of 2048",                                          GL_MAX_CUBE_MAP_TEXTURE_SIZE,                                           2048},
2790                 { "max_renderbuffer_size",                                                      "MAX_RENDERBUFFER_SIZE has minimum value of 2048",                                                      GL_MAX_RENDERBUFFER_SIZE,                                                       2048},
2791                 { "max_draw_buffers",                                                           "MAX_DRAW_BUFFERS has minimum value of 4",                                                                      GL_MAX_DRAW_BUFFERS,                                                            4       },
2792                 { "max_color_attachments",                                                      "MAX_COLOR_ATTACHMENTS has minimum value of 4",                                                         GL_MAX_COLOR_ATTACHMENTS,                                                       4       },
2793                 { "max_elements_indices",                                                       "MAX_ELEMENTS_INDICES has minimum value of 0",                                                          GL_MAX_ELEMENTS_INDICES,                                                        0       },
2794                 { "max_elements_vertices",                                                      "MAX_ELEMENTS_VERTICES has minimum value of 0",                                                         GL_MAX_ELEMENTS_VERTICES,                                                       0       },
2795                 { "num_extensions",                                                                     "NUM_EXTENSIONS has minimum value of 0",                                                                        GL_NUM_EXTENSIONS,                                                                      0       },
2796                 { "major_version",                                                                      "MAJOR_VERSION has minimum value of 3",                                                                         GL_MAJOR_VERSION,                                                                       3       },
2797                 { "minor_version",                                                                      "MINOR_VERSION has minimum value of 0",                                                                         GL_MINOR_VERSION,                                                                       0       },
2798                 { "max_vertex_attribs",                                                         "MAX_VERTEX_ATTRIBS has minimum value of 16",                                                           GL_MAX_VERTEX_ATTRIBS,                                                          16      },
2799                 { "max_vertex_uniform_components",                                      "MAX_VERTEX_UNIFORM_COMPONENTS has minimum value of 1024",                                      GL_MAX_VERTEX_UNIFORM_COMPONENTS,                                       1024},
2800                 { "max_vertex_uniform_vectors",                                         "MAX_VERTEX_UNIFORM_VECTORS has minimum value of 256",                                          GL_MAX_VERTEX_UNIFORM_VECTORS,                                          256     },
2801                 { "max_vertex_uniform_blocks",                                          "MAX_VERTEX_UNIFORM_BLOCKS has minimum value of 12",                                            GL_MAX_VERTEX_UNIFORM_BLOCKS,                                           12      },
2802                 { "max_vertex_output_components",                                       "MAX_VERTEX_OUTPUT_COMPONENTS has minimum value of 64",                                         GL_MAX_VERTEX_OUTPUT_COMPONENTS,                                        64      },
2803                 { "max_vertex_texture_image_units",                                     "MAX_VERTEX_TEXTURE_IMAGE_UNITS has minimum value of 16",                                       GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS,                                      16      },
2804                 { "max_fragment_uniform_components",                            "MAX_FRAGMENT_UNIFORM_COMPONENTS has minimum value of 896",                                     GL_MAX_FRAGMENT_UNIFORM_COMPONENTS,                                     896     },
2805                 { "max_fragment_uniform_vectors",                                       "MAX_FRAGMENT_UNIFORM_VECTORS has minimum value of 224",                                        GL_MAX_FRAGMENT_UNIFORM_VECTORS,                                        224     },
2806                 { "max_fragment_uniform_blocks",                                        "MAX_FRAGMENT_UNIFORM_BLOCKS has minimum value of 12",                                          GL_MAX_FRAGMENT_UNIFORM_BLOCKS,                                         12      },
2807                 { "max_fragment_input_components",                                      "MAX_FRAGMENT_INPUT_COMPONENTS has minimum value of 60",                                        GL_MAX_FRAGMENT_INPUT_COMPONENTS,                                       60      },
2808                 { "max_texture_image_units",                                            "MAX_TEXTURE_IMAGE_UNITS has minimum value of 16",                                                      GL_MAX_TEXTURE_IMAGE_UNITS,                                                     16      },
2809                 { "max_program_texel_offset",                                           "MAX_PROGRAM_TEXEL_OFFSET has minimum value of 7",                                                      GL_MAX_PROGRAM_TEXEL_OFFSET,                                            7       },
2810                 { "max_uniform_buffer_bindings",                                        "MAX_UNIFORM_BUFFER_BINDINGS has minimum value of 24",                                          GL_MAX_UNIFORM_BUFFER_BINDINGS,                                         24      },
2811                 { "max_combined_uniform_blocks",                                        "MAX_COMBINED_UNIFORM_BLOCKS has minimum value of 24",                                          GL_MAX_COMBINED_UNIFORM_BLOCKS,                                         24      },
2812                 { "max_varying_components",                                                     "MAX_VARYING_COMPONENTS has minimum value of 60",                                                       GL_MAX_VARYING_COMPONENTS,                                                      60      },
2813                 { "max_varying_vectors",                                                        "MAX_VARYING_VECTORS has minimum value of 15",                                                          GL_MAX_VARYING_VECTORS,                                                         15      },
2814                 { "max_combined_texture_image_units",                           "MAX_COMBINED_TEXTURE_IMAGE_UNITS has minimum value of 32",                                     GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,                            32      },
2815                 { "max_transform_feedback_interleaved_components",      "MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS has minimum value of 64",        GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS,       64      },
2816                 { "max_transform_feedback_separate_attribs",            "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS has minimum value of 4",                       GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,                     4       },
2817                 { "max_transform_feedback_separate_components",         "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS has minimum value of 4",            GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS,          4       },
2818                 { "max_samples",                                                                        "MAX_SAMPLES has minimum value of 4",                                                                           GL_MAX_SAMPLES,                                                                         4       },
2819                 { "red_bits",                                                                           "RED_BITS has minimum value of 0",                                                                                      GL_RED_BITS,                                                                            0       },
2820                 { "green_bits",                                                                         "GREEN_BITS has minimum value of 0",                                                                            GL_GREEN_BITS,                                                                          0       },
2821                 { "blue_bits",                                                                          "BLUE_BITS has minimum value of 0",                                                                                     GL_BLUE_BITS,                                                                           0       },
2822                 { "alpha_bits",                                                                         "ALPHA_BITS has minimum value of 0",                                                                            GL_ALPHA_BITS,                                                                          0       },
2823                 { "depth_bits",                                                                         "DEPTH_BITS has minimum value of 0",                                                                            GL_DEPTH_BITS,                                                                          0       },
2824                 { "stencil_bits",                                                                       "STENCIL_BITS has minimum value of 0",                                                                          GL_STENCIL_BITS,                                                                        0       },
2825         };
2826         const LimitedStateInteger implementationMaxLimits[] =
2827         {
2828                 { "min_program_texel_offset",                                           "MIN_PROGRAM_TEXEL_OFFSET has maximum value of -8",                                                     GL_MIN_PROGRAM_TEXEL_OFFSET,                                            -8      },
2829                 { "uniform_buffer_offset_alignment",                            "UNIFORM_BUFFER_OFFSET_ALIGNMENT has minimum value of 1",                                       GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT,                                     256     },
2830         };
2831
2832         // \note implementation defined limits have their own tests so just check the conversions to boolean, int64 and float
2833         StateVerifier* implementationLimitVerifiers[] = {m_verifierBoolean, m_verifierInteger64, m_verifierFloat};
2834
2835         for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(implementationMinLimits); testNdx++)
2836                 FOR_EACH_VERIFIER(implementationLimitVerifiers, addChild(new ConstantMinimumValueTestCase(m_context, verifier, (std::string(implementationMinLimits[testNdx].name) + verifier->getTestNamePostfix()).c_str(), implementationMinLimits[testNdx].description, implementationMinLimits[testNdx].targetName, implementationMinLimits[testNdx].value)));
2837         for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(implementationMaxLimits); testNdx++)
2838                 FOR_EACH_VERIFIER(implementationLimitVerifiers, addChild(new ConstantMaximumValueTestCase(m_context, verifier, (std::string(implementationMaxLimits[testNdx].name) + verifier->getTestNamePostfix()).c_str(), implementationMaxLimits[testNdx].description, implementationMaxLimits[testNdx].targetName, implementationMaxLimits[testNdx].value)));
2839
2840         StateVerifier* normalVerifiers[] = {m_verifierBoolean, m_verifierInteger, m_verifierInteger64, m_verifierFloat};
2841
2842         FOR_EACH_VERIFIER(implementationLimitVerifiers, addChild(new SampleBuffersTestCase              (m_context,      verifier, (std::string("sample_buffers")                                               + verifier->getTestNamePostfix()).c_str(),              "SAMPLE_BUFFERS")));
2843
2844         FOR_EACH_VERIFIER(normalVerifiers, addChild(new SamplesTestCase                         (m_context,      verifier, (std::string("samples")                                                              + verifier->getTestNamePostfix()).c_str(),              "SAMPLES")));
2845         FOR_EACH_VERIFIER(normalVerifiers, addChild(new HintTestCase                            (m_context,      verifier, (std::string("generate_mipmap_hint")                                 + verifier->getTestNamePostfix()).c_str(),              "GENERATE_MIPMAP_HINT",                         GL_GENERATE_MIPMAP_HINT)));
2846         FOR_EACH_VERIFIER(normalVerifiers, addChild(new HintTestCase                            (m_context,      verifier, (std::string("fragment_shader_derivative_hint")              + verifier->getTestNamePostfix()).c_str(),              "FRAGMENT_SHADER_DERIVATIVE_HINT",      GL_FRAGMENT_SHADER_DERIVATIVE_HINT)));
2847         FOR_EACH_VERIFIER(normalVerifiers, addChild(new DepthFuncTestCase                       (m_context,      verifier, (std::string("depth_func")                                                   + verifier->getTestNamePostfix()).c_str(),              "DEPTH_FUNC")));
2848         FOR_EACH_VERIFIER(normalVerifiers, addChild(new CullFaceTestCase                        (m_context,      verifier, (std::string("cull_face_mode")                                               + verifier->getTestNamePostfix()).c_str(),              "CULL_FACE_MODE")));
2849         FOR_EACH_VERIFIER(normalVerifiers, addChild(new FrontFaceTestCase                       (m_context,      verifier, (std::string("front_face_mode")                                              + verifier->getTestNamePostfix()).c_str(),              "FRONT_FACE")));
2850         FOR_EACH_VERIFIER(normalVerifiers, addChild(new ViewPortTestCase                        (m_context,      verifier, (std::string("viewport")                                                             + verifier->getTestNamePostfix()).c_str(),              "VIEWPORT")));
2851         FOR_EACH_VERIFIER(normalVerifiers, addChild(new ScissorBoxTestCase                      (m_context,      verifier, (std::string("scissor_box")                                                  + verifier->getTestNamePostfix()).c_str(),              "SCISSOR_BOX")));
2852         FOR_EACH_VERIFIER(normalVerifiers, addChild(new MaxViewportDimsTestCase         (m_context,      verifier, (std::string("max_viewport_dims")                                    + verifier->getTestNamePostfix()).c_str(),              "MAX_VIEWPORT_DIMS")));
2853         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefTestCase                      (m_context,      verifier, (std::string("stencil_ref")                                                  + verifier->getTestNamePostfix()).c_str(),              "STENCIL_REF",                                          GL_STENCIL_REF)));
2854         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefTestCase                      (m_context,      verifier, (std::string("stencil_back_ref")                                             + verifier->getTestNamePostfix()).c_str(),              "STENCIL_BACK_REF",                                     GL_STENCIL_BACK_REF)));
2855         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefSeparateTestCase      (m_context,      verifier, (std::string("stencil_ref_separate")                                 + verifier->getTestNamePostfix()).c_str(),              "STENCIL_REF (separate)",                       GL_STENCIL_REF,                 GL_FRONT)));
2856         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefSeparateTestCase      (m_context,      verifier, (std::string("stencil_ref_separate_both")                    + verifier->getTestNamePostfix()).c_str(),              "STENCIL_REF (separate)",                       GL_STENCIL_REF,                 GL_FRONT_AND_BACK)));
2857         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefSeparateTestCase      (m_context,      verifier, (std::string("stencil_back_ref_separate")                    + verifier->getTestNamePostfix()).c_str(),              "STENCIL_BACK_REF (separate)",          GL_STENCIL_BACK_REF,    GL_BACK)));
2858         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefSeparateTestCase      (m_context,      verifier, (std::string("stencil_back_ref_separate_both")               + verifier->getTestNamePostfix()).c_str(),              "STENCIL_BACK_REF (separate)",          GL_STENCIL_BACK_REF,    GL_FRONT_AND_BACK)));
2859
2860         const struct NamedStencilOp
2861         {
2862                 const char*             name;
2863
2864                 const char*             frontDescription;
2865                 GLenum                  frontTarget;
2866                 const char*             backDescription;
2867                 GLenum                  backTarget;
2868         } stencilOps[] =
2869         {
2870                 { "fail",               "STENCIL_FAIL",                         GL_STENCIL_FAIL,                        "STENCIL_BACK_FAIL",                    GL_STENCIL_BACK_FAIL                    },
2871                 { "depth_fail", "STENCIL_PASS_DEPTH_FAIL",      GL_STENCIL_PASS_DEPTH_FAIL,     "STENCIL_BACK_PASS_DEPTH_FAIL", GL_STENCIL_BACK_PASS_DEPTH_FAIL },
2872                 { "depth_pass", "STENCIL_PASS_DEPTH_PASS",      GL_STENCIL_PASS_DEPTH_PASS,     "STENCIL_BACK_PASS_DEPTH_PASS", GL_STENCIL_BACK_PASS_DEPTH_PASS }
2873         };
2874
2875         for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(stencilOps); testNdx++)
2876         {
2877                 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpTestCase                       (m_context, verifier, (std::string("stencil_")          + stencilOps[testNdx].name + verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].frontDescription,     stencilOps[testNdx].frontTarget)));
2878                 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpTestCase                       (m_context, verifier, (std::string("stencil_back_")     + stencilOps[testNdx].name + verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].backDescription,      stencilOps[testNdx].backTarget)));
2879
2880                 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpSeparateTestCase       (m_context, verifier, (std::string("stencil_")          + stencilOps[testNdx].name + "_separate_both"   + verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].frontDescription,        stencilOps[testNdx].frontTarget,        GL_FRONT_AND_BACK)));
2881                 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpSeparateTestCase       (m_context, verifier, (std::string("stencil_back_")     + stencilOps[testNdx].name + "_separate_both"   + verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].backDescription,         stencilOps[testNdx].backTarget,         GL_FRONT_AND_BACK)));
2882
2883                 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpSeparateTestCase       (m_context, verifier, (std::string("stencil_")          + stencilOps[testNdx].name + "_separate"                + verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].frontDescription,        stencilOps[testNdx].frontTarget,        GL_FRONT)));
2884                 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpSeparateTestCase       (m_context, verifier, (std::string("stencil_back_")     + stencilOps[testNdx].name + "_separate"                + verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].backDescription,         stencilOps[testNdx].backTarget,         GL_BACK)));
2885         }
2886
2887         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilFuncTestCase                                     (m_context, verifier,   (std::string("stencil_func")                                                            + verifier->getTestNamePostfix()).c_str(),      "STENCIL_FUNC")));
2888         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilFuncSeparateTestCase                     (m_context, verifier,   (std::string("stencil_func_separate")                                           + verifier->getTestNamePostfix()).c_str(),      "STENCIL_FUNC (separate)",                              GL_STENCIL_FUNC,                                GL_FRONT)));
2889         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilFuncSeparateTestCase                     (m_context, verifier,   (std::string("stencil_func_separate_both")                                      + verifier->getTestNamePostfix()).c_str(),      "STENCIL_FUNC (separate)",                              GL_STENCIL_FUNC,                                GL_FRONT_AND_BACK)));
2890         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilFuncSeparateTestCase                     (m_context, verifier,   (std::string("stencil_back_func_separate")                                      + verifier->getTestNamePostfix()).c_str(),      "STENCIL_FUNC (separate)",                              GL_STENCIL_BACK_FUNC,                   GL_BACK)));
2891         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilFuncSeparateTestCase                     (m_context, verifier,   (std::string("stencil_back_func_separate_both")                         + verifier->getTestNamePostfix()).c_str(),      "STENCIL_FUNC (separate)",                              GL_STENCIL_BACK_FUNC,                   GL_FRONT_AND_BACK)));
2892         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskTestCase                                     (m_context, verifier,   (std::string("stencil_value_mask")                                                      + verifier->getTestNamePostfix()).c_str(),      "STENCIL_VALUE_MASK",                                   GL_STENCIL_VALUE_MASK)));
2893         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskTestCase                                     (m_context, verifier,   (std::string("stencil_back_value_mask")                                         + verifier->getTestNamePostfix()).c_str(),      "STENCIL_BACK_VALUE_MASK",                              GL_STENCIL_BACK_VALUE_MASK)));
2894         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskSeparateTestCase                     (m_context, verifier,   (std::string("stencil_value_mask_separate")                                     + verifier->getTestNamePostfix()).c_str(),      "STENCIL_VALUE_MASK (separate)",                GL_STENCIL_VALUE_MASK,                  GL_FRONT)));
2895         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskSeparateTestCase                     (m_context, verifier,   (std::string("stencil_value_mask_separate_both")                        + verifier->getTestNamePostfix()).c_str(),      "STENCIL_VALUE_MASK (separate)",                GL_STENCIL_VALUE_MASK,                  GL_FRONT_AND_BACK)));
2896         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskSeparateTestCase                     (m_context, verifier,   (std::string("stencil_back_value_mask_separate")                        + verifier->getTestNamePostfix()).c_str(),      "STENCIL_BACK_VALUE_MASK (separate)",   GL_STENCIL_BACK_VALUE_MASK,             GL_BACK)));
2897         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskSeparateTestCase                     (m_context, verifier,   (std::string("stencil_back_value_mask_separate_both")           + verifier->getTestNamePostfix()).c_str(),      "STENCIL_BACK_VALUE_MASK (separate)",   GL_STENCIL_BACK_VALUE_MASK,             GL_FRONT_AND_BACK)));
2898         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskTestCase                        (m_context, verifier,   (std::string("stencil_writemask")                                                       + verifier->getTestNamePostfix()).c_str(),      "STENCIL_WRITEMASK",                                    GL_STENCIL_WRITEMASK)));
2899         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskTestCase                        (m_context, verifier,   (std::string("stencil_back_writemask")                                          + verifier->getTestNamePostfix()).c_str(),      "STENCIL_BACK_WRITEMASK",                               GL_STENCIL_BACK_WRITEMASK)));
2900         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskSeparateTestCase        (m_context, verifier,   (std::string("stencil_writemask_separate")                                      + verifier->getTestNamePostfix()).c_str(),      "STENCIL_WRITEMASK (separate)",                 GL_STENCIL_WRITEMASK,                   GL_FRONT)));
2901         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskSeparateTestCase        (m_context, verifier,   (std::string("stencil_writemask_separate_both")                         + verifier->getTestNamePostfix()).c_str(),      "STENCIL_WRITEMASK (separate)",                 GL_STENCIL_WRITEMASK,                   GL_FRONT_AND_BACK)));
2902         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskSeparateTestCase        (m_context, verifier,   (std::string("stencil_back_writemask_separate")                         + verifier->getTestNamePostfix()).c_str(),      "STENCIL_BACK_WRITEMASK (separate)",    GL_STENCIL_BACK_WRITEMASK,              GL_BACK)));
2903         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskSeparateTestCase        (m_context, verifier,   (std::string("stencil_back_writemask_separate_both")            + verifier->getTestNamePostfix()).c_str(),      "STENCIL_BACK_WRITEMASK (separate)",    GL_STENCIL_BACK_WRITEMASK,              GL_FRONT_AND_BACK)));
2904
2905         const struct PixelStoreState
2906         {
2907                 const char*     name;
2908                 const char*     description;
2909                 GLenum          target;
2910                 int                     initialValue;
2911         } pixelStoreStates[] =
2912         {
2913                 { "unpack_image_height","UNPACK_IMAGE_HEIGHT",  GL_UNPACK_IMAGE_HEIGHT, 0 },
2914                 { "unpack_skip_images", "UNPACK_SKIP_IMAGES",   GL_UNPACK_SKIP_IMAGES,  0 },
2915                 { "unpack_row_length",  "UNPACK_ROW_LENGTH",    GL_UNPACK_ROW_LENGTH,   0 },
2916                 { "unpack_skip_rows",   "UNPACK_SKIP_ROWS",             GL_UNPACK_SKIP_ROWS,    0 },
2917                 { "unpack_skip_pixels", "UNPACK_SKIP_PIXELS",   GL_UNPACK_SKIP_PIXELS,  0 },
2918                 { "pack_row_length",    "PACK_ROW_LENGTH",              GL_PACK_ROW_LENGTH,             0 },
2919                 { "pack_skip_rows",             "PACK_SKIP_ROWS",               GL_PACK_SKIP_ROWS,              0 },
2920                 { "pack_skip_pixels",   "PACK_SKIP_PIXELS",             GL_PACK_SKIP_PIXELS,    0 }
2921         };
2922         for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(pixelStoreStates); testNdx++)
2923         {
2924                 FOR_EACH_VERIFIER(normalVerifiers, addChild(new PixelStoreTestCase(m_context, verifier, (std::string(pixelStoreStates[testNdx].name) + verifier->getTestNamePostfix()).c_str(), pixelStoreStates[testNdx].description, pixelStoreStates[testNdx].target, pixelStoreStates[testNdx].initialValue)));
2925         }
2926
2927         FOR_EACH_VERIFIER(normalVerifiers, addChild(new PixelStoreAlignTestCase(m_context, verifier, (std::string("unpack_alignment")   + verifier->getTestNamePostfix()).c_str(),      "UNPACK_ALIGNMENT",     GL_UNPACK_ALIGNMENT)));
2928         FOR_EACH_VERIFIER(normalVerifiers, addChild(new PixelStoreAlignTestCase(m_context, verifier, (std::string("pack_alignment")             + verifier->getTestNamePostfix()).c_str(),      "PACK_ALIGNMENT",       GL_PACK_ALIGNMENT)));
2929
2930         const struct BlendColorState
2931         {
2932                 const char*     name;
2933                 const char*     description;
2934                 GLenum          target;
2935                 int                     initialValue;
2936         } blendColorStates[] =
2937         {
2938                 { "blend_src_rgb",              "BLEND_SRC_RGB",        GL_BLEND_SRC_RGB,               GL_ONE  },
2939                 { "blend_src_alpha",    "BLEND_SRC_ALPHA",      GL_BLEND_SRC_ALPHA,             GL_ONE  },
2940                 { "blend_dst_rgb",              "BLEND_DST_RGB",        GL_BLEND_DST_RGB,               GL_ZERO },
2941                 { "blend_dst_alpha",    "BLEND_DST_ALPHA",      GL_BLEND_DST_ALPHA,             GL_ZERO }
2942         };
2943         for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(blendColorStates); testNdx++)
2944         {
2945                 FOR_EACH_VERIFIER(normalVerifiers, addChild(new BlendFuncTestCase                       (m_context, verifier, (std::string(blendColorStates[testNdx].name)                                      + verifier->getTestNamePostfix()).c_str(),      blendColorStates[testNdx].description,  blendColorStates[testNdx].target,       blendColorStates[testNdx].initialValue)));
2946                 FOR_EACH_VERIFIER(normalVerifiers, addChild(new BlendFuncSeparateTestCase       (m_context, verifier, (std::string(blendColorStates[testNdx].name) + "_separate"        + verifier->getTestNamePostfix()).c_str(),      blendColorStates[testNdx].description,  blendColorStates[testNdx].target,       blendColorStates[testNdx].initialValue)));
2947         }
2948
2949         const struct BlendEquationState
2950         {
2951                 const char*     name;
2952                 const char*     description;
2953                 GLenum          target;
2954                 int                     initialValue;
2955         } blendEquationStates[] =
2956         {
2957                 { "blend_equation_rgb",         "BLEND_EQUATION_RGB",   GL_BLEND_EQUATION_RGB,          GL_FUNC_ADD     },
2958                 { "blend_equation_alpha",       "BLEND_EQUATION_ALPHA", GL_BLEND_EQUATION_ALPHA,        GL_FUNC_ADD     }
2959         };
2960         for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(blendEquationStates); testNdx++)
2961         {
2962                 FOR_EACH_VERIFIER(normalVerifiers, addChild(new BlendEquationTestCase                   (m_context, verifier, (std::string(blendEquationStates[testNdx].name) +                         + verifier->getTestNamePostfix()).c_str(),              blendEquationStates[testNdx].description,       blendEquationStates[testNdx].target,    blendEquationStates[testNdx].initialValue)));
2963                 FOR_EACH_VERIFIER(normalVerifiers, addChild(new BlendEquationSeparateTestCase   (m_context, verifier, (std::string(blendEquationStates[testNdx].name) + "_separate"     + verifier->getTestNamePostfix()).c_str(),              blendEquationStates[testNdx].description,       blendEquationStates[testNdx].target,    blendEquationStates[testNdx].initialValue)));
2964         }
2965
2966         const struct ImplementationArrayReturningState
2967         {
2968                 const char*     name;
2969                 const char*     description;
2970                 GLenum          target;
2971                 GLenum          targetLengthTarget;
2972                 int                     minLength;
2973         } implementationArrayReturningStates[] =
2974         {
2975                 { "compressed_texture_formats",         "COMPRESSED_TEXTURE_FORMATS",   GL_COMPRESSED_TEXTURE_FORMATS,  GL_NUM_COMPRESSED_TEXTURE_FORMATS,      10      },
2976                 { "program_binary_formats",                     "PROGRAM_BINARY_FORMATS",               GL_PROGRAM_BINARY_FORMATS,              GL_NUM_PROGRAM_BINARY_FORMATS,          0       },
2977                 { "shader_binary_formats",                      "SHADER_BINARY_FORMATS",                GL_SHADER_BINARY_FORMATS,               GL_NUM_SHADER_BINARY_FORMATS,           0       }
2978         };
2979         for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(implementationArrayReturningStates); testNdx++)
2980         {
2981                 FOR_EACH_VERIFIER(normalVerifiers, addChild(new ImplementationArrayTestCase(m_context, verifier, (std::string(implementationArrayReturningStates[testNdx].name) + verifier->getTestNamePostfix()).c_str(), implementationArrayReturningStates[testNdx].description,     implementationArrayReturningStates[testNdx].target,     implementationArrayReturningStates[testNdx].targetLengthTarget, implementationArrayReturningStates[testNdx].minLength)));
2982         }
2983
2984         const struct BufferBindingState
2985         {
2986                 const char*     name;
2987                 const char*     description;
2988                 GLenum          target;
2989                 GLenum          type;
2990         } bufferBindingStates[] =
2991         {
2992                 { "array_buffer_binding",                               "ARRAY_BUFFER_BINDING",                                 GL_ARRAY_BUFFER_BINDING,                                GL_ARRAY_BUFFER                         },
2993                 { "uniform_buffer_binding",                             "UNIFORM_BUFFER_BINDING",                               GL_UNIFORM_BUFFER_BINDING,                              GL_UNIFORM_BUFFER                       },
2994                 { "pixel_pack_buffer_binding",                  "PIXEL_PACK_BUFFER_BINDING",                    GL_PIXEL_PACK_BUFFER_BINDING,                   GL_PIXEL_PACK_BUFFER            },
2995                 { "pixel_unpack_buffer_binding",                "PIXEL_UNPACK_BUFFER_BINDING",                  GL_PIXEL_UNPACK_BUFFER_BINDING,                 GL_PIXEL_UNPACK_BUFFER          },
2996                 { "transform_feedback_buffer_binding",  "TRANSFORM_FEEDBACK_BUFFER_BINDING",    GL_TRANSFORM_FEEDBACK_BUFFER_BINDING,   GL_TRANSFORM_FEEDBACK_BUFFER},
2997                 { "copy_read_buffer_binding",                   "COPY_READ_BUFFER_BINDING",                             GL_COPY_READ_BUFFER_BINDING,                    GL_COPY_READ_BUFFER                     },
2998                 { "copy_write_buffer_binding",                  "COPY_WRITE_BUFFER_BINDING",                    GL_COPY_WRITE_BUFFER_BINDING,                   GL_COPY_WRITE_BUFFER            }
2999         };
3000         for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(bufferBindingStates); testNdx++)
3001         {
3002                 FOR_EACH_QUERYTYPE(queryTypes, addChild(new BufferBindingTestCase(m_context, queryType, (std::string(bufferBindingStates[testNdx].name) + getQueryTypeSuffix(queryType)).c_str(), bufferBindingStates[testNdx].description, bufferBindingStates[testNdx].target, bufferBindingStates[testNdx].type)));
3003         }
3004
3005         FOR_EACH_QUERYTYPE(queryTypes,     addChild(new ElementArrayBufferBindingTestCase       (m_context, queryType, (std::string("element_array_buffer_binding")     + getQueryTypeSuffix(queryType)).c_str())));
3006         FOR_EACH_QUERYTYPE(queryTypes,     addChild(new TransformFeedbackBindingTestCase        (m_context, queryType, (std::string("transform_feedback_binding")       + getQueryTypeSuffix(queryType)).c_str())));
3007         FOR_EACH_QUERYTYPE(queryTypes,     addChild(new CurrentProgramBindingTestCase           (m_context, queryType, (std::string("current_program_binding")          + getQueryTypeSuffix(queryType)).c_str(),       "CURRENT_PROGRAM")));
3008         FOR_EACH_QUERYTYPE(queryTypes,     addChild(new VertexArrayBindingTestCase                      (m_context, queryType, (std::string("vertex_array_binding")                     + getQueryTypeSuffix(queryType)).c_str(),       "VERTEX_ARRAY_BINDING")));
3009         FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilClearValueTestCase                       (m_context, verifier, (std::string("stencil_clear_value")                       + verifier->getTestNamePostfix()).c_str(),      "STENCIL_CLEAR_VALUE")));
3010         FOR_EACH_VERIFIER(normalVerifiers, addChild(new ActiveTextureTestCase                           (m_context, verifier, (std::string("active_texture")                            + verifier->getTestNamePostfix()).c_str(),      "ACTIVE_TEXTURE")));
3011         FOR_EACH_QUERYTYPE(queryTypes,     addChild(new RenderbufferBindingTestCase                     (m_context, queryType, (std::string("renderbuffer_binding")                     + getQueryTypeSuffix(queryType)).c_str(),       "RENDERBUFFER_BINDING")));
3012         FOR_EACH_QUERYTYPE(queryTypes,     addChild(new SamplerObjectBindingTestCase            (m_context, queryType, (std::string("sampler_binding")                          + getQueryTypeSuffix(queryType)).c_str(),       "SAMPLER_BINDING")));
3013
3014         const struct TextureBinding
3015         {
3016                 const char*     name;
3017                 const char*     description;
3018                 GLenum          target;
3019                 GLenum          type;
3020         } textureBindings[] =
3021         {
3022                 { "texture_binding_2d",                 "TEXTURE_BINDING_2D",           GL_TEXTURE_BINDING_2D,                  GL_TEXTURE_2D           },
3023                 { "texture_binding_3d",                 "TEXTURE_BINDING_3D",           GL_TEXTURE_BINDING_3D,                  GL_TEXTURE_3D           },
3024                 { "texture_binding_2d_array",   "TEXTURE_BINDING_2D_ARRAY",     GL_TEXTURE_BINDING_2D_ARRAY,    GL_TEXTURE_2D_ARRAY     },
3025                 { "texture_binding_cube_map",   "TEXTURE_BINDING_CUBE_MAP",     GL_TEXTURE_BINDING_CUBE_MAP,    GL_TEXTURE_CUBE_MAP     }
3026         };
3027
3028         for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(textureBindings); testNdx++)
3029         {
3030                 FOR_EACH_QUERYTYPE(queryTypes, addChild(new TextureBindingTestCase(m_context, queryType, (std::string(textureBindings[testNdx].name) + getQueryTypeSuffix(queryType)).c_str(), textureBindings[testNdx].description, textureBindings[testNdx].target, textureBindings[testNdx].type)));
3031         }
3032
3033
3034         FOR_EACH_QUERYTYPE(queryTypes,     addChild(new FrameBufferBindingTestCase              (m_context, queryType, (std::string("framebuffer_binding")                      + getQueryTypeSuffix(queryType)).c_str(),       "DRAW_FRAMEBUFFER_BINDING and READ_FRAMEBUFFER_BINDING")));
3035         FOR_EACH_VERIFIER(normalVerifiers, addChild(new ImplementationColorReadTestCase (m_context, verifier, (std::string("implementation_color_read")         + verifier->getTestNamePostfix()).c_str(),      "IMPLEMENTATION_COLOR_READ_TYPE and IMPLEMENTATION_COLOR_READ_FORMAT")));
3036         FOR_EACH_VERIFIER(normalVerifiers, addChild(new ReadBufferCase                                  (m_context, verifier, (std::string("read_buffer")                                       + verifier->getTestNamePostfix()).c_str(),      "READ_BUFFER")));
3037         FOR_EACH_VERIFIER(normalVerifiers, addChild(new DrawBufferCase                                  (m_context, verifier, (std::string("draw_buffer")                                       + verifier->getTestNamePostfix()).c_str(),      "DRAW_BUFFER")));
3038 }
3039
3040 void IntegerStateQueryTests::deinit (void)
3041 {
3042         if (m_verifierBoolean)
3043         {
3044                 delete m_verifierBoolean;
3045                 m_verifierBoolean = DE_NULL;
3046         }
3047         if (m_verifierInteger)
3048         {
3049                 delete m_verifierInteger;
3050                 m_verifierInteger = DE_NULL;
3051         }
3052         if (m_verifierInteger64)
3053         {
3054                 delete m_verifierInteger64;
3055                 m_verifierInteger64 = DE_NULL;
3056         }
3057         if (m_verifierFloat)
3058         {
3059                 delete m_verifierFloat;
3060                 m_verifierFloat = DE_NULL;
3061         }
3062
3063         this->TestCaseGroup::deinit();
3064 }
3065
3066 } // Functional
3067 } // gles3
3068 } // deqp