modules/gles31/functional/es31fIntegerStateQueryTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.1 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 Integer state query tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fIntegerStateQueryTests.hpp"
  25 #include "tcuTestLog.hpp"
  26 #include "gluRenderContext.hpp"
  27 #include "gluCallLogWrapper.hpp"
  28 #include "gluContextInfo.hpp"
  29 #include "gluObjectWrapper.hpp"
  30 #include "gluShaderProgram.hpp"
  31 #include "gluStrUtil.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 const int MAX_FRAG_ATOMIC_COUNTER_BUFFERS_GLES32        = 1;
  50 const int MAX_FRAG_ATOMIC_COUNTERS_GLES32                       = 8;
  51 const int MAX_FRAG_SHADER_STORAGE_BLOCKS_GLES32         = 4;
  52
  53 static const char* getVerifierSuffix (QueryType type)
  54 {
  55         switch (type)
  56         {
  57                 case QUERY_BOOLEAN:             return "getboolean";
  58                 case QUERY_INTEGER:             return "getinteger";
  59                 case QUERY_INTEGER64:   return "getinteger64";
  60                 case QUERY_FLOAT:               return "getfloat";
  61                 default:
  62                         DE_ASSERT(DE_FALSE);
  63                         return DE_NULL;
  64         }
  65 }
  66
  67 class MaxSamplesCase : public TestCase
  68 {
  69 public:
  70                                                 MaxSamplesCase  (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, QueryType verifierType);
  71 private:
  72         IterateResult           iterate                 (void);
  73
  74         const glw::GLenum       m_target;
  75         const int                       m_minValue;
  76         const QueryType         m_verifierType;
  77 };
  78
  79 MaxSamplesCase::MaxSamplesCase (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, QueryType verifierType)
  80         : TestCase                      (context, name, desc)
  81         , m_target                      (target)
  82         , m_minValue            (minValue)
  83         , m_verifierType        (verifierType)
  84 {
  85 }
  86
  87 MaxSamplesCase::IterateResult MaxSamplesCase::iterate (void)
  88 {
  89         glu::CallLogWrapper             gl              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
  90         tcu::ResultCollector    result  (m_testCtx.getLog(), " // ERROR: ");
  91
  92         gl.enableLogging(true);
  93         verifyStateIntegerMin(result, gl, m_target, m_minValue, m_verifierType);
  94
  95         result.setTestContextResult(m_testCtx);
  96         return STOP;
  97 }
  98
  99 class TexBindingCase : public TestCase
 100 {
 101 public:
 102                                                 TexBindingCase  (Context& context, const char* name, const char* desc, glw::GLenum texTarget, glw::GLenum bindTarget, QueryType verifierType);
 103 private:
 104         void                            init                    (void);
 105         IterateResult           iterate                 (void);
 106
 107         const glw::GLenum       m_texTarget;
 108         const glw::GLenum       m_bindTarget;
 109         const QueryType         m_verifierType;
 110 };
 111
 112 TexBindingCase::TexBindingCase (Context& context, const char* name, const char* desc, glw::GLenum texTarget, glw::GLenum bindTarget, QueryType verifierType)
 113         : TestCase                      (context, name, desc)
 114         , m_texTarget           (texTarget)
 115         , m_bindTarget          (bindTarget)
 116         , m_verifierType        (verifierType)
 117 {
 118 }
 119
 120 void TexBindingCase::init (void)
 121 {
 122         if (contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)))
 123                 return;
 124
 125         if (m_texTarget == GL_TEXTURE_2D_MULTISAMPLE_ARRAY && !m_context.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
 126                 throw tcu::NotSupportedError("Test requires OES_texture_storage_multisample_2d_array extension");
 127         if (m_texTarget == GL_TEXTURE_CUBE_MAP_ARRAY && !m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_cube_map_array"))
 128                 throw tcu::NotSupportedError("Test requires GL_EXT_texture_cube_map_array extension");
 129         if (m_texTarget == GL_TEXTURE_BUFFER && !m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_buffer"))
 130                 throw tcu::NotSupportedError("Test requires GL_EXT_texture_buffer extension");
 131 }
 132
 133 TexBindingCase::IterateResult TexBindingCase::iterate (void)
 134 {
 135         glu::CallLogWrapper             gl              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 136         tcu::ResultCollector    result  (m_testCtx.getLog(), " // ERROR: ");
 137
 138         gl.enableLogging(true);
 139
 140         // initial
 141         {
 142                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "initial", "Initial value");
 143
 144                 verifyStateInteger(result, gl, m_bindTarget, 0, m_verifierType);
 145         }
 146
 147         // bind
 148         {
 149                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "bind", "After bind");
 150
 151                 glw::GLuint texture;
 152
 153                 gl.glGenTextures(1, &texture);
 154                 gl.glBindTexture(m_texTarget, texture);
 155                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind texture");
 156
 157                 verifyStateInteger(result, gl, m_bindTarget, texture, m_verifierType);
 158
 159                 gl.glDeleteTextures(1, &texture);
 160         }
 161
 162         // after delete
 163         {
 164                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "bind", "After delete");
 165
 166                 verifyStateInteger(result, gl, m_bindTarget, 0, m_verifierType);
 167         }
 168
 169         result.setTestContextResult(m_testCtx);
 170         return STOP;
 171 }
 172
 173 class MinimumValueCase : public TestCase
 174 {
 175 public:
 176                                                 MinimumValueCase        (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, QueryType verifierType);
 177                                                 MinimumValueCase        (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, QueryType verifierType, glu::ApiType minVersion);
 178 private:
 179         IterateResult           iterate                         (void);
 180
 181         const glw::GLenum       m_target;
 182         const int                       m_minValue;
 183         const QueryType         m_verifierType;
 184         const glu::ApiType      m_minimumVersion;
 185 };
 186
 187 MinimumValueCase::MinimumValueCase (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, QueryType verifierType)
 188         : TestCase                      (context, name, desc)
 189         , m_target                      (target)
 190         , m_minValue            (minValue)
 191         , m_verifierType        (verifierType)
 192         , m_minimumVersion      (glu::ApiType::es(3, 1))
 193 {
 194 }
 195
 196 MinimumValueCase::MinimumValueCase (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, QueryType verifierType, glu::ApiType minVersion)
 197         : TestCase                      (context, name, desc)
 198         , m_target                      (target)
 199         , m_minValue            (minValue)
 200         , m_verifierType        (verifierType)
 201         , m_minimumVersion      (minVersion)
 202 {
 203 }
 204
 205 MinimumValueCase::IterateResult MinimumValueCase::iterate (void)
 206 {
 207         TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(m_context.getRenderContext().getType(), m_minimumVersion), "Test not supported in this context version.");
 208
 209         glu::CallLogWrapper             gl              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 210         tcu::ResultCollector    result  (m_testCtx.getLog(), " // ERROR: ");
 211
 212         // \note: In GL ES 3.2, the following targets have different limits as in 3.1
 213         const int                               value   = contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2))
 214                                                                         ? (m_target == GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS   ? MAX_FRAG_ATOMIC_COUNTER_BUFFERS_GLES32        // 1
 215                                                                         : m_target == GL_MAX_FRAGMENT_ATOMIC_COUNTERS                   ? MAX_FRAG_ATOMIC_COUNTERS_GLES32                       // 8
 216                                                                         : m_target == GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS             ? MAX_FRAG_SHADER_STORAGE_BLOCKS_GLES32         // 4
 217                                                                         : m_minValue)
 218                                                                         : m_minValue;
 219
 220         gl.enableLogging(true);
 221         verifyStateIntegerMin(result, gl, m_target, value, m_verifierType);
 222
 223         result.setTestContextResult(m_testCtx);
 224         return STOP;
 225 }
 226
 227 class AlignmentCase : public TestCase
 228 {
 229 public:
 230                                                 AlignmentCase   (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, QueryType verifierType);
 231                                                 AlignmentCase   (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, QueryType verifierType, glu::ApiType minVersion);
 232 private:
 233         IterateResult           iterate                 (void);
 234
 235         const glw::GLenum       m_target;
 236         const int                       m_minValue;
 237         const QueryType         m_verifierType;
 238         const glu::ApiType      m_minimumVersion;
 239 };
 240
 241 AlignmentCase::AlignmentCase (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, QueryType verifierType)
 242         : TestCase                      (context, name, desc)
 243         , m_target                      (target)
 244         , m_minValue            (minValue)
 245         , m_verifierType        (verifierType)
 246         , m_minimumVersion      (glu::ApiType::es(3, 1))
 247 {
 248 }
 249
 250 AlignmentCase::AlignmentCase (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, QueryType verifierType, glu::ApiType minVersion)
 251         : TestCase                      (context, name, desc)
 252         , m_target                      (target)
 253         , m_minValue            (minValue)
 254         , m_verifierType        (verifierType)
 255         , m_minimumVersion      (minVersion)
 256 {
 257 }
 258
 259 AlignmentCase::IterateResult AlignmentCase::iterate (void)
 260 {
 261         TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(m_context.getRenderContext().getType(), m_minimumVersion), "Test not supported in this context.");
 262
 263         glu::CallLogWrapper             gl              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 264         tcu::ResultCollector    result  (m_testCtx.getLog(), " // ERROR: ");
 265
 266         gl.enableLogging(true);
 267         verifyStateIntegerMax(result, gl, m_target, m_minValue, m_verifierType);
 268
 269         result.setTestContextResult(m_testCtx);
 270         return STOP;
 271 }
 272
 273 class BufferBindingCase : public TestCase
 274 {
 275 public:
 276                                                 BufferBindingCase       (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bindingPoint, QueryType verifierType);
 277 private:
 278         IterateResult           iterate                         (void);
 279
 280         const glw::GLenum       m_queryTarget;
 281         const glw::GLenum       m_bindingPoint;
 282         const QueryType         m_verifierType;
 283 };
 284
 285 BufferBindingCase::BufferBindingCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bindingPoint, QueryType verifierType)
 286         : TestCase                      (context, name, desc)
 287         , m_queryTarget         (queryTarget)
 288         , m_bindingPoint        (bindingPoint)
 289         , m_verifierType        (verifierType)
 290 {
 291 }
 292
 293 BufferBindingCase::IterateResult BufferBindingCase::iterate (void)
 294 {
 295         glu::CallLogWrapper             gl              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 296         tcu::ResultCollector    result  (m_testCtx.getLog(), " // ERROR: ");
 297
 298         gl.enableLogging(true);
 299
 300         {
 301                 const tcu::ScopedLogSection     section(m_testCtx.getLog(), "Initial", "Initial value");
 302
 303                 verifyStateInteger(result, gl, m_queryTarget, 0, m_verifierType);
 304         }
 305
 306         {
 307                 const tcu::ScopedLogSection     section (m_testCtx.getLog(), "AfterBinding", "After binding");
 308                 glu::Buffer                                     buf             (m_context.getRenderContext());
 309
 310                 gl.glBindBuffer(m_bindingPoint, *buf);
 311                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "setup");
 312
 313                 verifyStateInteger(result, gl, m_queryTarget, *buf, m_verifierType);
 314         }
 315
 316         {
 317                 const tcu::ScopedLogSection     section (m_testCtx.getLog(), "AfterDelete", "After deleting");
 318                 glw::GLuint                                     buf             = 0;
 319
 320                 gl.glGenBuffers(1, &buf);
 321                 gl.glBindBuffer(m_bindingPoint, buf);
 322                 gl.glDeleteBuffers(1, &buf);
 323                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "setup");
 324
 325                 verifyStateInteger(result, gl, m_queryTarget, 0, m_verifierType);
 326         }
 327
 328         result.setTestContextResult(m_testCtx);
 329         return STOP;
 330 }
 331
 332 class ProgramPipelineBindingCase : public TestCase
 333 {
 334 public:
 335                                                 ProgramPipelineBindingCase      (Context& context, const char* name, const char* desc, QueryType verifierType);
 336 private:
 337         IterateResult           iterate                                         (void);
 338
 339         const QueryType         m_verifierType;
 340 };
 341
 342 ProgramPipelineBindingCase::ProgramPipelineBindingCase (Context& context, const char* name, const char* desc, QueryType verifierType)
 343         : TestCase                      (context, name, desc)
 344         , m_verifierType        (verifierType)
 345 {
 346 }
 347
 348 ProgramPipelineBindingCase::IterateResult ProgramPipelineBindingCase::iterate (void)
 349 {
 350         glu::CallLogWrapper             gl              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 351         tcu::ResultCollector    result  (m_testCtx.getLog(), " // ERROR: ");
 352
 353         gl.enableLogging(true);
 354
 355         {
 356                 const tcu::ScopedLogSection     section(m_testCtx.getLog(), "Initial", "Initial value");
 357
 358                 verifyStateInteger(result, gl, GL_PROGRAM_PIPELINE_BINDING, 0, m_verifierType);
 359         }
 360
 361         {
 362                 const tcu::ScopedLogSection     section         (m_testCtx.getLog(), "AfterBinding", "After binding");
 363                 glu::ProgramPipeline            pipeline        (m_context.getRenderContext());
 364
 365                 gl.glBindProgramPipeline(pipeline.getPipeline());
 366                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "setup");
 367
 368                 verifyStateInteger(result, gl, GL_PROGRAM_PIPELINE_BINDING, pipeline.getPipeline(), m_verifierType);
 369         }
 370
 371         {
 372                 const tcu::ScopedLogSection     section         (m_testCtx.getLog(), "AfterDelete", "After deleting");
 373                 glw::GLuint                                     pipeline        = 0;
 374
 375                 gl.glGenProgramPipelines(1, &pipeline);
 376                 gl.glBindProgramPipeline(pipeline);
 377                 gl.glDeleteProgramPipelines(1, &pipeline);
 378                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "setup");
 379
 380                 verifyStateInteger(result, gl, GL_PROGRAM_PIPELINE_BINDING, 0, m_verifierType);
 381         }
 382
 383         result.setTestContextResult(m_testCtx);
 384         return STOP;
 385 }
 386
 387 class FramebufferMinimumValueCase : public TestCase
 388 {
 389 public:
 390                                                 FramebufferMinimumValueCase     (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, glw::GLenum tiedTo, QueryType verifierType);
 391 private:
 392         IterateResult           iterate                                         (void);
 393
 394         const glw::GLenum       m_target;
 395         const glw::GLenum       m_tiedTo;
 396         const int                       m_minValue;
 397         const QueryType         m_verifierType;
 398 };
 399
 400 FramebufferMinimumValueCase::FramebufferMinimumValueCase (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, glw::GLenum tiedTo, QueryType verifierType)
 401         : TestCase                      (context, name, desc)
 402         , m_target                      (target)
 403         , m_tiedTo                      (tiedTo)
 404         , m_minValue            (minValue)
 405         , m_verifierType        (verifierType)
 406 {
 407 }
 408
 409 FramebufferMinimumValueCase::IterateResult FramebufferMinimumValueCase::iterate (void)
 410 {
 411         glu::CallLogWrapper             gl              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 412         tcu::ResultCollector    result  (m_testCtx.getLog(), " // ERROR: ");
 413
 414         gl.enableLogging(true);
 415
 416         {
 417                 const tcu::ScopedLogSection     section(m_testCtx.getLog(), "Minimum", "Specified minimum is " + de::toString(m_minValue));
 418
 419                 verifyStateIntegerMin(result, gl, m_target, m_minValue, m_verifierType);
 420         }
 421         {
 422                 const tcu::ScopedLogSection                             section         (m_testCtx.getLog(), "Ties", "The limit is tied to the value of " + de::toString(glu::getGettableStateStr(m_tiedTo)));
 423                 StateQueryMemoryWriteGuard<glw::GLint>  tiedToValue;
 424
 425                 gl.glGetIntegerv(m_tiedTo, &tiedToValue);
 426                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv");
 427
 428                 if (tiedToValue.verifyValidity(result))
 429                         verifyStateIntegerMin(result, gl, m_target, tiedToValue, m_verifierType);
 430         }
 431
 432         result.setTestContextResult(m_testCtx);
 433         return STOP;
 434 }
 435
 436 class LegacyVectorLimitCase : public TestCase
 437 {
 438 public:
 439                                                 LegacyVectorLimitCase   (Context& context, const char* name, const char* desc, glw::GLenum legacyTarget, glw::GLenum componentTarget, QueryType verifierType);
 440 private:
 441         IterateResult           iterate                                 (void);
 442
 443         const glw::GLenum       m_legacyTarget;
 444         const glw::GLenum       m_componentTarget;
 445         const QueryType         m_verifierType;
 446 };
 447
 448 LegacyVectorLimitCase::LegacyVectorLimitCase (Context& context, const char* name, const char* desc, glw::GLenum legacyTarget, glw::GLenum componentTarget, QueryType verifierType)
 449         : TestCase                      (context, name, desc)
 450         , m_legacyTarget        (legacyTarget)
 451         , m_componentTarget     (componentTarget)
 452         , m_verifierType        (verifierType)
 453 {
 454 }
 455
 456 LegacyVectorLimitCase::IterateResult LegacyVectorLimitCase::iterate (void)
 457 {
 458         glu::CallLogWrapper             gl              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 459         tcu::ResultCollector    result  (m_testCtx.getLog(), " // ERROR: ");
 460
 461         gl.enableLogging(true);
 462
 463         {
 464                 const tcu::ScopedLogSection     section(m_testCtx.getLog(), "TiedTo", de::toString(glu::getGettableStateStr(m_legacyTarget)) +
 465                                                                                                                                                         " is " +
 466                                                                                                                                                         de::toString(glu::getGettableStateStr(m_componentTarget)) +
 467                                                                                                                                                         " divided by four");
 468
 469                 StateQueryMemoryWriteGuard<glw::GLint> value;
 470                 gl.glGetIntegerv(m_componentTarget, &value);
 471                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv");
 472
 473                 if (value.verifyValidity(result))
 474                         verifyStateInteger(result, gl, m_legacyTarget, ((int)value) / 4, m_verifierType);
 475         }
 476
 477         result.setTestContextResult(m_testCtx);
 478         return STOP;
 479 }
 480
 481 class CombinedUniformComponentsCase : public TestCase
 482 {
 483 public:
 484                                                 CombinedUniformComponentsCase   (Context& context, const char* name, const char* desc, glw::GLenum target, QueryType verifierType);
 485                                                 CombinedUniformComponentsCase   (Context& context, const char* name, const char* desc, glw::GLenum target, QueryType verifierType, glu::ApiType minVersion);
 486 private:
 487         IterateResult           iterate                                                                 (void);
 488         const glw::GLenum       m_target;
 489         const QueryType         m_verifierType;
 490         const glu::ApiType      m_minimumVersion;
 491 };
 492
 493 CombinedUniformComponentsCase::CombinedUniformComponentsCase (Context& context, const char* name, const char* desc, glw::GLenum target, QueryType verifierType)
 494         : TestCase                      (context, name, desc)
 495         , m_target                      (target)
 496         , m_verifierType        (verifierType)
 497         , m_minimumVersion      (glu::ApiType::es(3, 1))
 498 {
 499 }
 500
 501 CombinedUniformComponentsCase::CombinedUniformComponentsCase (Context& context, const char* name, const char* desc, glw::GLenum target, QueryType verifierType, glu::ApiType minVersion)
 502         : TestCase                      (context, name, desc)
 503         , m_target                      (target)
 504         , m_verifierType        (verifierType)
 505         , m_minimumVersion      (minVersion)
 506 {
 507 }
 508
 509 CombinedUniformComponentsCase::IterateResult CombinedUniformComponentsCase::iterate (void)
 510 {
 511         TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(m_context.getRenderContext().getType(), m_minimumVersion), "Test not supported in this context.");
 512
 513         glu::CallLogWrapper             gl                                                      (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 514         tcu::ResultCollector    result                                          (m_testCtx.getLog(), " // ERROR: ");
 515
 516         const glw::GLenum               maxUniformBlocksEnum            = (m_target == GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS) ? GL_MAX_COMPUTE_UNIFORM_BLOCKS
 517                                                                                                                 : (m_target == GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS) ? GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS
 518                                                                                                                 : (m_target == GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS) ? GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS
 519                                                                                                                 : (m_target == GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS) ? GL_MAX_GEOMETRY_UNIFORM_BLOCKS
 520                                                                                                                 : -1;
 521
 522         const glw::GLenum               maxUniformComponentsEnum        = (m_target == GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS) ? GL_MAX_COMPUTE_UNIFORM_COMPONENTS
 523                                                                                                                 : (m_target == GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS) ? GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS
 524                                                                                                                 : (m_target == GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS) ? GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS
 525                                                                                                                 : (m_target == GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS) ? GL_MAX_GEOMETRY_UNIFORM_COMPONENTS
 526                                                                                                                 : -1;
 527
 528         gl.enableLogging(true);
 529
 530         m_testCtx.getLog()      << tcu::TestLog::Message
 531                                                 << "The minimum value of MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS is MAX_COMPUTE_UNIFORM_BLOCKS x MAX_UNIFORM_BLOCK_SIZE / 4 + MAX_COMPUTE_UNIFORM_COMPONENTS"
 532                                                 << tcu::TestLog::EndMessage;
 533
 534         StateQueryMemoryWriteGuard<glw::GLint> maxUniformBlocks;
 535         gl.glGetIntegerv(maxUniformBlocksEnum, &maxUniformBlocks);
 536         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv");
 537
 538         StateQueryMemoryWriteGuard<glw::GLint> maxUniformBlockSize;
 539         gl.glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &maxUniformBlockSize);
 540         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv");
 541
 542         StateQueryMemoryWriteGuard<glw::GLint> maxUniformComponents;
 543         gl.glGetIntegerv(maxUniformComponentsEnum, &maxUniformComponents);
 544         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv");
 545
 546         if (maxUniformBlocks.verifyValidity(result) && maxUniformBlockSize.verifyValidity(result) && maxUniformComponents.verifyValidity(result))
 547                 verifyStateIntegerMin(result, gl, m_target, ((int)maxUniformBlocks) * ((int)maxUniformBlockSize) / 4 + (int)maxUniformComponents, m_verifierType);
 548
 549         result.setTestContextResult(m_testCtx);
 550         return STOP;
 551 }
 552
 553 class TextureGatherLimitCase : public TestCase
 554 {
 555 public:
 556                                                 TextureGatherLimitCase  (Context& context, const char* name, const char* desc, bool isMaxCase, QueryType verifierType);
 557 private:
 558         IterateResult           iterate                                 (void);
 559
 560         const bool                      m_isMaxCase;
 561         const QueryType         m_verifierType;
 562 };
 563
 564 TextureGatherLimitCase::TextureGatherLimitCase (Context& context, const char* name, const char* desc, bool isMaxCase, QueryType verifierType)
 565         : TestCase                      (context, name, desc)
 566         , m_isMaxCase           (isMaxCase)
 567         , m_verifierType        (verifierType)
 568 {
 569 }
 570
 571 TextureGatherLimitCase::IterateResult TextureGatherLimitCase::iterate (void)
 572 {
 573         glu::CallLogWrapper             gl              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 574         tcu::ResultCollector    result  (m_testCtx.getLog(), " // ERROR: ");
 575
 576         gl.enableLogging(true);
 577
 578         if (m_isMaxCase)
 579         {
 580                 // range [0, inf)
 581                 verifyStateIntegerMin(result, gl, GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET, 0, m_verifierType);
 582         }
 583         else
 584         {
 585                 // range (-inf, 0]
 586                 verifyStateIntegerMax(result, gl, GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET, 0, m_verifierType);
 587         }
 588
 589         result.setTestContextResult(m_testCtx);
 590         return STOP;
 591 }
 592
 593 class MaxUniformBufferBindingsCase : public TestCase
 594 {
 595 public:
 596                                                 MaxUniformBufferBindingsCase    (Context& context, const char* name, const char* desc, QueryType verifierType);
 597 private:
 598         IterateResult           iterate                                                 (void);
 599
 600         const QueryType         m_verifierType;
 601 };
 602
 603 MaxUniformBufferBindingsCase::MaxUniformBufferBindingsCase (Context& context, const char* name, const char* desc, QueryType verifierType)
 604         : TestCase                      (context, name, desc)
 605         , m_verifierType        (verifierType)
 606 {
 607 }
 608
 609 MaxUniformBufferBindingsCase::IterateResult MaxUniformBufferBindingsCase::iterate (void)
 610 {
 611         glu::CallLogWrapper             gl              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 612         tcu::ResultCollector    result  (m_testCtx.getLog(), " // ERROR: ");
 613         int                                             minMax;
 614
 615         gl.enableLogging(true);
 616
 617         if (contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)))
 618         {
 619                 minMax = 72;
 620         }
 621         else
 622         {
 623                 if (m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader"))
 624                 {
 625                         m_testCtx.getLog()      << tcu::TestLog::Message
 626                                                                 << "GL_EXT_tessellation_shader increases the minimum value of GL_MAX_UNIFORM_BUFFER_BINDINGS to 72"
 627                                                                 << tcu::TestLog::EndMessage;
 628                         minMax = 72;
 629                 }
 630                 else if (m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
 631                 {
 632                         m_testCtx.getLog()      << tcu::TestLog::Message
 633                                                                 << "GL_EXT_geometry_shader increases the minimum value of GL_MAX_UNIFORM_BUFFER_BINDINGS to 48"
 634                                                                 << tcu::TestLog::EndMessage;
 635                         minMax = 48;
 636                 }
 637                 else
 638                 {
 639                         minMax = 36;
 640                 }
 641         }
 642
 643         // range [0, inf)
 644         verifyStateIntegerMin(result, gl, GL_MAX_UNIFORM_BUFFER_BINDINGS, minMax, m_verifierType);
 645
 646         result.setTestContextResult(m_testCtx);
 647         return STOP;
 648 }
 649
 650 class MaxCombinedUniformBlocksCase : public TestCase
 651 {
 652 public:
 653                                                 MaxCombinedUniformBlocksCase    (Context& context, const char* name, const char* desc, QueryType verifierType);
 654 private:
 655         IterateResult           iterate                                                 (void);
 656
 657         const QueryType         m_verifierType;
 658 };
 659
 660 MaxCombinedUniformBlocksCase::MaxCombinedUniformBlocksCase (Context& context, const char* name, const char* desc, QueryType verifierType)
 661         : TestCase                      (context, name, desc)
 662         , m_verifierType        (verifierType)
 663 {
 664 }
 665
 666 MaxCombinedUniformBlocksCase::IterateResult MaxCombinedUniformBlocksCase::iterate (void)
 667 {
 668         glu::CallLogWrapper             gl              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 669         tcu::ResultCollector    result  (m_testCtx.getLog(), " // ERROR: ");
 670         int                                             minMax;
 671
 672         gl.enableLogging(true);
 673
 674         if (contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)))
 675         {
 676                 minMax = 60;
 677         }
 678         else
 679         {
 680                 if (m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader"))
 681                 {
 682                         m_testCtx.getLog()      << tcu::TestLog::Message
 683                                                                 << "GL_EXT_tessellation_shader increases the minimum value of GL_MAX_COMBINED_UNIFORM_BLOCKS to 60"
 684                                                                 << tcu::TestLog::EndMessage;
 685                         minMax = 60;
 686                 }
 687                 else if (m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
 688                 {
 689                         m_testCtx.getLog()      << tcu::TestLog::Message
 690                                                                 << "GL_EXT_geometry_shader increases the minimum value of GL_MAX_COMBINED_UNIFORM_BLOCKS to 36"
 691                                                                 << tcu::TestLog::EndMessage;
 692                         minMax = 36;
 693                 }
 694                 else
 695                 {
 696                         minMax = 24;
 697                 }
 698         }
 699
 700         // range [0, inf)
 701         verifyStateIntegerMin(result, gl, GL_MAX_COMBINED_UNIFORM_BLOCKS, minMax, m_verifierType);
 702
 703         result.setTestContextResult(m_testCtx);
 704         return STOP;
 705 }
 706
 707 class MaxCombinedTexImageUnitsCase : public TestCase
 708 {
 709 public:
 710                                                 MaxCombinedTexImageUnitsCase    (Context& context, const char* name, const char* desc, QueryType verifierType);
 711 private:
 712         IterateResult           iterate                                                 (void);
 713
 714         const QueryType         m_verifierType;
 715 };
 716
 717 MaxCombinedTexImageUnitsCase::MaxCombinedTexImageUnitsCase (Context& context, const char* name, const char* desc, QueryType verifierType)
 718         : TestCase                      (context, name, desc)
 719         , m_verifierType        (verifierType)
 720 {
 721 }
 722
 723 MaxCombinedTexImageUnitsCase::IterateResult MaxCombinedTexImageUnitsCase::iterate (void)
 724 {
 725         glu::CallLogWrapper             gl              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 726         tcu::ResultCollector    result  (m_testCtx.getLog(), " // ERROR: ");
 727         int                                             minMax;
 728
 729         gl.enableLogging(true);
 730         if (contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)))
 731         {
 732                 minMax = 96;
 733         }
 734         else
 735         {
 736                 if (m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader"))
 737                 {
 738                         m_testCtx.getLog()      << tcu::TestLog::Message
 739                                                                 << "GL_EXT_tessellation_shader increases the minimum value of GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS to 96"
 740                                                                 << tcu::TestLog::EndMessage;
 741                         minMax = 96;
 742                 }
 743                 else if (m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
 744                 {
 745                         m_testCtx.getLog()      << tcu::TestLog::Message
 746                                                                 << "GL_EXT_geometry_shader increases the minimum value of GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS to 36"
 747                                                                 << tcu::TestLog::EndMessage;
 748                         minMax = 64;
 749                 }
 750                 else
 751                 {
 752                         minMax = 48;
 753                 }
 754         }
 755
 756         // range [0, inf)
 757         verifyStateIntegerMin(result, gl, GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, minMax, m_verifierType);
 758
 759         result.setTestContextResult(m_testCtx);
 760         return STOP;
 761 }
 762
 763 } // anonymous
 764
 765 IntegerStateQueryTests::IntegerStateQueryTests (Context& context)
 766         : TestCaseGroup(context, "integer", "Integer state query tests")
 767 {
 768 }
 769
 770 IntegerStateQueryTests::~IntegerStateQueryTests (void)
 771 {
 772 }
 773
 774 void IntegerStateQueryTests::init (void)
 775 {
 776         // Verifiers
 777         const QueryType verifiers[]     = { QUERY_BOOLEAN, QUERY_INTEGER, QUERY_INTEGER64, QUERY_FLOAT };
 778
 779 #define FOR_EACH_VERIFIER(X) \
 780         for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx)   \
 781         {                                                                                                                                                                               \
 782                 const char* verifierSuffix = getVerifierSuffix(verifiers[verifierNdx]);                         \
 783                 const QueryType verifier = verifiers[verifierNdx];                                                                      \
 784                 this->addChild(X);                                                                                                                                      \
 785         }
 786
 787         FOR_EACH_VERIFIER(new MaxSamplesCase(m_context,         (std::string() + "max_color_texture_samples_" + verifierSuffix).c_str(),                                "Test GL_MAX_COLOR_TEXTURE_SAMPLES",                    GL_MAX_COLOR_TEXTURE_SAMPLES,           1,      verifier))
 788         FOR_EACH_VERIFIER(new MaxSamplesCase(m_context,         (std::string() + "max_depth_texture_samples_" + verifierSuffix).c_str(),                                "Test GL_MAX_DEPTH_TEXTURE_SAMPLES",                    GL_MAX_DEPTH_TEXTURE_SAMPLES,           1,      verifier))
 789         FOR_EACH_VERIFIER(new MaxSamplesCase(m_context,         (std::string() + "max_integer_samples_" + verifierSuffix).c_str(),                                              "Test GL_MAX_INTEGER_SAMPLES",                                  GL_MAX_INTEGER_SAMPLES,                         1,      verifier))
 790
 791         FOR_EACH_VERIFIER(new TexBindingCase(m_context,         (std::string() + "texture_binding_2d_multisample_" + verifierSuffix).c_str(),                   "Test TEXTURE_BINDING_2D_MULTISAMPLE",                  GL_TEXTURE_2D_MULTISAMPLE,                      GL_TEXTURE_BINDING_2D_MULTISAMPLE,                      verifier))
 792         FOR_EACH_VERIFIER(new TexBindingCase(m_context,         (std::string() + "texture_binding_2d_multisample_array_" + verifierSuffix).c_str(),             "Test TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY",    GL_TEXTURE_2D_MULTISAMPLE_ARRAY,        GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY,        verifier))
 793         FOR_EACH_VERIFIER(new TexBindingCase(m_context,         (std::string() + "texture_binding_cube_map_array_" + verifierSuffix).c_str(),                   "Test TEXTURE_BINDING_CUBE_MAP_ARRAY",                  GL_TEXTURE_CUBE_MAP_ARRAY,                      GL_TEXTURE_BINDING_CUBE_MAP_ARRAY,                      verifier))
 794         FOR_EACH_VERIFIER(new TexBindingCase(m_context,         (std::string() + "texture_binding_buffer_" + verifierSuffix).c_str(),                                   "Test TEXTURE_BINDING_BUFFER",                                  GL_TEXTURE_BUFFER,                                      GL_TEXTURE_BINDING_BUFFER,                                      verifier))
 795
 796         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_vertex_attrib_relative_offset_" + verifierSuffix).c_str(),                "Test MAX_VERTEX_ATTRIB_RELATIVE_OFFSET",               GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET,   2047,   verifier))
 797         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_vertex_attrib_bindings_" + verifierSuffix).c_str(),                               "Test MAX_VERTEX_ATTRIB_BINDINGS",                              GL_MAX_VERTEX_ATTRIB_BINDINGS,                  16,             verifier))
 798         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_vertex_attrib_stride_" + verifierSuffix).c_str(),                                 "Test MAX_VERTEX_ATTRIB_STRIDE",                                GL_MAX_VERTEX_ATTRIB_STRIDE,                    2048,   verifier))
 799         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_sample_mask_words_" + verifierSuffix).c_str(),                                    "Test MAX_SAMPLE_MASK_WORDS",                                   GL_MAX_SAMPLE_MASK_WORDS,                               1,              verifier))
 800
 801         FOR_EACH_VERIFIER(new AlignmentCase(m_context,          (std::string() + "shader_storage_buffer_offset_alignment_" + verifierSuffix).c_str(),   "Test SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT",  GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT,      256,    verifier))
 802
 803         FOR_EACH_VERIFIER(new BufferBindingCase(m_context,      (std::string() + "draw_indirect_buffer_binding_" + verifierSuffix).c_str(),                             "Test DRAW_INDIRECT_BUFFER_BINDING",                    GL_DRAW_INDIRECT_BUFFER_BINDING,                GL_DRAW_INDIRECT_BUFFER,                verifier))
 804         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,               verifier))
 805         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,               verifier))
 806         FOR_EACH_VERIFIER(new BufferBindingCase(m_context,      (std::string() + "dispatch_indirect_buffer_binding_" + verifierSuffix).c_str(),                 "Test DISPATCH_INDIRECT_BUFFER_BINDING",                GL_DISPATCH_INDIRECT_BUFFER_BINDING,    GL_DISPATCH_INDIRECT_BUFFER,    verifier))
 807
 808         FOR_EACH_VERIFIER(new FramebufferMinimumValueCase(m_context,    (std::string() + "max_framebuffer_width_" + verifierSuffix).c_str(),            "Test MAX_FRAMEBUFFER_WIDTH",                                   GL_MAX_FRAMEBUFFER_WIDTH,                               2048,   GL_MAX_TEXTURE_SIZE,    verifier))
 809         FOR_EACH_VERIFIER(new FramebufferMinimumValueCase(m_context,    (std::string() + "max_framebuffer_height_" + verifierSuffix).c_str(),           "Test MAX_FRAMEBUFFER_HEIGHT",                                  GL_MAX_FRAMEBUFFER_HEIGHT,                              2048,   GL_MAX_TEXTURE_SIZE,    verifier))
 810         FOR_EACH_VERIFIER(new FramebufferMinimumValueCase(m_context,    (std::string() + "max_framebuffer_samples_" + verifierSuffix).c_str(),          "Test MAX_FRAMEBUFFER_SAMPLES",                                 GL_MAX_FRAMEBUFFER_SAMPLES,                             4,              GL_MAX_SAMPLES,                 verifier))
 811
 812         FOR_EACH_VERIFIER(new ProgramPipelineBindingCase(m_context,     (std::string() + "program_pipeline_binding_" + verifierSuffix).c_str(),                 "Test PROGRAM_PIPELINE_BINDING",        verifier))
 813
 814         // vertex
 815         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_vertex_atomic_counter_buffers_" + verifierSuffix).c_str(),                "Test MAX_VERTEX_ATOMIC_COUNTER_BUFFERS",               GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS,   0,              verifier))
 816         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_vertex_atomic_counters_" + verifierSuffix).c_str(),                               "Test MAX_VERTEX_ATOMIC_COUNTERS",                              GL_MAX_VERTEX_ATOMIC_COUNTERS,                  0,              verifier))
 817         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_vertex_image_uniforms_" + verifierSuffix).c_str(),                                "Test MAX_VERTEX_IMAGE_UNIFORMS",                               GL_MAX_VERTEX_IMAGE_UNIFORMS,                   0,              verifier))
 818         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_vertex_shader_storage_blocks_" + verifierSuffix).c_str(),                 "Test MAX_VERTEX_SHADER_STORAGE_BLOCKS",                GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS,    0,              verifier))
 819         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_vertex_uniform_components_" + verifierSuffix).c_str(),                    "Test MAX_VERTEX_UNIFORM_COMPONENTS",                   GL_MAX_VERTEX_UNIFORM_COMPONENTS,               1024,   verifier))
 820
 821         // fragment
 822         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_fragment_atomic_counter_buffers_" + verifierSuffix).c_str(),              "Test MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS",             GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS, 0,              verifier))
 823         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_fragment_atomic_counters_" + verifierSuffix).c_str(),                             "Test MAX_FRAGMENT_ATOMIC_COUNTERS",                    GL_MAX_FRAGMENT_ATOMIC_COUNTERS,                0,              verifier))
 824         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_fragment_image_uniforms_" + verifierSuffix).c_str(),                              "Test MAX_FRAGMENT_IMAGE_UNIFORMS",                             GL_MAX_FRAGMENT_IMAGE_UNIFORMS,                 0,              verifier))
 825         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_fragment_shader_storage_blocks_" + verifierSuffix).c_str(),               "Test MAX_FRAGMENT_SHADER_STORAGE_BLOCKS",              GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS,  0,              verifier))
 826         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_fragment_uniform_components_" + verifierSuffix).c_str(),                  "Test MAX_FRAGMENT_UNIFORM_COMPONENTS",                 GL_MAX_FRAGMENT_UNIFORM_COMPONENTS,             1024,   verifier))
 827
 828         // compute
 829         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_compute_work_group_invocations_" + verifierSuffix).c_str(),               "Test MAX_COMPUTE_WORK_GROUP_INVOCATIONS",              GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS,          128,    verifier))
 830         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_compute_uniform_blocks_" + verifierSuffix).c_str(),                               "Test MAX_COMPUTE_UNIFORM_BLOCKS",                              GL_MAX_COMPUTE_UNIFORM_BLOCKS,                          12,             verifier))
 831         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_compute_texture_image_units_" + verifierSuffix).c_str(),                  "Test MAX_COMPUTE_TEXTURE_IMAGE_UNITS",                 GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS,                     16,             verifier))
 832         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_compute_shared_memory_size_" + verifierSuffix).c_str(),                   "Test MAX_COMPUTE_SHARED_MEMORY_SIZE",                  GL_MAX_COMPUTE_SHARED_MEMORY_SIZE,                      16384,  verifier))
 833         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_compute_uniform_components_" + verifierSuffix).c_str(),                   "Test MAX_COMPUTE_UNIFORM_COMPONENTS",                  GL_MAX_COMPUTE_UNIFORM_COMPONENTS,                      1024,   verifier))
 834         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_compute_atomic_counter_buffers_" + verifierSuffix).c_str(),               "Test MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS",              GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS,          1,              verifier))
 835         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_compute_atomic_counters_" + verifierSuffix).c_str(),                              "Test MAX_COMPUTE_ATOMIC_COUNTERS",                             GL_MAX_COMPUTE_ATOMIC_COUNTERS,                         8,              verifier))
 836         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_compute_image_uniforms_" + verifierSuffix).c_str(),                               "Test MAX_COMPUTE_IMAGE_UNIFORMS",                              GL_MAX_COMPUTE_IMAGE_UNIFORMS,                          4,              verifier))
 837         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_compute_shader_storage_blocks_" + verifierSuffix).c_str(),                "Test MAX_COMPUTE_SHADER_STORAGE_BLOCKS",               GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS,           4,              verifier))
 838
 839         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_uniform_locations_" + verifierSuffix).c_str(),                                    "Test MAX_UNIFORM_LOCATIONS",                                   GL_MAX_UNIFORM_LOCATIONS,                                       1024,   verifier))
 840         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_atomic_counter_buffer_bindings_" + verifierSuffix).c_str(),               "Test MAX_ATOMIC_COUNTER_BUFFER_BINDINGS",              GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS,          1,              verifier))
 841         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_atomic_counter_buffer_size_" + verifierSuffix).c_str(),                   "Test MAX_ATOMIC_COUNTER_BUFFER_SIZE",                  GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE,                      32,             verifier))
 842         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_combined_atomic_counter_buffers_" + verifierSuffix).c_str(),              "Test MAX_COMBINED_ATOMIC_COUNTER_BUFFERS",             GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS,         1,              verifier))
 843         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_combined_atomic_counters_" + verifierSuffix).c_str(),                             "Test MAX_COMBINED_ATOMIC_COUNTERS",                    GL_MAX_COMBINED_ATOMIC_COUNTERS,                        8,              verifier))
 844         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_image_units_" + verifierSuffix).c_str(),                                                  "Test MAX_IMAGE_UNITS",                                                 GL_MAX_IMAGE_UNITS,                                                     4,              verifier))
 845         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_combined_image_uniforms_" + verifierSuffix).c_str(),                              "Test MAX_COMBINED_IMAGE_UNIFORMS",                             GL_MAX_COMBINED_IMAGE_UNIFORMS,                         4,              verifier))
 846         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_shader_storage_buffer_bindings_" + verifierSuffix).c_str(),               "Test MAX_SHADER_STORAGE_BUFFER_BINDINGS",              GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS,          4,              verifier))
 847         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_shader_storage_block_size_" + verifierSuffix).c_str(),                    "Test MAX_SHADER_STORAGE_BLOCK_SIZE",                   GL_MAX_SHADER_STORAGE_BLOCK_SIZE,                       1<<27,  verifier))
 848         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_combined_shader_storage_blocks_" + verifierSuffix).c_str(),               "Test MAX_COMBINED_SHADER_STORAGE_BLOCKS",              GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS,          4,              verifier))
 849         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_combined_shader_output_resources_" + verifierSuffix).c_str(),             "Test MAX_COMBINED_SHADER_OUTPUT_RESOURCES",    GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES,        4,              verifier))
 850
 851         FOR_EACH_VERIFIER(new MaxUniformBufferBindingsCase      (m_context,     (std::string() + "max_uniform_buffer_bindings_" + verifierSuffix).c_str(),                              "Test MAX_UNIFORM_BUFFER_BINDINGS",                             verifier))
 852         FOR_EACH_VERIFIER(new MaxCombinedUniformBlocksCase      (m_context,     (std::string() + "max_combined_uniform_blocks_" + verifierSuffix).c_str(),                              "Test MAX_COMBINED_UNIFORM_BLOCKS",                             verifier))
 853         FOR_EACH_VERIFIER(new MaxCombinedTexImageUnitsCase      (m_context,     (std::string() + "max_combined_texture_image_units_" + verifierSuffix).c_str(),                 "Test MAX_COMBINED_TEXTURE_IMAGE_UNITS",                verifier))
 854         FOR_EACH_VERIFIER(new CombinedUniformComponentsCase     (m_context,     (std::string() + "max_combined_compute_uniform_components_" + verifierSuffix).c_str(),  "Test MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS", GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS, verifier))
 855
 856         FOR_EACH_VERIFIER(new LegacyVectorLimitCase(m_context,  (std::string() + "max_vertex_uniform_vectors_" + verifierSuffix).c_str(),                       "Test MAX_VERTEX_UNIFORM_VECTORS",                              GL_MAX_VERTEX_UNIFORM_VECTORS,                  GL_MAX_VERTEX_UNIFORM_COMPONENTS,       verifier))
 857         FOR_EACH_VERIFIER(new LegacyVectorLimitCase(m_context,  (std::string() + "max_fragment_uniform_vectors_" + verifierSuffix).c_str(),                     "Test MAX_FRAGMENT_UNIFORM_VECTORS",                    GL_MAX_FRAGMENT_UNIFORM_VECTORS,                GL_MAX_FRAGMENT_UNIFORM_COMPONENTS,     verifier))
 858
 859         FOR_EACH_VERIFIER(new TextureGatherLimitCase(m_context, (std::string() + "min_program_texture_gather_offset_" + verifierSuffix).c_str(),        "Test MIN_PROGRAM_TEXTURE_GATHER_OFFSET",               false,          verifier))
 860         FOR_EACH_VERIFIER(new TextureGatherLimitCase(m_context, (std::string() + "max_program_texture_gather_offset_" + verifierSuffix).c_str(),        "Test MAX_PROGRAM_TEXTURE_GATHER_OFFSET",               true,           verifier))
 861
 862         // GL ES 3.2 tests
 863         FOR_EACH_VERIFIER(new MinimumValueCase  (m_context,     (std::string() + "max_framebuffer_layers_" + verifierSuffix).c_str(),                                           "Test MAX_FRAMEBUFFER_LAYERS",                                          GL_MAX_FRAMEBUFFER_LAYERS,                                              256,    verifier,       glu::ApiType::es(3, 2)))
 864         FOR_EACH_VERIFIER(new MinimumValueCase  (m_context,     (std::string() + "fragment_interpolation_offset_bits_" + verifierSuffix).c_str(),                       "Test FRAGMENT_INTERPOLATION_OFFSET_BITS",                      GL_FRAGMENT_INTERPOLATION_OFFSET_BITS,                  4,              verifier,       glu::ApiType::es(3, 2)))
 865         FOR_EACH_VERIFIER(new MinimumValueCase  (m_context,     (std::string() + "max_texture_buffer_size_" + verifierSuffix).c_str(),                                          "Test MAX_TEXTURE_BUFFER_SIZE",                                         GL_MAX_TEXTURE_BUFFER_SIZE,                                             65536,  verifier,       glu::ApiType::es(3, 2)))
 866         FOR_EACH_VERIFIER(new AlignmentCase             (m_context,     (std::string() + "texture_buffer_offset_alignment_" + verifierSuffix).c_str(),                          "Test TEXTURE_BUFFER_OFFSET_ALIGNMENT",                         GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT,                             256,    verifier,       glu::ApiType::es(3, 2)))
 867
 868         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_gen_level_" + verifierSuffix).c_str(),                                                       "Test MAX_TESS_GEN_LEVEL",                                                      GL_MAX_TESS_GEN_LEVEL,                                                  64,             verifier,       glu::ApiType::es(3, 2)))
 869         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_patch_vertices_" + verifierSuffix).c_str(),                                                       "Test MAX_PATCH_VERTICES",                                                      GL_MAX_PATCH_VERTICES,                                                  32,             verifier,       glu::ApiType::es(3, 2)))
 870         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_patch_components_" + verifierSuffix).c_str(),                                        "Test MAX_TESS_PATCH_COMPONENTS",                                       GL_MAX_TESS_PATCH_COMPONENTS,                                   120,    verifier,       glu::ApiType::es(3, 2)))
 871
 872         // tess control
 873         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_control_uniform_components_" + verifierSuffix).c_str(),                      "Test MAX_TESS_CONTROL_UNIFORM_COMPONENTS",                     GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS,                 1024,   verifier,       glu::ApiType::es(3, 2)))
 874         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_control_texture_image_units_" + verifierSuffix).c_str(),                     "Test MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS",            GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS,                16,             verifier,       glu::ApiType::es(3, 2)))
 875         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_control_output_components_" + verifierSuffix).c_str(),                       "Test MAX_TESS_CONTROL_OUTPUT_COMPONENTS",                      GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS,                  64,             verifier,       glu::ApiType::es(3, 2)))
 876         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_control_total_output_components_" + verifierSuffix).c_str(),         "Test MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS",        GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS,    2048,   verifier,       glu::ApiType::es(3, 2)))
 877         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_control_input_components_" + verifierSuffix).c_str(),                        "Test MAX_TESS_CONTROL_INPUT_COMPONENTS",                       GL_MAX_TESS_CONTROL_INPUT_COMPONENTS,                   64,             verifier,       glu::ApiType::es(3, 2)))
 878         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_control_uniform_blocks_" + verifierSuffix).c_str(),                          "Test MAX_TESS_CONTROL_UNIFORM_BLOCKS",                         GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS,                             12,             verifier,       glu::ApiType::es(3, 2)))
 879         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_control_atomic_counter_buffers_" + verifierSuffix).c_str(),          "Test MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS",         GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS,             0,              verifier,       glu::ApiType::es(3, 2)))
 880         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_control_atomic_counters_" + verifierSuffix).c_str(),                         "Test MAX_TESS_CONTROL_ATOMIC_COUNTERS",                        GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS,                    0,              verifier,       glu::ApiType::es(3, 2)))
 881         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_control_shader_storage_blocks_" + verifierSuffix).c_str(),           "Test MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS",          GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS,              0,              verifier,       glu::ApiType::es(3, 2)))
 882
 883         // tess evaluation
 884         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_evaluation_uniform_components_" + verifierSuffix).c_str(),           "Test MAX_TESS_EVALUATION_UNIFORM_COMPONENTS",          GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS,              1024,   verifier,       glu::ApiType::es(3, 2)))
 885         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_evaluation_texture_image_units_" + verifierSuffix).c_str(),          "Test MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS",         GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS,             16,             verifier,       glu::ApiType::es(3, 2)))
 886         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_evaluation_output_components_" + verifierSuffix).c_str(),            "Test MAX_TESS_EVALUATION_OUTPUT_COMPONENTS",           GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS,               64,             verifier,       glu::ApiType::es(3, 2)))
 887         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_evaluation_input_components_" + verifierSuffix).c_str(),                     "Test MAX_TESS_EVALUATION_INPUT_COMPONENTS",            GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS,                64,             verifier,       glu::ApiType::es(3, 2)))
 888         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_evaluation_uniform_blocks_" + verifierSuffix).c_str(),                       "Test MAX_TESS_EVALUATION_UNIFORM_BLOCKS",                      GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS,                  12,             verifier,       glu::ApiType::es(3, 2)))
 889         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_evaluation_atomic_counter_buffers_" + verifierSuffix).c_str(),       "Test MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS",      GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS,  0,              verifier,       glu::ApiType::es(3, 2)))
 890         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_evaluation_atomic_counters_" + verifierSuffix).c_str(),                      "Test MAX_TESS_EVALUATION_ATOMIC_COUNTERS",                     GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS,                 0,              verifier,       glu::ApiType::es(3, 2)))
 891         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_evaluation_shader_storage_blocks_" + verifierSuffix).c_str(),        "Test MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS",       GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS,   0,              verifier,       glu::ApiType::es(3, 2)))
 892
 893         // geometry
 894         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_geometry_uniform_components_" + verifierSuffix).c_str(),                          "Test MAX_GEOMETRY_UNIFORM_COMPONENTS",                         GL_MAX_GEOMETRY_UNIFORM_COMPONENTS,                             1024,   verifier,       glu::ApiType::es(3, 2)))
 895         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_geometry_uniform_blocks_" + verifierSuffix).c_str(),                                      "Test MAX_GEOMETRY_UNIFORM_BLOCKS",                                     GL_MAX_GEOMETRY_UNIFORM_BLOCKS,                                 12,             verifier,       glu::ApiType::es(3, 2)))
 896         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_geometry_input_components_" + verifierSuffix).c_str(),                            "Test MAX_GEOMETRY_INPUT_COMPONENTS",                           GL_MAX_GEOMETRY_INPUT_COMPONENTS,                               64,             verifier,       glu::ApiType::es(3, 2)))
 897         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_geometry_output_components_" + verifierSuffix).c_str(),                           "Test MAX_GEOMETRY_OUTPUT_COMPONENTS",                          GL_MAX_GEOMETRY_OUTPUT_COMPONENTS,                              64,             verifier,       glu::ApiType::es(3, 2)))
 898         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_geometry_output_vertices_" + verifierSuffix).c_str(),                                     "Test MAX_GEOMETRY_OUTPUT_VERTICES",                            GL_MAX_GEOMETRY_OUTPUT_VERTICES,                                256,    verifier,       glu::ApiType::es(3, 2)))
 899         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_geometry_total_output_components_" + verifierSuffix).c_str(),                     "Test MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS",            GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS,                1024,   verifier,       glu::ApiType::es(3, 2)))
 900         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_geometry_texture_image_units_" + verifierSuffix).c_str(),                         "Test MAX_GEOMETRY_TEXTURE_IMAGE_UNITS",                        GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS,                    16,             verifier,       glu::ApiType::es(3, 2)))
 901         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_geometry_shader_invocations_" + verifierSuffix).c_str(),                          "Test MAX_GEOMETRY_SHADER_INVOCATIONS",                         GL_MAX_GEOMETRY_SHADER_INVOCATIONS,                             32,             verifier,       glu::ApiType::es(3, 2)))
 902         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_geometry_atomic_counter_buffers_" + verifierSuffix).c_str(),                      "Test MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS",                     GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS,                 0,              verifier,       glu::ApiType::es(3, 2)))
 903         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_geometry_atomic_counters_" + verifierSuffix).c_str(),                                     "Test MAX_GEOMETRY_ATOMIC_COUNTERS",                            GL_MAX_GEOMETRY_ATOMIC_COUNTERS,                                0,              verifier,       glu::ApiType::es(3, 2)))
 904         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_geometry_shader_storage_blocks_" + verifierSuffix).c_str(),                       "Test MAX_GEOMETRY_SHADER_STORAGE_BLOCKS",                      GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS,                  0,              verifier,       glu::ApiType::es(3, 2)))
 905
 906         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_control_image_uniforms_" + verifierSuffix).c_str(),                          "Test MAX_TESS_CONTROL_IMAGE_UNIFORMS",                         GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS,                             0,              verifier,       glu::ApiType::es(3, 2)))
 907         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_tess_evaluation_image_uniforms_" + verifierSuffix).c_str(),                       "Test MAX_TESS_EVALUATION_IMAGE_UNIFORMS",                      GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS,                  0,              verifier,       glu::ApiType::es(3, 2)))
 908         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_geometry_image_uniforms_" + verifierSuffix).c_str(),                                      "Test MAX_GEOMETRY_IMAGE_UNIFORMS",                                     GL_MAX_GEOMETRY_IMAGE_UNIFORMS,                                 0,              verifier,       glu::ApiType::es(3, 2)))
 909
 910         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "debug_logged_messages_" + verifierSuffix).c_str(),                                            "Test DEBUG_LOGGED_MESSAGES",                                           GL_DEBUG_LOGGED_MESSAGES,                                               0,              verifier,       glu::ApiType::es(3, 2)))
 911         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "debug_next_logged_message_length_" + verifierSuffix).c_str(),                         "Test DEBUG_NEXT_LOGGED_MESSAGE_LENGTH",                        GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH,                    0,              verifier,       glu::ApiType::es(3, 2)))
 912         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "debug_group_stack_depth_" + verifierSuffix).c_str(),                                          "Test DEBUG_GROUP_STACK_DEPTH",                                         GL_DEBUG_GROUP_STACK_DEPTH,                                             0,              verifier,       glu::ApiType::es(3, 2)))
 913         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_debug_message_length_" + verifierSuffix).c_str(),                                         "Test MAX_DEBUG_MESSAGE_LENGTH",                                        GL_MAX_DEBUG_MESSAGE_LENGTH,                                    1,              verifier,       glu::ApiType::es(3, 2)))
 914         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_debug_logged_messages_" + verifierSuffix).c_str(),                                        "Test MAX_DEBUG_LOGGED_MESSAGES",                                       GL_MAX_DEBUG_LOGGED_MESSAGES,                                   1,              verifier,       glu::ApiType::es(3, 2)))
 915         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_debug_group_stack_depth_" + verifierSuffix).c_str(),                                      "Test MAX_DEBUG_GROUP_STACK_DEPTH",                                     GL_MAX_DEBUG_GROUP_STACK_DEPTH,                                 64,             verifier,       glu::ApiType::es(3, 2)))
 916         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "max_label_length_" + verifierSuffix).c_str(),                                                         "Test MAX_LABEL_LENGTH",                                                        GL_MAX_LABEL_LENGTH,                                                    256,    verifier,       glu::ApiType::es(3, 2)))
 917
 918         FOR_EACH_VERIFIER(new MinimumValueCase(m_context,       (std::string() + "texture_buffer_binding_" + verifierSuffix).c_str(),                                           "Test TEXTURE_BUFFER_BINDING",                                          GL_TEXTURE_BUFFER_BINDING,                                              0,              verifier,       glu::ApiType::es(3, 2)))
 919
 920         FOR_EACH_VERIFIER(new CombinedUniformComponentsCase     (m_context,     (std::string() + "max_combined_tess_control_uniform_components_" + verifierSuffix).c_str(),             "Test MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS",    GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS,        verifier,       glu::ApiType::es(3, 2)))
 921         FOR_EACH_VERIFIER(new CombinedUniformComponentsCase     (m_context,     (std::string() + "max_combined_tess_evaluation_uniform_components_" + verifierSuffix).c_str(),  "Test MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS", GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS, verifier,   glu::ApiType::es(3, 2)))
 922         FOR_EACH_VERIFIER(new CombinedUniformComponentsCase     (m_context,     (std::string() + "max_combined_geometry_uniform_components_" + verifierSuffix).c_str(),                 "Test MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS",                GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS,            verifier,       glu::ApiType::es(3, 2)))
 923
 924 #undef FOR_EACH_VERIFIER
 925 }
 926
 927 } // Functional
 928 } // gles31
 929 } // deqp