1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 3.1 Module
3 * -------------------------------------------------
5 * Copyright 2014 The Android Open Source Project
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 * \brief Integer state query tests
22 *//*--------------------------------------------------------------------*/
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"
47 using namespace gls::StateQueryUtil;
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;
53 static const char* getVerifierSuffix (QueryType type)
57 case QUERY_BOOLEAN: return "getboolean";
58 case QUERY_INTEGER: return "getinteger";
59 case QUERY_INTEGER64: return "getinteger64";
60 case QUERY_FLOAT: return "getfloat";
67 class MaxSamplesCase : public TestCase
70 MaxSamplesCase (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, QueryType verifierType);
72 IterateResult iterate (void);
74 const glw::GLenum m_target;
76 const QueryType m_verifierType;
79 MaxSamplesCase::MaxSamplesCase (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, QueryType verifierType)
80 : TestCase (context, name, desc)
82 , m_minValue (minValue)
83 , m_verifierType (verifierType)
87 MaxSamplesCase::IterateResult MaxSamplesCase::iterate (void)
89 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
90 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
92 gl.enableLogging(true);
93 verifyStateIntegerMin(result, gl, m_target, m_minValue, m_verifierType);
95 result.setTestContextResult(m_testCtx);
99 class TexBindingCase : public TestCase
102 TexBindingCase (Context& context, const char* name, const char* desc, glw::GLenum texTarget, glw::GLenum bindTarget, QueryType verifierType);
105 IterateResult iterate (void);
107 const glw::GLenum m_texTarget;
108 const glw::GLenum m_bindTarget;
109 const QueryType m_verifierType;
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)
120 void TexBindingCase::init (void)
122 if (contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)))
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");
133 TexBindingCase::IterateResult TexBindingCase::iterate (void)
135 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
136 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
138 gl.enableLogging(true);
142 const tcu::ScopedLogSection section(m_testCtx.getLog(), "initial", "Initial value");
144 verifyStateInteger(result, gl, m_bindTarget, 0, m_verifierType);
149 const tcu::ScopedLogSection section(m_testCtx.getLog(), "bind", "After bind");
153 gl.glGenTextures(1, &texture);
154 gl.glBindTexture(m_texTarget, texture);
155 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind texture");
157 verifyStateInteger(result, gl, m_bindTarget, texture, m_verifierType);
159 gl.glDeleteTextures(1, &texture);
164 const tcu::ScopedLogSection section(m_testCtx.getLog(), "bind", "After delete");
166 verifyStateInteger(result, gl, m_bindTarget, 0, m_verifierType);
169 result.setTestContextResult(m_testCtx);
173 class MinimumValueCase : public TestCase
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);
179 IterateResult iterate (void);
181 const glw::GLenum m_target;
182 const int m_minValue;
183 const QueryType m_verifierType;
184 const glu::ApiType m_minimumVersion;
187 MinimumValueCase::MinimumValueCase (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, QueryType verifierType)
188 : TestCase (context, name, desc)
190 , m_minValue (minValue)
191 , m_verifierType (verifierType)
192 , m_minimumVersion (glu::ApiType::es(3, 1))
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)
199 , m_minValue (minValue)
200 , m_verifierType (verifierType)
201 , m_minimumVersion (minVersion)
205 MinimumValueCase::IterateResult MinimumValueCase::iterate (void)
207 TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(m_context.getRenderContext().getType(), m_minimumVersion), "Test not supported in this context version.");
209 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
210 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
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
220 gl.enableLogging(true);
221 verifyStateIntegerMin(result, gl, m_target, value, m_verifierType);
223 result.setTestContextResult(m_testCtx);
227 class AlignmentCase : public TestCase
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);
233 IterateResult iterate (void);
235 const glw::GLenum m_target;
236 const int m_minValue;
237 const QueryType m_verifierType;
238 const glu::ApiType m_minimumVersion;
241 AlignmentCase::AlignmentCase (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, QueryType verifierType)
242 : TestCase (context, name, desc)
244 , m_minValue (minValue)
245 , m_verifierType (verifierType)
246 , m_minimumVersion (glu::ApiType::es(3, 1))
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)
253 , m_minValue (minValue)
254 , m_verifierType (verifierType)
255 , m_minimumVersion (minVersion)
259 AlignmentCase::IterateResult AlignmentCase::iterate (void)
261 TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(m_context.getRenderContext().getType(), m_minimumVersion), "Test not supported in this context.");
263 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
264 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
266 gl.enableLogging(true);
267 verifyStateIntegerMax(result, gl, m_target, m_minValue, m_verifierType);
269 result.setTestContextResult(m_testCtx);
273 class BufferBindingCase : public TestCase
276 BufferBindingCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bindingPoint, QueryType verifierType);
278 IterateResult iterate (void);
280 const glw::GLenum m_queryTarget;
281 const glw::GLenum m_bindingPoint;
282 const QueryType m_verifierType;
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)
293 BufferBindingCase::IterateResult BufferBindingCase::iterate (void)
295 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
296 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
298 gl.enableLogging(true);
301 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
303 verifyStateInteger(result, gl, m_queryTarget, 0, m_verifierType);
307 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterBinding", "After binding");
308 glu::Buffer buf (m_context.getRenderContext());
310 gl.glBindBuffer(m_bindingPoint, *buf);
311 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "setup");
313 verifyStateInteger(result, gl, m_queryTarget, *buf, m_verifierType);
317 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterDelete", "After deleting");
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");
325 verifyStateInteger(result, gl, m_queryTarget, 0, m_verifierType);
328 result.setTestContextResult(m_testCtx);
332 class ProgramPipelineBindingCase : public TestCase
335 ProgramPipelineBindingCase (Context& context, const char* name, const char* desc, QueryType verifierType);
337 IterateResult iterate (void);
339 const QueryType m_verifierType;
342 ProgramPipelineBindingCase::ProgramPipelineBindingCase (Context& context, const char* name, const char* desc, QueryType verifierType)
343 : TestCase (context, name, desc)
344 , m_verifierType (verifierType)
348 ProgramPipelineBindingCase::IterateResult ProgramPipelineBindingCase::iterate (void)
350 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
351 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
353 gl.enableLogging(true);
356 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
358 verifyStateInteger(result, gl, GL_PROGRAM_PIPELINE_BINDING, 0, m_verifierType);
362 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterBinding", "After binding");
363 glu::ProgramPipeline pipeline (m_context.getRenderContext());
365 gl.glBindProgramPipeline(pipeline.getPipeline());
366 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "setup");
368 verifyStateInteger(result, gl, GL_PROGRAM_PIPELINE_BINDING, pipeline.getPipeline(), m_verifierType);
372 const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterDelete", "After deleting");
373 glw::GLuint pipeline = 0;
375 gl.glGenProgramPipelines(1, &pipeline);
376 gl.glBindProgramPipeline(pipeline);
377 gl.glDeleteProgramPipelines(1, &pipeline);
378 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "setup");
380 verifyStateInteger(result, gl, GL_PROGRAM_PIPELINE_BINDING, 0, m_verifierType);
383 result.setTestContextResult(m_testCtx);
387 class FramebufferMinimumValueCase : public TestCase
390 FramebufferMinimumValueCase (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, glw::GLenum tiedTo, QueryType verifierType);
392 IterateResult iterate (void);
394 const glw::GLenum m_target;
395 const glw::GLenum m_tiedTo;
396 const int m_minValue;
397 const QueryType m_verifierType;
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)
404 , m_minValue (minValue)
405 , m_verifierType (verifierType)
409 FramebufferMinimumValueCase::IterateResult FramebufferMinimumValueCase::iterate (void)
411 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
412 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
414 gl.enableLogging(true);
417 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Minimum", "Specified minimum is " + de::toString(m_minValue));
419 verifyStateIntegerMin(result, gl, m_target, m_minValue, m_verifierType);
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;
425 gl.glGetIntegerv(m_tiedTo, &tiedToValue);
426 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv");
428 if (tiedToValue.verifyValidity(result))
429 verifyStateIntegerMin(result, gl, m_target, tiedToValue, m_verifierType);
432 result.setTestContextResult(m_testCtx);
436 class LegacyVectorLimitCase : public TestCase
439 LegacyVectorLimitCase (Context& context, const char* name, const char* desc, glw::GLenum legacyTarget, glw::GLenum componentTarget, QueryType verifierType);
441 IterateResult iterate (void);
443 const glw::GLenum m_legacyTarget;
444 const glw::GLenum m_componentTarget;
445 const QueryType m_verifierType;
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)
456 LegacyVectorLimitCase::IterateResult LegacyVectorLimitCase::iterate (void)
458 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
459 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
461 gl.enableLogging(true);
464 const tcu::ScopedLogSection section(m_testCtx.getLog(), "TiedTo", de::toString(glu::getGettableStateStr(m_legacyTarget)) +
466 de::toString(glu::getGettableStateStr(m_componentTarget)) +
469 StateQueryMemoryWriteGuard<glw::GLint> value;
470 gl.glGetIntegerv(m_componentTarget, &value);
471 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv");
473 if (value.verifyValidity(result))
474 verifyStateInteger(result, gl, m_legacyTarget, ((int)value) / 4, m_verifierType);
477 result.setTestContextResult(m_testCtx);
481 class CombinedUniformComponentsCase : public TestCase
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);
487 IterateResult iterate (void);
488 const glw::GLenum m_target;
489 const QueryType m_verifierType;
490 const glu::ApiType m_minimumVersion;
493 CombinedUniformComponentsCase::CombinedUniformComponentsCase (Context& context, const char* name, const char* desc, glw::GLenum target, QueryType verifierType)
494 : TestCase (context, name, desc)
496 , m_verifierType (verifierType)
497 , m_minimumVersion (glu::ApiType::es(3, 1))
501 CombinedUniformComponentsCase::CombinedUniformComponentsCase (Context& context, const char* name, const char* desc, glw::GLenum target, QueryType verifierType, glu::ApiType minVersion)
502 : TestCase (context, name, desc)
504 , m_verifierType (verifierType)
505 , m_minimumVersion (minVersion)
509 CombinedUniformComponentsCase::IterateResult CombinedUniformComponentsCase::iterate (void)
511 TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(m_context.getRenderContext().getType(), m_minimumVersion), "Test not supported in this context.");
513 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
514 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
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
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
528 gl.enableLogging(true);
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;
534 StateQueryMemoryWriteGuard<glw::GLint> maxUniformBlocks;
535 gl.glGetIntegerv(maxUniformBlocksEnum, &maxUniformBlocks);
536 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv");
538 StateQueryMemoryWriteGuard<glw::GLint> maxUniformBlockSize;
539 gl.glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &maxUniformBlockSize);
540 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv");
542 StateQueryMemoryWriteGuard<glw::GLint> maxUniformComponents;
543 gl.glGetIntegerv(maxUniformComponentsEnum, &maxUniformComponents);
544 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv");
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);
549 result.setTestContextResult(m_testCtx);
553 class TextureGatherLimitCase : public TestCase
556 TextureGatherLimitCase (Context& context, const char* name, const char* desc, bool isMaxCase, QueryType verifierType);
558 IterateResult iterate (void);
560 const bool m_isMaxCase;
561 const QueryType m_verifierType;
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)
571 TextureGatherLimitCase::IterateResult TextureGatherLimitCase::iterate (void)
573 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
574 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
576 gl.enableLogging(true);
581 verifyStateIntegerMin(result, gl, GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET, 0, m_verifierType);
586 verifyStateIntegerMax(result, gl, GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET, 0, m_verifierType);
589 result.setTestContextResult(m_testCtx);
593 class MaxUniformBufferBindingsCase : public TestCase
596 MaxUniformBufferBindingsCase (Context& context, const char* name, const char* desc, QueryType verifierType);
598 IterateResult iterate (void);
600 const QueryType m_verifierType;
603 MaxUniformBufferBindingsCase::MaxUniformBufferBindingsCase (Context& context, const char* name, const char* desc, QueryType verifierType)
604 : TestCase (context, name, desc)
605 , m_verifierType (verifierType)
609 MaxUniformBufferBindingsCase::IterateResult MaxUniformBufferBindingsCase::iterate (void)
611 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
612 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
615 gl.enableLogging(true);
617 if (contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)))
623 if (m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader"))
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;
630 else if (m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
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;
644 verifyStateIntegerMin(result, gl, GL_MAX_UNIFORM_BUFFER_BINDINGS, minMax, m_verifierType);
646 result.setTestContextResult(m_testCtx);
650 class MaxCombinedUniformBlocksCase : public TestCase
653 MaxCombinedUniformBlocksCase (Context& context, const char* name, const char* desc, QueryType verifierType);
655 IterateResult iterate (void);
657 const QueryType m_verifierType;
660 MaxCombinedUniformBlocksCase::MaxCombinedUniformBlocksCase (Context& context, const char* name, const char* desc, QueryType verifierType)
661 : TestCase (context, name, desc)
662 , m_verifierType (verifierType)
666 MaxCombinedUniformBlocksCase::IterateResult MaxCombinedUniformBlocksCase::iterate (void)
668 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
669 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
672 gl.enableLogging(true);
674 if (contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)))
680 if (m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader"))
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;
687 else if (m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
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;
701 verifyStateIntegerMin(result, gl, GL_MAX_COMBINED_UNIFORM_BLOCKS, minMax, m_verifierType);
703 result.setTestContextResult(m_testCtx);
707 class MaxCombinedTexImageUnitsCase : public TestCase
710 MaxCombinedTexImageUnitsCase (Context& context, const char* name, const char* desc, QueryType verifierType);
712 IterateResult iterate (void);
714 const QueryType m_verifierType;
717 MaxCombinedTexImageUnitsCase::MaxCombinedTexImageUnitsCase (Context& context, const char* name, const char* desc, QueryType verifierType)
718 : TestCase (context, name, desc)
719 , m_verifierType (verifierType)
723 MaxCombinedTexImageUnitsCase::IterateResult MaxCombinedTexImageUnitsCase::iterate (void)
725 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
726 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
729 gl.enableLogging(true);
730 if (contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)))
736 if (m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader"))
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;
743 else if (m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
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;
757 verifyStateIntegerMin(result, gl, GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, minMax, m_verifierType);
759 result.setTestContextResult(m_testCtx);
765 IntegerStateQueryTests::IntegerStateQueryTests (Context& context)
766 : TestCaseGroup(context, "integer", "Integer state query tests")
770 IntegerStateQueryTests::~IntegerStateQueryTests (void)
774 void IntegerStateQueryTests::init (void)
777 const QueryType verifiers[] = { QUERY_BOOLEAN, QUERY_INTEGER, QUERY_INTEGER64, QUERY_FLOAT };
779 #define FOR_EACH_VERIFIER(X) \
780 for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx) \
782 const char* verifierSuffix = getVerifierSuffix(verifiers[verifierNdx]); \
783 const QueryType verifier = verifiers[verifierNdx]; \
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))
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))
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))
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))
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))
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))
812 FOR_EACH_VERIFIER(new ProgramPipelineBindingCase(m_context, (std::string() + "program_pipeline_binding_" + verifierSuffix).c_str(), "Test PROGRAM_PIPELINE_BINDING", verifier))
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))
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))
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))
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))
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))
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))
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))
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)))
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)))
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)))
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)))
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)))
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)))
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)))
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)))
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)))
924 #undef FOR_EACH_VERIFIER