modules/gles31/functional/es31fIndexedStateQueryTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.1 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2015 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 Indexed state query tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fIndexedStateQueryTests.hpp"
  25 #include "tcuTestLog.hpp"
  26 #include "tcuFormatUtil.hpp"
  27 #include "gluRenderContext.hpp"
  28 #include "gluCallLogWrapper.hpp"
  29 #include "gluStrUtil.hpp"
  30 #include "gluContextInfo.hpp"
  31 #include "gluObjectWrapper.hpp"
  32 #include "glwFunctions.hpp"
  33 #include "glwEnums.hpp"
  34 #include "glsStateQueryUtil.hpp"
  35 #include "deRandom.hpp"
  36 #include "deStringUtil.hpp"
  37
  38 namespace deqp
  39 {
  40 namespace gles31
  41 {
  42 namespace Functional
  43 {
  44 namespace
  45 {
  46
  47 using namespace gls::StateQueryUtil;
  48
  49 static const char* getVerifierSuffix (QueryType type)
  50 {
  51         switch (type)
  52         {
  53                 case QUERY_INDEXED_BOOLEAN:                     return "getbooleani_v";
  54                 case QUERY_INDEXED_INTEGER:                     return "getintegeri_v";
  55                 case QUERY_INDEXED_INTEGER64:           return "getinteger64i_v";
  56                 case QUERY_INDEXED_BOOLEAN_VEC4:        return "getbooleani_v";
  57                 case QUERY_INDEXED_INTEGER_VEC4:        return "getintegeri_v";
  58                 case QUERY_INDEXED_INTEGER64_VEC4:      return "getinteger64i_v";
  59                 case QUERY_INDEXED_ISENABLED:           return "isenabledi";
  60                 default:
  61                         DE_ASSERT(DE_FALSE);
  62                         return DE_NULL;
  63         }
  64 }
  65
  66 void isExtensionSupported (Context& context, std::string extensionName)
  67 {
  68         if (extensionName == "GL_EXT_draw_buffers_indexed" || extensionName == "GL_KHR_blend_equation_advanced")
  69         {
  70                 if (!contextSupports(context.getRenderContext().getType(), glu::ApiType::es(3, 2)) && !context.getContextInfo().isExtensionSupported(extensionName.c_str()))
  71                         TCU_THROW(NotSupportedError, (std::string("Extension ") + extensionName + std::string(" not supported.")).c_str());
  72         }
  73         else if (!context.getContextInfo().isExtensionSupported(extensionName.c_str()))
  74                 TCU_THROW(NotSupportedError, (std::string("Extension ") + extensionName + std::string(" not supported.")).c_str());
  75 }
  76
  77 class SampleMaskCase : public TestCase
  78 {
  79 public:
  80                                                 SampleMaskCase  (Context& context, const char* name, const char* desc, QueryType verifierType);
  81
  82 private:
  83         void                            init                    (void);
  84         IterateResult           iterate                 (void);
  85
  86         const QueryType         m_verifierType;
  87         int                                     m_maxSampleMaskWords;
  88 };
  89
  90 SampleMaskCase::SampleMaskCase (Context& context, const char* name, const char* desc, QueryType verifierType)
  91         : TestCase                              (context, name, desc)
  92         , m_verifierType                (verifierType)
  93         , m_maxSampleMaskWords  (-1)
  94 {
  95 }
  96
  97 void SampleMaskCase::init (void)
  98 {
  99         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 100
 101         gl.getIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &m_maxSampleMaskWords);
 102         GLU_EXPECT_NO_ERROR(gl.getError(), "query sample mask words");
 103
 104         // mask word count ok?
 105         if (m_maxSampleMaskWords <= 0)
 106                 throw tcu::TestError("Minimum value of GL_MAX_SAMPLE_MASK_WORDS is 1. Got " + de::toString(m_maxSampleMaskWords));
 107
 108         m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_SAMPLE_MASK_WORDS = " << m_maxSampleMaskWords << tcu::TestLog::EndMessage;
 109 }
 110
 111 SampleMaskCase::IterateResult SampleMaskCase::iterate (void)
 112 {
 113         glu::CallLogWrapper             gl              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 114         tcu::ResultCollector    result  (m_testCtx.getLog(), " // ERROR: ");
 115
 116         gl.enableLogging(true);
 117
 118         // initial values
 119         {
 120                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "initial", "Initial values");
 121
 122                 for (int ndx = 0; ndx < m_maxSampleMaskWords; ++ndx)
 123                         verifyStateIndexedInteger(result, gl, GL_SAMPLE_MASK_VALUE, ndx, -1, m_verifierType);
 124         }
 125
 126         // fixed values
 127         {
 128                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "fixed", "Fixed values");
 129
 130                 for (int ndx = 0; ndx < m_maxSampleMaskWords; ++ndx)
 131                 {
 132                         gl.glSampleMaski(ndx, 0);
 133                         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glSampleMaski");
 134
 135                         verifyStateIndexedInteger(result, gl, GL_SAMPLE_MASK_VALUE, ndx, 0, m_verifierType);
 136                 }
 137         }
 138
 139         // random masks
 140         {
 141                 const int                                       numRandomTest   = 20;
 142                 const tcu::ScopedLogSection section                     (m_testCtx.getLog(), "random", "Random values");
 143                 de::Random                                      rnd                             (0x4312);
 144
 145                 for (int testNdx = 0; testNdx < numRandomTest; ++testNdx)
 146                 {
 147                         const glw::GLint        maskIndex               = (glw::GLint)(rnd.getUint32() % m_maxSampleMaskWords);
 148                         glw::GLint                      mask                    = (glw::GLint)(rnd.getUint32());
 149
 150                         gl.glSampleMaski(maskIndex, mask);
 151                         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glSampleMaski");
 152
 153                         verifyStateIndexedInteger(result, gl, GL_SAMPLE_MASK_VALUE, maskIndex, mask, m_verifierType);
 154                 }
 155         }
 156
 157         result.setTestContextResult(m_testCtx);
 158         return STOP;
 159 }
 160
 161 class MinValueIndexed3Case : public TestCase
 162 {
 163 public:
 164                                                 MinValueIndexed3Case    (Context& context, const char* name, const char* desc, glw::GLenum target, const tcu::IVec3& ref, QueryType verifierType);
 165
 166 private:
 167         IterateResult           iterate                                 (void);
 168
 169         const glw::GLenum       m_target;
 170         const tcu::IVec3        m_ref;
 171         const QueryType         m_verifierType;
 172 };
 173
 174 MinValueIndexed3Case::MinValueIndexed3Case (Context& context, const char* name, const char* desc, glw::GLenum target, const tcu::IVec3& ref, QueryType verifierType)
 175         : TestCase                              (context, name, desc)
 176         , m_target                              (target)
 177         , m_ref                                 (ref)
 178         , m_verifierType                (verifierType)
 179 {
 180 }
 181
 182 MinValueIndexed3Case::IterateResult MinValueIndexed3Case::iterate (void)
 183 {
 184         glu::CallLogWrapper             gl              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 185         tcu::ResultCollector    result  (m_testCtx.getLog(), " // ERROR: ");
 186
 187         gl.enableLogging(true);
 188
 189         for (int ndx = 0; ndx < 3; ++ndx)
 190         {
 191                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Element", "Element " + de::toString(ndx));
 192
 193                 verifyStateIndexedIntegerMin(result, gl, m_target, ndx, m_ref[ndx], m_verifierType);
 194         }
 195
 196         result.setTestContextResult(m_testCtx);
 197         return STOP;
 198 }
 199
 200 class BufferBindingCase : public TestCase
 201 {
 202 public:
 203                                                 BufferBindingCase       (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType);
 204
 205 private:
 206         IterateResult           iterate                         (void);
 207
 208         const glw::GLenum       m_queryTarget;
 209         const glw::GLenum       m_bufferTarget;
 210         const glw::GLenum       m_numBindingsTarget;
 211         const QueryType         m_verifierType;
 212 };
 213
 214 BufferBindingCase::BufferBindingCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType)
 215         : TestCase                              (context, name, desc)
 216         , m_queryTarget                 (queryTarget)
 217         , m_bufferTarget                (bufferTarget)
 218         , m_numBindingsTarget   (numBindingsTarget)
 219         , m_verifierType                (verifierType)
 220 {
 221 }
 222
 223 BufferBindingCase::IterateResult BufferBindingCase::iterate (void)
 224 {
 225         glu::CallLogWrapper             gl                      (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 226         tcu::ResultCollector    result          (m_testCtx.getLog(), " // ERROR: ");
 227         int                                             maxBindings     = -1;
 228
 229         gl.enableLogging(true);
 230
 231         gl.glGetIntegerv(m_numBindingsTarget, &maxBindings);
 232         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
 233
 234         {
 235                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
 236
 237                 for (int ndx = 0; ndx < maxBindings; ++ndx)
 238                         verifyStateIndexedInteger(result, gl, m_queryTarget, ndx, 0, m_verifierType);
 239         }
 240
 241         {
 242                 const tcu::ScopedLogSection     superSection    (m_testCtx.getLog(), "AfterSetting", "After setting");
 243                 glu::Buffer                                     bufferA                 (m_context.getRenderContext());
 244                 glu::Buffer                                     bufferB                 (m_context.getRenderContext());
 245                 const int                                       ndxA                    = 0;
 246                 const int                                       ndxB                    = maxBindings / 2;
 247
 248                 {
 249                         const tcu::ScopedLogSection section(m_testCtx.getLog(), "Generic", "After setting generic binding point");
 250
 251                         gl.glBindBuffer(m_bufferTarget, *bufferA);
 252                         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glBindBuffer");
 253
 254                         verifyStateIndexedInteger(result, gl, m_queryTarget, 0, 0, m_verifierType);
 255                 }
 256                 {
 257                         const tcu::ScopedLogSection     section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferBase");
 258
 259                         gl.glBindBufferBase(m_bufferTarget, ndxA, *bufferA);
 260                         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glBindBufferBase");
 261
 262                         verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, *bufferA, m_verifierType);
 263                 }
 264                 {
 265                         const tcu::ScopedLogSection     section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferRange");
 266
 267                         gl.glBindBufferRange(m_bufferTarget, ndxB, *bufferB, 0, 8);
 268                         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glBindBufferRange");
 269
 270                         verifyStateIndexedInteger(result, gl, m_queryTarget, ndxB, *bufferB, m_verifierType);
 271                 }
 272                 if (ndxA != ndxB)
 273                 {
 274                         const tcu::ScopedLogSection     section(m_testCtx.getLog(), "DifferentStates", "Original state did not change");
 275
 276                         verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, *bufferA, m_verifierType);
 277                 }
 278         }
 279
 280         result.setTestContextResult(m_testCtx);
 281         return STOP;
 282 }
 283
 284 class BufferStartCase : public TestCase
 285 {
 286 public:
 287                                                 BufferStartCase         (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType);
 288
 289 private:
 290         IterateResult           iterate                         (void);
 291
 292         const glw::GLenum       m_queryTarget;
 293         const glw::GLenum       m_bufferTarget;
 294         const glw::GLenum       m_numBindingsTarget;
 295         const QueryType         m_verifierType;
 296 };
 297
 298 BufferStartCase::BufferStartCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType)
 299         : TestCase                              (context, name, desc)
 300         , m_queryTarget                 (queryTarget)
 301         , m_bufferTarget                (bufferTarget)
 302         , m_numBindingsTarget   (numBindingsTarget)
 303         , m_verifierType                (verifierType)
 304 {
 305 }
 306
 307 BufferStartCase::IterateResult BufferStartCase::iterate (void)
 308 {
 309         glu::CallLogWrapper             gl                      (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 310         tcu::ResultCollector    result          (m_testCtx.getLog(), " // ERROR: ");
 311         int                                             maxBindings     = -1;
 312
 313         gl.enableLogging(true);
 314
 315         gl.glGetIntegerv(m_numBindingsTarget, &maxBindings);
 316         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
 317
 318         {
 319                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
 320
 321                 for (int ndx = 0; ndx < maxBindings; ++ndx)
 322                         verifyStateIndexedInteger(result, gl, m_queryTarget, ndx, 0, m_verifierType);
 323         }
 324
 325
 326         {
 327                 const tcu::ScopedLogSection     superSection    (m_testCtx.getLog(), "AfterSetting", "After setting");
 328                 glu::Buffer                                     bufferA                 (m_context.getRenderContext());
 329                 glu::Buffer                                     bufferB                 (m_context.getRenderContext());
 330                 const int                                       ndxA                    = 0;
 331                 const int                                       ndxB                    = maxBindings / 2;
 332                 int                                                     offset                  = -1;
 333
 334                 if (m_bufferTarget == GL_ATOMIC_COUNTER_BUFFER)
 335                         offset = 4;
 336                 else if (m_bufferTarget == GL_SHADER_STORAGE_BUFFER)
 337                 {
 338                         gl.glGetIntegerv(GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT, &offset);
 339                         GLU_EXPECT_NO_ERROR(gl.glGetError(), "get align");
 340                 }
 341                 else
 342                         DE_ASSERT(false);
 343
 344                 TCU_CHECK(offset >= 0);
 345
 346                 {
 347                         const tcu::ScopedLogSection     section(m_testCtx.getLog(), "Generic", "After setting generic binding point");
 348
 349                         gl.glBindBuffer(m_bufferTarget, *bufferA);
 350                         gl.glBufferData(m_bufferTarget, 16, DE_NULL, GL_DYNAMIC_READ);
 351                         gl.glBindBuffer(m_bufferTarget, *bufferB);
 352                         gl.glBufferData(m_bufferTarget, 32, DE_NULL, GL_DYNAMIC_READ);
 353                         GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen bufs");
 354
 355                         verifyStateIndexedInteger(result, gl, m_queryTarget, 0, 0, m_verifierType);
 356                 }
 357                 {
 358                         const tcu::ScopedLogSection     section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferBase");
 359
 360                         gl.glBindBufferBase(m_bufferTarget, ndxA, *bufferA);
 361                         GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf");
 362
 363                         verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType);
 364                 }
 365                 {
 366                         const tcu::ScopedLogSection     section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferRange");
 367
 368                         gl.glBindBufferRange(m_bufferTarget, ndxB, *bufferB, offset, 8);
 369                         GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf");
 370
 371                         verifyStateIndexedInteger(result, gl, m_queryTarget, ndxB, offset, m_verifierType);
 372                 }
 373                 if (ndxA != ndxB)
 374                 {
 375                         const tcu::ScopedLogSection     section(m_testCtx.getLog(), "DifferentStates", "Original state did not change");
 376
 377                         verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType);
 378                 }
 379         }
 380
 381         result.setTestContextResult(m_testCtx);
 382         return STOP;
 383 }
 384
 385 class BufferSizeCase : public TestCase
 386 {
 387 public:
 388                                                 BufferSizeCase  (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType);
 389
 390 private:
 391         IterateResult           iterate                 (void);
 392
 393         const glw::GLenum       m_queryTarget;
 394         const glw::GLenum       m_bufferTarget;
 395         const glw::GLenum       m_numBindingsTarget;
 396         const QueryType         m_verifierType;
 397 };
 398
 399 BufferSizeCase::BufferSizeCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType)
 400         : TestCase                              (context, name, desc)
 401         , m_queryTarget                 (queryTarget)
 402         , m_bufferTarget                (bufferTarget)
 403         , m_numBindingsTarget   (numBindingsTarget)
 404         , m_verifierType                (verifierType)
 405 {
 406 }
 407
 408 BufferSizeCase::IterateResult BufferSizeCase::iterate (void)
 409 {
 410         glu::CallLogWrapper             gl                      (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 411         tcu::ResultCollector    result          (m_testCtx.getLog(), " // ERROR: ");
 412         int                                             maxBindings     = -1;
 413
 414         gl.enableLogging(true);
 415
 416         gl.glGetIntegerv(m_numBindingsTarget, &maxBindings);
 417         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
 418
 419         {
 420                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
 421
 422                 for (int ndx = 0; ndx < maxBindings; ++ndx)
 423                         verifyStateIndexedInteger(result, gl, m_queryTarget, ndx, 0, m_verifierType);
 424         }
 425
 426         {
 427                 const tcu::ScopedLogSection     superSection    (m_testCtx.getLog(), "AfterSetting", "After setting");
 428                 glu::Buffer                                     bufferA                 (m_context.getRenderContext());
 429                 glu::Buffer                                     bufferB                 (m_context.getRenderContext());
 430                 const int                                       ndxA                    = 0;
 431                 const int                                       ndxB                    = maxBindings / 2;
 432
 433                 {
 434                         const tcu::ScopedLogSection     section(m_testCtx.getLog(), "Generic", "After setting generic binding point");
 435
 436                         gl.glBindBuffer(m_bufferTarget, *bufferA);
 437                         gl.glBufferData(m_bufferTarget, 16, DE_NULL, GL_DYNAMIC_READ);
 438                         gl.glBindBuffer(m_bufferTarget, *bufferB);
 439                         gl.glBufferData(m_bufferTarget, 32, DE_NULL, GL_DYNAMIC_READ);
 440                         GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen bufs");
 441
 442                         verifyStateIndexedInteger(result, gl, m_queryTarget, 0, 0, m_verifierType);
 443                 }
 444                 {
 445                         const tcu::ScopedLogSection     section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferBase");
 446
 447                         gl.glBindBufferBase(m_bufferTarget, ndxA, *bufferA);
 448                         GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf");
 449
 450                         verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType);
 451                 }
 452                 {
 453                         const tcu::ScopedLogSection     section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferRange");
 454
 455                         gl.glBindBufferRange(m_bufferTarget, ndxB, *bufferB, 0, 8);
 456                         GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf");
 457
 458                         verifyStateIndexedInteger(result, gl, m_queryTarget, ndxB, 8, m_verifierType);
 459                 }
 460                 if (ndxA != ndxB)
 461                 {
 462                         const tcu::ScopedLogSection     section(m_testCtx.getLog(), "DifferentStates", "Original state did not change");
 463
 464                         verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType);
 465                 }
 466         }
 467
 468         result.setTestContextResult(m_testCtx);
 469         return STOP;
 470 }
 471
 472 class ImageBindingNameCase : public TestCase
 473 {
 474 public:
 475                                                 ImageBindingNameCase    (Context& context, const char* name, const char* desc, QueryType verifierType);
 476
 477 private:
 478         IterateResult           iterate                                 (void);
 479
 480         const QueryType         m_verifierType;
 481 };
 482
 483 ImageBindingNameCase::ImageBindingNameCase (Context& context, const char* name, const char* desc, QueryType verifierType)
 484         : TestCase                      (context, name, desc)
 485         , m_verifierType        (verifierType)
 486 {
 487 }
 488
 489 ImageBindingNameCase::IterateResult ImageBindingNameCase::iterate (void)
 490 {
 491         glu::CallLogWrapper             gl                      (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 492         tcu::ResultCollector    result          (m_testCtx.getLog(), " // ERROR: ");
 493         int                                             maxImages       = -1;
 494
 495         gl.enableLogging(true);
 496
 497         gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
 498         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
 499
 500         {
 501                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
 502
 503                 for (int ndx = 0; ndx < maxImages; ++ndx)
 504                         verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_NAME, ndx, 0, m_verifierType);
 505         }
 506
 507         {
 508                 const tcu::ScopedLogSection     superSection    (m_testCtx.getLog(), "AfterSetting", "After setting");
 509                 glu::Texture                            textureA                (m_context.getRenderContext());
 510                 glu::Texture                            textureB                (m_context.getRenderContext());
 511                 const int                                       ndxA                    = 0;
 512                 const int                                       ndxB                    = maxImages / 2;
 513
 514                 gl.glBindTexture(GL_TEXTURE_2D, *textureA);
 515                 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
 516                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
 517
 518                 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
 519                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
 520
 521                 gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
 522                 gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4);
 523                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
 524
 525                 gl.glBindImageTexture(ndxB, *textureB, 0, GL_FALSE, 2, GL_READ_ONLY, GL_RGBA8UI);
 526                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
 527
 528                 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_NAME, ndxA, *textureA, m_verifierType);
 529                 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_NAME, ndxB, *textureB, m_verifierType);
 530         }
 531
 532         result.setTestContextResult(m_testCtx);
 533         return STOP;
 534 }
 535
 536 class ImageBindingLevelCase : public TestCase
 537 {
 538 public:
 539                                                 ImageBindingLevelCase   (Context& context, const char* name, const char* desc, QueryType verifierType);
 540
 541 private:
 542         IterateResult           iterate                                 (void);
 543
 544         const QueryType         m_verifierType;
 545 };
 546
 547 ImageBindingLevelCase::ImageBindingLevelCase (Context& context, const char* name, const char* desc, QueryType verifierType)
 548         : TestCase                      (context, name, desc)
 549         , m_verifierType        (verifierType)
 550 {
 551 }
 552
 553 ImageBindingLevelCase::IterateResult ImageBindingLevelCase::iterate (void)
 554 {
 555         glu::CallLogWrapper             gl                      (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 556         tcu::ResultCollector    result          (m_testCtx.getLog(), " // ERROR: ");
 557         int                                             maxImages       = -1;
 558
 559         gl.enableLogging(true);
 560
 561         gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
 562         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
 563
 564         {
 565                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
 566
 567                 for (int ndx = 0; ndx < maxImages; ++ndx)
 568                         verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LEVEL, ndx, 0, m_verifierType);
 569         }
 570
 571         {
 572                 const tcu::ScopedLogSection     superSection    (m_testCtx.getLog(), "AfterSetting", "After setting");
 573                 glu::Texture                            textureA                (m_context.getRenderContext());
 574                 glu::Texture                            textureB                (m_context.getRenderContext());
 575                 const int                                       ndxA                    = 0;
 576                 const int                                       ndxB                    = maxImages / 2;
 577
 578                 gl.glBindTexture(GL_TEXTURE_2D, *textureA);
 579                 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
 580                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
 581
 582                 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
 583                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
 584
 585                 gl.glBindTexture(GL_TEXTURE_2D, *textureB);
 586                 gl.glTexStorage2D(GL_TEXTURE_2D, 3, GL_RGBA8, 32, 32);
 587                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
 588
 589                 gl.glBindImageTexture(ndxB, *textureB, 2, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
 590                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
 591
 592                 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LEVEL, ndxA, 0, m_verifierType);
 593                 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LEVEL, ndxB, 2, m_verifierType);
 594         }
 595
 596         result.setTestContextResult(m_testCtx);
 597         return STOP;
 598 }
 599
 600 class ImageBindingLayeredCase : public TestCase
 601 {
 602 public:
 603                                                 ImageBindingLayeredCase (Context& context, const char* name, const char* desc, QueryType verifierType);
 604
 605 private:
 606         IterateResult           iterate                                 (void);
 607
 608         const QueryType         m_verifierType;
 609 };
 610
 611 ImageBindingLayeredCase::ImageBindingLayeredCase (Context& context, const char* name, const char* desc, QueryType verifierType)
 612         : TestCase                      (context, name, desc)
 613         , m_verifierType        (verifierType)
 614 {
 615 }
 616
 617 ImageBindingLayeredCase::IterateResult ImageBindingLayeredCase::iterate (void)
 618 {
 619         glu::CallLogWrapper             gl                      (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 620         tcu::ResultCollector    result          (m_testCtx.getLog(), " // ERROR: ");
 621         int                                             maxImages       = -1;
 622
 623         gl.enableLogging(true);
 624
 625         gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
 626         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
 627
 628         {
 629                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
 630
 631                 for (int ndx = 0; ndx < maxImages; ++ndx)
 632                         verifyStateIndexedBoolean(result, gl, GL_IMAGE_BINDING_LAYERED, ndx, false, m_verifierType);
 633         }
 634
 635         {
 636                 const tcu::ScopedLogSection     superSection    (m_testCtx.getLog(), "AfterSetting", "After setting");
 637                 glu::Texture                            textureA                (m_context.getRenderContext());
 638                 glu::Texture                            textureB                (m_context.getRenderContext());
 639                 const int                                       ndxA                    = 0;
 640                 const int                                       ndxB                    = maxImages / 2;
 641
 642                 gl.glBindTexture(GL_TEXTURE_2D, *textureA);
 643                 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
 644                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
 645
 646                 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
 647                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
 648
 649                 gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
 650                 gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4);
 651                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
 652
 653                 gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_ONLY, GL_RGBA8UI);
 654                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
 655
 656                 verifyStateIndexedBoolean(result, gl, GL_IMAGE_BINDING_LAYERED, ndxA, false, m_verifierType);
 657                 verifyStateIndexedBoolean(result, gl, GL_IMAGE_BINDING_LAYERED, ndxB, true, m_verifierType);
 658         }
 659
 660         result.setTestContextResult(m_testCtx);
 661         return STOP;
 662 }
 663
 664 class ImageBindingLayerCase : public TestCase
 665 {
 666 public:
 667                                                 ImageBindingLayerCase   (Context& context, const char* name, const char* desc, QueryType verifierType);
 668
 669 private:
 670         IterateResult           iterate                                 (void);
 671
 672         const QueryType         m_verifierType;
 673 };
 674
 675 ImageBindingLayerCase::ImageBindingLayerCase (Context& context, const char* name, const char* desc, QueryType verifierType)
 676         : TestCase                      (context, name, desc)
 677         , m_verifierType        (verifierType)
 678 {
 679 }
 680
 681 ImageBindingLayerCase::IterateResult ImageBindingLayerCase::iterate (void)
 682 {
 683         glu::CallLogWrapper             gl                      (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 684         tcu::ResultCollector    result          (m_testCtx.getLog(), " // ERROR: ");
 685         int                                             maxImages       = -1;
 686
 687         gl.enableLogging(true);
 688
 689         gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
 690         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
 691
 692         {
 693                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
 694
 695                 for (int ndx = 0; ndx < maxImages; ++ndx)
 696                         verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LAYER, ndx, 0, m_verifierType);
 697         }
 698
 699         {
 700                 const tcu::ScopedLogSection     superSection    (m_testCtx.getLog(), "AfterSetting", "After setting");
 701                 glu::Texture                            textureA                (m_context.getRenderContext());
 702                 glu::Texture                            textureB                (m_context.getRenderContext());
 703                 const int                                       ndxA                    = 0;
 704                 const int                                       ndxB                    = maxImages / 2;
 705
 706                 gl.glBindTexture(GL_TEXTURE_2D, *textureA);
 707                 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
 708                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
 709
 710                 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
 711                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
 712
 713                 gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
 714                 gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4);
 715                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
 716
 717                 gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_ONLY, GL_RGBA8UI);
 718                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
 719
 720                 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LAYER, ndxA, 0, m_verifierType);
 721                 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LAYER, ndxB, 2, m_verifierType);
 722         }
 723
 724         result.setTestContextResult(m_testCtx);
 725         return STOP;
 726 }
 727
 728 class ImageBindingAccessCase : public TestCase
 729 {
 730 public:
 731                                                 ImageBindingAccessCase  (Context& context, const char* name, const char* desc, QueryType verifierType);
 732
 733 private:
 734         IterateResult           iterate                                 (void);
 735
 736         const QueryType         m_verifierType;
 737 };
 738
 739 ImageBindingAccessCase::ImageBindingAccessCase (Context& context, const char* name, const char* desc, QueryType verifierType)
 740         : TestCase                      (context, name, desc)
 741         , m_verifierType        (verifierType)
 742 {
 743 }
 744
 745 ImageBindingAccessCase::IterateResult ImageBindingAccessCase::iterate (void)
 746 {
 747         glu::CallLogWrapper             gl                      (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 748         tcu::ResultCollector    result          (m_testCtx.getLog(), " // ERROR: ");
 749         int                                             maxImages       = -1;
 750
 751         gl.enableLogging(true);
 752
 753         gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
 754         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
 755
 756         {
 757                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
 758
 759                 for (int ndx = 0; ndx < maxImages; ++ndx)
 760                         verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_ACCESS, ndx, GL_READ_ONLY, m_verifierType);
 761         }
 762
 763         {
 764                 const tcu::ScopedLogSection     superSection    (m_testCtx.getLog(), "AfterSetting", "After setting");
 765                 glu::Texture                            textureA                (m_context.getRenderContext());
 766                 glu::Texture                            textureB                (m_context.getRenderContext());
 767                 const int                                       ndxA                    = 0;
 768                 const int                                       ndxB                    = maxImages / 2;
 769
 770                 gl.glBindTexture(GL_TEXTURE_2D, *textureA);
 771                 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
 772                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
 773
 774                 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
 775                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
 776
 777                 gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
 778                 gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4);
 779                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
 780
 781                 gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_WRITE, GL_RGBA8UI);
 782                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
 783
 784                 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_ACCESS, ndxA, GL_READ_ONLY, m_verifierType);
 785                 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_ACCESS, ndxB, GL_READ_WRITE, m_verifierType);
 786         }
 787
 788         result.setTestContextResult(m_testCtx);
 789         return STOP;
 790 }
 791
 792 class ImageBindingFormatCase : public TestCase
 793 {
 794 public:
 795                                                 ImageBindingFormatCase  (Context& context, const char* name, const char* desc, QueryType verifierType);
 796
 797 private:
 798         IterateResult           iterate                                 (void);
 799
 800         const QueryType         m_verifierType;
 801 };
 802
 803 ImageBindingFormatCase::ImageBindingFormatCase (Context& context, const char* name, const char* desc, QueryType verifierType)
 804         : TestCase                      (context, name, desc)
 805         , m_verifierType        (verifierType)
 806 {
 807 }
 808
 809 ImageBindingFormatCase::IterateResult ImageBindingFormatCase::iterate (void)
 810 {
 811         glu::CallLogWrapper             gl                      (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 812         tcu::ResultCollector    result          (m_testCtx.getLog(), " // ERROR: ");
 813         int                                             maxImages       = -1;
 814
 815         gl.enableLogging(true);
 816
 817         gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
 818         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
 819
 820         {
 821                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
 822
 823                 for (int ndx = 0; ndx < maxImages; ++ndx)
 824                         verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_FORMAT, ndx, GL_R32UI, m_verifierType);
 825         }
 826
 827         {
 828                 const tcu::ScopedLogSection     superSection    (m_testCtx.getLog(), "AfterSetting", "After setting");
 829                 glu::Texture                            textureA                (m_context.getRenderContext());
 830                 glu::Texture                            textureB                (m_context.getRenderContext());
 831                 const int                                       ndxA                    = 0;
 832                 const int                                       ndxB                    = maxImages / 2;
 833
 834                 gl.glBindTexture(GL_TEXTURE_2D, *textureA);
 835                 gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
 836                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
 837
 838                 gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
 839                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
 840
 841                 gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
 842                 gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_R32F, 32, 32, 4);
 843                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
 844
 845                 gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_WRITE, GL_R32F);
 846                 GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
 847
 848                 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_FORMAT, ndxA, GL_RGBA8UI, m_verifierType);
 849                 verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_FORMAT, ndxB, GL_R32F, m_verifierType);
 850         }
 851
 852         result.setTestContextResult(m_testCtx);
 853         return STOP;
 854 }
 855
 856 class EnableBlendCase : public TestCase
 857 {
 858 public:
 859                                                 EnableBlendCase (Context& context, const char* name, const char* desc, QueryType verifierType);
 860
 861         void                            init                    (void);
 862 private:
 863         IterateResult           iterate                 (void);
 864
 865         const QueryType         m_verifierType;
 866 };
 867
 868 EnableBlendCase::EnableBlendCase (Context& context, const char* name, const char* desc, QueryType verifierType)
 869         : TestCase                      (context, name, desc)
 870         , m_verifierType        (verifierType)
 871 {
 872 }
 873
 874 void EnableBlendCase::init (void)
 875 {
 876         isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
 877 }
 878
 879 EnableBlendCase::IterateResult EnableBlendCase::iterate (void)
 880 {
 881         glu::CallLogWrapper             gl                              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 882         tcu::ResultCollector    result                  (m_testCtx.getLog(), " // ERROR: ");
 883         deInt32                                 maxDrawBuffers = 0;
 884
 885         gl.enableLogging(true);
 886
 887         gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
 888         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
 889
 890         {
 891                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
 892
 893                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
 894                         verifyStateIndexedBoolean(result, gl, GL_BLEND, ndx, false, m_verifierType);
 895         }
 896         {
 897                 const tcu::ScopedLogSection     superSection    (m_testCtx.getLog(), "AfterSettingCommon", "After setting common");
 898
 899                 gl.glEnable(GL_BLEND);
 900
 901                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
 902                         verifyStateIndexedBoolean(result, gl, GL_BLEND, ndx, true, m_verifierType);
 903
 904         }
 905         {
 906                 const tcu::ScopedLogSection     superSection    (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");
 907
 908                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
 909                 {
 910                         if (ndx % 2 == 0)
 911                                 gl.glEnablei(GL_BLEND, ndx);
 912                         else
 913                                 gl.glDisablei(GL_BLEND, ndx);
 914                 }
 915
 916                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
 917                         verifyStateIndexedBoolean(result, gl, GL_BLEND, ndx, (ndx % 2 == 0), m_verifierType);
 918         }
 919         {
 920                 const tcu::ScopedLogSection     superSection    (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common");
 921
 922                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
 923                 {
 924                         if (ndx % 2 == 0)
 925                                 gl.glEnablei(GL_BLEND, ndx);
 926                         else
 927                                 gl.glDisablei(GL_BLEND, ndx);
 928                 }
 929
 930                 gl.glEnable(GL_BLEND);
 931
 932                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
 933                         verifyStateIndexedBoolean(result, gl, GL_BLEND, ndx, true, m_verifierType);
 934         }
 935
 936         result.setTestContextResult(m_testCtx);
 937         return STOP;
 938 }
 939
 940 class ColorMaskCase : public TestCase
 941 {
 942 public:
 943                                                 ColorMaskCase   (Context& context, const char* name, const char* desc, QueryType verifierType);
 944
 945         void                            init                    (void);
 946 private:
 947         IterateResult           iterate                 (void);
 948
 949         const QueryType         m_verifierType;
 950 };
 951
 952 ColorMaskCase::ColorMaskCase (Context& context, const char* name, const char* desc, QueryType verifierType)
 953         : TestCase                      (context, name, desc)
 954         , m_verifierType        (verifierType)
 955 {
 956 }
 957
 958 void ColorMaskCase::init (void)
 959 {
 960         isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
 961 }
 962
 963 ColorMaskCase::IterateResult ColorMaskCase::iterate (void)
 964 {
 965         glu::CallLogWrapper             gl                              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 966         tcu::ResultCollector    result                  (m_testCtx.getLog(), " // ERROR: ");
 967         deInt32                                 maxDrawBuffers = 0;
 968
 969         gl.enableLogging(true);
 970
 971         gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
 972         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
 973
 974         {
 975                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
 976
 977                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
 978                         verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, tcu::BVec4(true), m_verifierType);
 979         }
 980         {
 981                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommon", "After setting common");
 982
 983                 gl.glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_FALSE);
 984
 985                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
 986                         verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, tcu::BVec4(false, true, true, false), m_verifierType);
 987         }
 988         {
 989                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");
 990
 991                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
 992                         gl.glColorMaski(ndx, (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE), (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE));
 993
 994                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
 995                         verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, (ndx % 2 == 0 ? tcu::BVec4(true, false, true, false) : tcu::BVec4(false, true, false, true)), m_verifierType);
 996         }
 997         {
 998                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common");
 999
1000                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1001                         gl.glColorMaski(ndx, (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE), (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE));
1002
1003                 gl.glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_FALSE);
1004
1005                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1006                         verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, tcu::BVec4(false, true, true, false), m_verifierType);
1007         }
1008
1009         result.setTestContextResult(m_testCtx);
1010         return STOP;
1011 }
1012
1013 class BlendFuncCase : public TestCase
1014 {
1015 public:
1016                                                 BlendFuncCase   (Context& context, const char* name, const char* desc, QueryType verifierType);
1017
1018         void                            init                    (void);
1019 private:
1020         IterateResult           iterate                 (void);
1021
1022         const QueryType         m_verifierType;
1023 };
1024
1025 BlendFuncCase::BlendFuncCase (Context& context, const char* name, const char* desc, QueryType verifierType)
1026         : TestCase                      (context, name, desc)
1027         , m_verifierType        (verifierType)
1028 {
1029 }
1030
1031 void BlendFuncCase::init (void)
1032 {
1033         isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
1034 }
1035
1036 BlendFuncCase::IterateResult BlendFuncCase::iterate (void)
1037 {
1038         const deUint32 blendFuncs[] =
1039         {
1040                 GL_ZERO,
1041                 GL_ONE,
1042                 GL_SRC_COLOR,
1043                 GL_ONE_MINUS_SRC_COLOR,
1044                 GL_DST_COLOR,
1045                 GL_ONE_MINUS_DST_COLOR,
1046                 GL_SRC_ALPHA,
1047                 GL_ONE_MINUS_SRC_ALPHA,
1048                 GL_DST_ALPHA,
1049                 GL_ONE_MINUS_DST_ALPHA,
1050                 GL_CONSTANT_COLOR,
1051                 GL_ONE_MINUS_CONSTANT_COLOR,
1052                 GL_CONSTANT_ALPHA,
1053                 GL_ONE_MINUS_CONSTANT_ALPHA,
1054                 GL_SRC_ALPHA_SATURATE
1055         };
1056
1057         glu::CallLogWrapper             gl                              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
1058         tcu::ResultCollector    result                  (m_testCtx.getLog(), " // ERROR: ");
1059         deInt32                                 maxDrawBuffers = 0;
1060
1061         gl.enableLogging(true);
1062
1063         gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
1064         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
1065
1066         {
1067                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
1068
1069                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1070                         verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_ONE, m_verifierType);
1071
1072                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1073                         verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_ZERO, m_verifierType);
1074
1075                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1076                         verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_ONE, m_verifierType);
1077
1078                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1079                         verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_ZERO, m_verifierType);
1080         }
1081         {
1082                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommon", "After setting common");
1083
1084                 gl.glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA);
1085
1086                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1087                         verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_ALPHA, m_verifierType);
1088
1089                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1090                         verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_DST_ALPHA, m_verifierType);
1091
1092                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1093                         verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_SRC_ALPHA, m_verifierType);
1094
1095                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1096                         verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_DST_ALPHA, m_verifierType);
1097         }
1098         {
1099                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommonSeparate", "After setting common separate");
1100
1101                 gl.glBlendFuncSeparate(GL_SRC_COLOR, GL_ONE_MINUS_SRC_ALPHA, GL_DST_COLOR, GL_ONE_MINUS_DST_ALPHA);
1102
1103                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1104                         verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_COLOR, m_verifierType);
1105
1106                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1107                         verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_ONE_MINUS_SRC_ALPHA, m_verifierType);
1108
1109                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1110                         verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_DST_COLOR, m_verifierType);
1111
1112                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1113                         verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_ONE_MINUS_DST_ALPHA, m_verifierType);
1114         }
1115         {
1116                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");
1117
1118                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1119                         gl.glBlendFunci(ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)]);
1120
1121                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1122                         verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
1123
1124                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1125                         verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
1126
1127                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1128                         verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
1129
1130                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1131                         verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
1132         }
1133         {
1134                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexedSeparate", "After setting indexed separate");
1135
1136                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1137                         gl.glBlendFuncSeparatei(ndx, blendFuncs[(ndx + 3) % DE_LENGTH_OF_ARRAY(blendFuncs)],
1138                                                                                  blendFuncs[(ndx + 2) % DE_LENGTH_OF_ARRAY(blendFuncs)],
1139                                                                                  blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)],
1140                                                                                  blendFuncs[(ndx + 0) % DE_LENGTH_OF_ARRAY(blendFuncs)]);
1141
1142                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1143                         verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, blendFuncs[(ndx + 3) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
1144
1145                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1146                         verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, blendFuncs[(ndx + 2) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
1147
1148                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1149                         verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
1150
1151                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1152                         verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, blendFuncs[(ndx + 0) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
1153
1154         }
1155         {
1156                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common");
1157
1158                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1159                         gl.glBlendFunci(ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)]);
1160
1161                 gl.glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA);
1162
1163                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1164                         verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_ALPHA, m_verifierType);
1165
1166                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1167                         verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_DST_ALPHA, m_verifierType);
1168
1169                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1170                         verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_SRC_ALPHA, m_verifierType);
1171
1172                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1173                         verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_DST_ALPHA, m_verifierType);
1174         }
1175         {
1176                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommonSeparate", "After resetting indexed with common separate");
1177
1178                 gl.glBlendFuncSeparate(GL_SRC_COLOR, GL_ONE_MINUS_SRC_ALPHA, GL_DST_COLOR, GL_ONE_MINUS_DST_ALPHA);
1179
1180                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1181                         gl.glBlendFuncSeparatei(ndx, blendFuncs[(ndx + 3) % DE_LENGTH_OF_ARRAY(blendFuncs)],
1182                                                                                  blendFuncs[(ndx + 2) % DE_LENGTH_OF_ARRAY(blendFuncs)],
1183                                                                                  blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)],
1184                                                                                  blendFuncs[(ndx + 0) % DE_LENGTH_OF_ARRAY(blendFuncs)]);
1185
1186                 gl.glBlendFuncSeparate(GL_SRC_COLOR, GL_ONE_MINUS_SRC_ALPHA, GL_DST_COLOR, GL_ONE_MINUS_DST_ALPHA);
1187
1188                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1189                         verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_COLOR, m_verifierType);
1190
1191                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1192                         verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_ONE_MINUS_SRC_ALPHA, m_verifierType);
1193
1194                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1195                         verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_DST_COLOR, m_verifierType);
1196
1197                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1198                         verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_ONE_MINUS_DST_ALPHA, m_verifierType);
1199         }
1200
1201         result.setTestContextResult(m_testCtx);
1202         return STOP;
1203 }
1204
1205 class BlendEquationCase : public TestCase
1206 {
1207 public:
1208                                                 BlendEquationCase       (Context& context, const char* name, const char* desc, QueryType verifierType);
1209
1210         void                            init                            (void);
1211 private:
1212         IterateResult           iterate                         (void);
1213
1214         const QueryType         m_verifierType;
1215 };
1216
1217 BlendEquationCase::BlendEquationCase (Context& context, const char* name, const char* desc, QueryType verifierType)
1218         : TestCase                      (context, name, desc)
1219         , m_verifierType        (verifierType)
1220 {
1221 }
1222
1223 void BlendEquationCase::init (void)
1224 {
1225         isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
1226 }
1227
1228 BlendEquationCase::IterateResult BlendEquationCase::iterate (void)
1229 {
1230         const deUint32 blendEquations[] =
1231         {
1232                 GL_FUNC_ADD,
1233                 GL_FUNC_SUBTRACT,
1234                 GL_FUNC_REVERSE_SUBTRACT,
1235                 GL_MIN,
1236                 GL_MAX
1237         };
1238
1239         glu::CallLogWrapper             gl                              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
1240         tcu::ResultCollector    result                  (m_testCtx.getLog(), " // ERROR: ");
1241         deInt32                                 maxDrawBuffers = 0;
1242
1243         gl.enableLogging(true);
1244
1245         gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
1246         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
1247
1248         {
1249                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
1250
1251                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1252                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_ADD, m_verifierType);
1253
1254                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1255                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_ADD, m_verifierType);
1256         }
1257         {
1258                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommon", "After setting common");
1259
1260                 gl.glBlendEquation(GL_FUNC_SUBTRACT);
1261
1262                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1263                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_SUBTRACT, m_verifierType);
1264
1265                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1266                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType);
1267         }
1268         {
1269                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommonSeparate", "After setting common separate");
1270
1271                 gl.glBlendEquationSeparate(GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_SUBTRACT);
1272
1273                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1274                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_REVERSE_SUBTRACT, m_verifierType);
1275
1276                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1277                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType);
1278         }
1279         {
1280                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");
1281
1282                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1283                         gl.glBlendEquationi(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)]);
1284
1285                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1286                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType);
1287
1288                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1289                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType);
1290         }
1291         {
1292                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexedSeparate", "After setting indexed separate");
1293
1294                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1295                         gl.glBlendEquationSeparatei(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)]);
1296
1297                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1298                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType);
1299
1300                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1301                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType);
1302         }
1303         {
1304                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common");
1305
1306                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1307                         gl.glBlendEquationi(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)]);
1308
1309                 gl.glBlendEquation(GL_FUNC_SUBTRACT);
1310
1311                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1312                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_SUBTRACT, m_verifierType);
1313
1314                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1315                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType);
1316         }
1317         {
1318                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommonSeparate", "After resetting indexed with common separate");
1319
1320                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1321                         gl.glBlendEquationSeparatei(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)]);
1322
1323                 gl.glBlendEquationSeparate(GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_SUBTRACT);
1324
1325                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1326                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_REVERSE_SUBTRACT, m_verifierType);
1327
1328                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1329                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType);
1330         }
1331
1332         result.setTestContextResult(m_testCtx);
1333         return STOP;
1334 }
1335
1336 class BlendEquationAdvancedCase : public TestCase
1337 {
1338 public:
1339                                                 BlendEquationAdvancedCase       (Context& context, const char* name, const char* desc, QueryType verifierType);
1340
1341         void                            init                            (void);
1342 private:
1343         IterateResult           iterate                         (void);
1344
1345         const QueryType         m_verifierType;
1346 };
1347
1348 BlendEquationAdvancedCase::BlendEquationAdvancedCase (Context& context, const char* name, const char* desc, QueryType verifierType)
1349         : TestCase                      (context, name, desc)
1350         , m_verifierType        (verifierType)
1351 {
1352 }
1353
1354 void BlendEquationAdvancedCase::init (void)
1355 {
1356         isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
1357         isExtensionSupported(m_context, "GL_KHR_blend_equation_advanced");
1358 }
1359
1360 BlendEquationAdvancedCase::IterateResult BlendEquationAdvancedCase::iterate (void)
1361 {
1362         const deUint32 blendEquations[] =
1363         {
1364                 GL_FUNC_ADD,
1365                 GL_FUNC_SUBTRACT,
1366                 GL_FUNC_REVERSE_SUBTRACT,
1367                 GL_MIN,
1368                 GL_MAX
1369         };
1370
1371         const deUint32 blendEquationAdvanced[] =
1372         {
1373                 GL_MULTIPLY,
1374                 GL_SCREEN,
1375                 GL_OVERLAY,
1376                 GL_DARKEN,
1377                 GL_LIGHTEN,
1378                 GL_COLORDODGE,
1379                 GL_COLORBURN,
1380                 GL_HARDLIGHT,
1381                 GL_SOFTLIGHT,
1382                 GL_DIFFERENCE,
1383                 GL_EXCLUSION,
1384                 GL_HSL_HUE,
1385                 GL_HSL_SATURATION,
1386                 GL_HSL_COLOR,
1387                 GL_HSL_LUMINOSITY
1388         };
1389
1390         glu::CallLogWrapper             gl                              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
1391         tcu::ResultCollector    result                  (m_testCtx.getLog(), " // ERROR: ");
1392         deInt32                                 maxDrawBuffers = 0;
1393
1394         gl.enableLogging(true);
1395
1396         gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
1397         GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
1398
1399         {
1400                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommon", "After setting common");
1401
1402                 gl.glBlendEquation(GL_SCREEN);
1403
1404                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1405                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_SCREEN, m_verifierType);
1406
1407                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1408                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_SCREEN, m_verifierType);
1409         }
1410         {
1411                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");
1412
1413                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1414                         gl.glBlendEquationi(ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)]);
1415
1416                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1417                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)], m_verifierType);
1418
1419                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1420                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)], m_verifierType);
1421         }
1422         {
1423                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common");
1424
1425                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1426                         gl.glBlendEquationi(ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)]);
1427
1428                 gl.glBlendEquation(GL_MULTIPLY);
1429
1430                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1431                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_MULTIPLY, m_verifierType);
1432
1433                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1434                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_MULTIPLY, m_verifierType);
1435         }
1436         {
1437                 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedSeparateWithCommon", "After resetting indexed separate with common");
1438
1439                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1440                         gl.glBlendEquationSeparatei(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)]);
1441
1442                 gl.glBlendEquation(GL_LIGHTEN);
1443
1444                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1445                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_LIGHTEN, m_verifierType);
1446
1447                 for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
1448                         verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_LIGHTEN, m_verifierType);
1449         }
1450
1451         result.setTestContextResult(m_testCtx);
1452         return STOP;
1453 }
1454
1455 } // anonymous
1456
1457 IndexedStateQueryTests::IndexedStateQueryTests (Context& context)
1458         : TestCaseGroup(context, "indexed", "Indexed state queries")
1459 {
1460 }
1461
1462 IndexedStateQueryTests::~IndexedStateQueryTests (void)
1463 {
1464 }
1465
1466 void IndexedStateQueryTests::init (void)
1467 {
1468         static const QueryType verifiers[] = { QUERY_INDEXED_BOOLEAN, QUERY_INDEXED_INTEGER, QUERY_INDEXED_INTEGER64 };
1469         static const QueryType vec4Verifiers[] = { QUERY_INDEXED_BOOLEAN_VEC4, QUERY_INDEXED_INTEGER_VEC4, QUERY_INDEXED_INTEGER64_VEC4 };
1470
1471 #define FOR_EACH_VERIFIER(X) \
1472         for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx)   \
1473         {                                                                                                                                                                               \
1474                 const QueryType verifier = verifiers[verifierNdx];                                                                      \
1475                 const char* verifierSuffix = getVerifierSuffix(verifier);                                                       \
1476                 this->addChild(X);                                                                                                                                      \
1477         }
1478
1479 #define FOR_EACH_VEC4_VERIFIER(X) \
1480         for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(vec4Verifiers); ++verifierNdx)       \
1481         {                                                                                                                                                                                       \
1482                 const QueryType verifier = vec4Verifiers[verifierNdx];                                                                  \
1483                 const char* verifierSuffix = getVerifierSuffix(verifier);                                                               \
1484                 this->addChild(X);                                                                                                                                              \
1485         }
1486
1487         FOR_EACH_VERIFIER(new SampleMaskCase                    (m_context, (std::string() + "sample_mask_value_" + verifierSuffix).c_str(),                            "Test SAMPLE_MASK_VALUE", verifier))
1488
1489         FOR_EACH_VERIFIER(new MinValueIndexed3Case              (m_context, (std::string() + "max_compute_work_group_count_" + verifierSuffix).c_str(),         "Test MAX_COMPUTE_WORK_GROUP_COUNT",    GL_MAX_COMPUTE_WORK_GROUP_COUNT,        tcu::IVec3(65535,65535,65535),  verifier))
1490         FOR_EACH_VERIFIER(new MinValueIndexed3Case              (m_context, (std::string() + "max_compute_work_group_size_" + verifierSuffix).c_str(),          "Test MAX_COMPUTE_WORK_GROUP_SIZE",             GL_MAX_COMPUTE_WORK_GROUP_SIZE,         tcu::IVec3(128, 128, 64),               verifier))
1491
1492         FOR_EACH_VERIFIER(new BufferBindingCase                 (m_context, (std::string() + "atomic_counter_buffer_binding_" + verifierSuffix).c_str(),        "Test ATOMIC_COUNTER_BUFFER_BINDING",   GL_ATOMIC_COUNTER_BUFFER_BINDING,       GL_ATOMIC_COUNTER_BUFFER,       GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS,  verifier))
1493         FOR_EACH_VERIFIER(new BufferStartCase                   (m_context, (std::string() + "atomic_counter_buffer_start_" + verifierSuffix).c_str(),          "Test ATOMIC_COUNTER_BUFFER_START",             GL_ATOMIC_COUNTER_BUFFER_START,         GL_ATOMIC_COUNTER_BUFFER,       GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS,  verifier))
1494         FOR_EACH_VERIFIER(new BufferSizeCase                    (m_context, (std::string() + "atomic_counter_buffer_size_" + verifierSuffix).c_str(),           "Test ATOMIC_COUNTER_BUFFER_SIZE",              GL_ATOMIC_COUNTER_BUFFER_SIZE,          GL_ATOMIC_COUNTER_BUFFER,       GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS,  verifier))
1495
1496         FOR_EACH_VERIFIER(new BufferBindingCase                 (m_context, (std::string() + "shader_storage_buffer_binding_" + verifierSuffix).c_str(),        "Test SHADER_STORAGE_BUFFER_BINDING",   GL_SHADER_STORAGE_BUFFER_BINDING,       GL_SHADER_STORAGE_BUFFER,       GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS,  verifier))
1497         FOR_EACH_VERIFIER(new BufferStartCase                   (m_context, (std::string() + "shader_storage_buffer_start_" + verifierSuffix).c_str(),          "Test SHADER_STORAGE_BUFFER_START",             GL_SHADER_STORAGE_BUFFER_START,         GL_SHADER_STORAGE_BUFFER,       GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS,  verifier))
1498         FOR_EACH_VERIFIER(new BufferSizeCase                    (m_context, (std::string() + "shader_storage_buffer_size_" + verifierSuffix).c_str(),           "Test SHADER_STORAGE_BUFFER_SIZE",              GL_SHADER_STORAGE_BUFFER_SIZE,          GL_SHADER_STORAGE_BUFFER,       GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS,  verifier))
1499
1500         FOR_EACH_VERIFIER(new ImageBindingNameCase              (m_context, (std::string() + "image_binding_name_" + verifierSuffix).c_str(),                           "Test IMAGE_BINDING_NAME",                              verifier))
1501         FOR_EACH_VERIFIER(new ImageBindingLevelCase             (m_context, (std::string() + "image_binding_level_" + verifierSuffix).c_str(),                          "Test IMAGE_BINDING_LEVEL",                             verifier))
1502         FOR_EACH_VERIFIER(new ImageBindingLayeredCase   (m_context, (std::string() + "image_binding_layered_" + verifierSuffix).c_str(),                        "Test IMAGE_BINDING_LAYERED",                   verifier))
1503         FOR_EACH_VERIFIER(new ImageBindingLayerCase             (m_context, (std::string() + "image_binding_layer_" + verifierSuffix).c_str(),                          "Test IMAGE_BINDING_LAYER",                             verifier))
1504         FOR_EACH_VERIFIER(new ImageBindingAccessCase    (m_context, (std::string() + "image_binding_access_" + verifierSuffix).c_str(),                         "Test IMAGE_BINDING_ACCESS",                    verifier))
1505         FOR_EACH_VERIFIER(new ImageBindingFormatCase    (m_context, (std::string() + "image_binding_format_" + verifierSuffix).c_str(),                         "Test IMAGE_BINDING_FORMAT",                    verifier))
1506
1507         {
1508                 const QueryType verifier = QUERY_INDEXED_ISENABLED;
1509                 const char* verifierSuffix = getVerifierSuffix(verifier);
1510                 this->addChild(new EnableBlendCase                      (m_context, (std::string() + "blend_" + verifierSuffix).c_str(),                                                        "BLEND",                                                                verifier));
1511         }
1512         FOR_EACH_VEC4_VERIFIER(new ColorMaskCase                (m_context, (std::string() + "color_mask_" + verifierSuffix).c_str(),                                           "COLOR_WRITEMASK",                                              verifier))
1513         FOR_EACH_VERIFIER(new BlendFuncCase                             (m_context, (std::string() + "blend_func_" + verifierSuffix).c_str(),                                           "BLEND_SRC and BLEND_DST",                              verifier))
1514         FOR_EACH_VERIFIER(new BlendEquationCase                 (m_context, (std::string() + "blend_equation_" + verifierSuffix).c_str(),                                       "BLEND_EQUATION_RGB and BLEND_DST",             verifier))
1515         FOR_EACH_VERIFIER(new BlendEquationAdvancedCase (m_context, (std::string() + "blend_equation_advanced_" + verifierSuffix).c_str(),                      "BLEND_EQUATION_RGB and BLEND_DST",             verifier))
1516
1517 #undef FOR_EACH_VEC4_VERIFIER
1518 #undef FOR_EACH_VERIFIER
1519 }
1520
1521 } // Functional
1522 } // gles31
1523 } // deqp