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