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