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 (state < GLfloat(reference)) 831 { 832 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLfloat(reference) << "; got " << 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 GLfloat viewportBoundsRange[2] = {0.0f}; 1152 GLboolean hasViewportArray = false; 1153 glGetIntegerv(GL_MAX_VIEWPORT_DIMS, maxViewportDimensions); 1154 hasViewportArray = m_context.getContextInfo().isExtensionSupported("GL_OES_viewport_array") || 1155 m_context.getContextInfo().isExtensionSupported("GL_NV_viewport_array") || 1156 m_context.getContextInfo().isExtensionSupported("GL_ARB_viewport_array"); 1157 if (hasViewportArray) 1158 { 1159 glGetFloatv(GL_VIEWPORT_BOUNDS_RANGE, viewportBoundsRange); 1160 } 1161 1162 // verify initial value of first two values 1163 m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT, 0, 0, m_context.getRenderTarget().getWidth(), m_context.getRenderTarget().getHeight()); 1164 expectError(GL_NO_ERROR); 1165 1166 const int numIterations = 120; 1167 for (int i = 0; i < numIterations; ++i) 1168 { 1169 GLint x = rnd.getInt(-64000, 64000); 1170 GLint y = rnd.getInt(-64000, 64000); 1171 GLsizei width = rnd.getInt(0, maxViewportDimensions[0]); 1172 GLsizei height = rnd.getInt(0, maxViewportDimensions[1]); 1173 1174 glViewport(x, y, width, height); 1175 1176 if (hasViewportArray) 1177 { 1178 m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT, 1179 de::clamp(x, deFloorFloatToInt32(viewportBoundsRange[0]), deFloorFloatToInt32(viewportBoundsRange[1])), 1180 de::clamp(y, deFloorFloatToInt32(viewportBoundsRange[0]), deFloorFloatToInt32(viewportBoundsRange[1])), 1181 width, height); 1182 } 1183 else 1184 { 1185 m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT, x, y, width, height); 1186 } 1187 1188 expectError(GL_NO_ERROR); 1189 } 1190 } 1191 1192private: 1193 StateVerifier* m_verifier; 1194}; 1195 1196class ScissorBoxTestCase : public ApiCase 1197{ 1198public: 1199 ScissorBoxTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 1200 : ApiCase (context, name, description) 1201 , m_verifier (verifier) 1202 { 1203 } 1204 1205 void test (void) 1206 { 1207 de::Random rnd(0xabcdef); 1208 1209 // verify initial value of first two values 1210 m_verifier->verifyInteger4Mask(m_testCtx, GL_SCISSOR_BOX, 0, true, 0, true, 0, false, 0, false); 1211 expectError(GL_NO_ERROR); 1212 1213 const int numIterations = 120; 1214 for (int i = 0; i < numIterations; ++i) 1215 { 1216 GLint left = rnd.getInt(-64000, 64000); 1217 GLint bottom = rnd.getInt(-64000, 64000); 1218 GLsizei width = rnd.getInt(0, 64000); 1219 GLsizei height = rnd.getInt(0, 64000); 1220 1221 glScissor(left, bottom, width, height); 1222 m_verifier->verifyInteger4(m_testCtx, GL_SCISSOR_BOX, left, bottom, width, height); 1223 expectError(GL_NO_ERROR); 1224 } 1225 } 1226private: 1227 StateVerifier* m_verifier; 1228}; 1229 1230class MaxViewportDimsTestCase : public ApiCase 1231{ 1232public: 1233 MaxViewportDimsTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 1234 : ApiCase (context, name, description) 1235 , m_verifier (verifier) 1236 { 1237 } 1238 1239 void test (void) 1240 { 1241 m_verifier->verifyIntegerGreaterOrEqual2(m_testCtx, GL_MAX_VIEWPORT_DIMS, m_context.getRenderTarget().getWidth(), m_context.getRenderTarget().getHeight()); 1242 expectError(GL_NO_ERROR); 1243 } 1244private: 1245 StateVerifier* m_verifier; 1246}; 1247 1248class StencilRefTestCase : public ApiCase 1249{ 1250public: 1251 StencilRefTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName) 1252 : ApiCase (context, name, description) 1253 , m_verifier (verifier) 1254 , m_testTargetName (testTargetName) 1255 { 1256 } 1257 1258 void test (void) 1259 { 1260 m_verifier->verifyInteger(m_testCtx, m_testTargetName, 0); 1261 expectError(GL_NO_ERROR); 1262 1263 const int stencilBits = m_context.getRenderTarget().getStencilBits(); 1264 1265 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit) 1266 { 1267 const int ref = 1 << stencilBit; 1268 1269 glStencilFunc(GL_ALWAYS, ref, 0); // mask should not affect the REF 1270 expectError(GL_NO_ERROR); 1271 1272 m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref); 1273 expectError(GL_NO_ERROR); 1274 1275 glStencilFunc(GL_ALWAYS, ref, ref); 1276 expectError(GL_NO_ERROR); 1277 1278 m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref); 1279 expectError(GL_NO_ERROR); 1280 } 1281 } 1282 1283private: 1284 StateVerifier* m_verifier; 1285 GLenum m_testTargetName; 1286}; 1287 1288class StencilRefSeparateTestCase : public ApiCase 1289{ 1290public: 1291 StencilRefSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, GLenum stencilFuncTargetFace) 1292 : ApiCase (context, name, description) 1293 , m_verifier (verifier) 1294 , m_testTargetName (testTargetName) 1295 , m_stencilFuncTargetFace (stencilFuncTargetFace) 1296 { 1297 } 1298 1299 void test (void) 1300 { 1301 m_verifier->verifyInteger(m_testCtx, m_testTargetName, 0); 1302 expectError(GL_NO_ERROR); 1303 1304 const int stencilBits = m_context.getRenderTarget().getStencilBits(); 1305 1306 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit) 1307 { 1308 const int ref = 1 << stencilBit; 1309 1310 glStencilFuncSeparate(m_stencilFuncTargetFace, GL_ALWAYS, ref, 0); 1311 expectError(GL_NO_ERROR); 1312 1313 m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref); 1314 expectError(GL_NO_ERROR); 1315 1316 glStencilFuncSeparate(m_stencilFuncTargetFace, GL_ALWAYS, ref, ref); 1317 expectError(GL_NO_ERROR); 1318 1319 m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref); 1320 expectError(GL_NO_ERROR); 1321 } 1322 } 1323private: 1324 StateVerifier* m_verifier; 1325 GLenum m_testTargetName; 1326 GLenum m_stencilFuncTargetFace; 1327}; 1328 1329class StencilOpTestCase : public ApiCase 1330{ 1331public: 1332 StencilOpTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum stencilOpName) 1333 : ApiCase (context, name, description) 1334 , m_verifier (verifier) 1335 , m_stencilOpName (stencilOpName) 1336 { 1337 } 1338 1339 void test (void) 1340 { 1341 m_verifier->verifyInteger(m_testCtx, m_stencilOpName, GL_KEEP); 1342 expectError(GL_NO_ERROR); 1343 1344 const GLenum stencilOpValues[] = {GL_KEEP, GL_ZERO, GL_REPLACE, GL_INCR, GL_DECR, GL_INVERT, GL_INCR_WRAP, GL_DECR_WRAP}; 1345 1346 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stencilOpValues); ++ndx) 1347 { 1348 SetStencilOp(stencilOpValues[ndx]); 1349 expectError(GL_NO_ERROR); 1350 1351 m_verifier->verifyInteger(m_testCtx, m_stencilOpName, stencilOpValues[ndx]); 1352 expectError(GL_NO_ERROR); 1353 } 1354 } 1355 1356protected: 1357 virtual void SetStencilOp (GLenum stencilOpValue) 1358 { 1359 switch (m_stencilOpName) 1360 { 1361 case GL_STENCIL_FAIL: 1362 case GL_STENCIL_BACK_FAIL: 1363 glStencilOp(stencilOpValue, GL_KEEP, GL_KEEP); 1364 break; 1365 1366 case GL_STENCIL_PASS_DEPTH_FAIL: 1367 case GL_STENCIL_BACK_PASS_DEPTH_FAIL: 1368 glStencilOp(GL_KEEP, stencilOpValue, GL_KEEP); 1369 break; 1370 1371 case GL_STENCIL_PASS_DEPTH_PASS: 1372 case GL_STENCIL_BACK_PASS_DEPTH_PASS: 1373 glStencilOp(GL_KEEP, GL_KEEP, stencilOpValue); 1374 break; 1375 1376 default: 1377 DE_ASSERT(false && "should not happen"); 1378 break; 1379 } 1380 } 1381 1382 StateVerifier* m_verifier; 1383 GLenum m_stencilOpName; 1384}; 1385 1386 1387class StencilOpSeparateTestCase : public StencilOpTestCase 1388{ 1389public: 1390 StencilOpSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum stencilOpName, GLenum stencilOpFace) 1391 : StencilOpTestCase (context, verifier, name, description, stencilOpName) 1392 , m_stencilOpFace (stencilOpFace) 1393 { 1394 } 1395 1396private: 1397 void SetStencilOp (GLenum stencilOpValue) 1398 { 1399 switch (m_stencilOpName) 1400 { 1401 case GL_STENCIL_FAIL: 1402 case GL_STENCIL_BACK_FAIL: 1403 glStencilOpSeparate(m_stencilOpFace, stencilOpValue, GL_KEEP, GL_KEEP); 1404 break; 1405 1406 case GL_STENCIL_PASS_DEPTH_FAIL: 1407 case GL_STENCIL_BACK_PASS_DEPTH_FAIL: 1408 glStencilOpSeparate(m_stencilOpFace, GL_KEEP, stencilOpValue, GL_KEEP); 1409 break; 1410 1411 case GL_STENCIL_PASS_DEPTH_PASS: 1412 case GL_STENCIL_BACK_PASS_DEPTH_PASS: 1413 glStencilOpSeparate(m_stencilOpFace, GL_KEEP, GL_KEEP, stencilOpValue); 1414 break; 1415 1416 default: 1417 DE_ASSERT(false && "should not happen"); 1418 break; 1419 } 1420 } 1421 1422 GLenum m_stencilOpFace; 1423}; 1424 1425class StencilFuncTestCase : public ApiCase 1426{ 1427public: 1428 StencilFuncTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 1429 : ApiCase (context, name, description) 1430 , m_verifier (verifier) 1431 { 1432 } 1433 1434 void test (void) 1435 { 1436 m_verifier->verifyInteger(m_testCtx, GL_STENCIL_FUNC, GL_ALWAYS); 1437 expectError(GL_NO_ERROR); 1438 1439 const GLenum stencilfuncValues[] = {GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL, GL_EQUAL, GL_GEQUAL, GL_GREATER, GL_NOTEQUAL}; 1440 1441 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stencilfuncValues); ++ndx) 1442 { 1443 glStencilFunc(stencilfuncValues[ndx], 0, 0); 1444 expectError(GL_NO_ERROR); 1445 1446 m_verifier->verifyInteger(m_testCtx, GL_STENCIL_FUNC, stencilfuncValues[ndx]); 1447 expectError(GL_NO_ERROR); 1448 1449 m_verifier->verifyInteger(m_testCtx, GL_STENCIL_BACK_FUNC, stencilfuncValues[ndx]); 1450 expectError(GL_NO_ERROR); 1451 } 1452 } 1453private: 1454 StateVerifier* m_verifier; 1455}; 1456 1457class StencilFuncSeparateTestCase : public ApiCase 1458{ 1459public: 1460 StencilFuncSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum stencilFuncName, GLenum stencilFuncFace) 1461 : ApiCase (context, name, description) 1462 , m_verifier (verifier) 1463 , m_stencilFuncName (stencilFuncName) 1464 , m_stencilFuncFace (stencilFuncFace) 1465 { 1466 } 1467 1468 void test (void) 1469 { 1470 m_verifier->verifyInteger(m_testCtx, m_stencilFuncName, GL_ALWAYS); 1471 expectError(GL_NO_ERROR); 1472 1473 const GLenum stencilfuncValues[] = {GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL, GL_EQUAL, GL_GEQUAL, GL_GREATER, GL_NOTEQUAL}; 1474 1475 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stencilfuncValues); ++ndx) 1476 { 1477 glStencilFuncSeparate(m_stencilFuncFace, stencilfuncValues[ndx], 0, 0); 1478 expectError(GL_NO_ERROR); 1479 1480 m_verifier->verifyInteger(m_testCtx, m_stencilFuncName, stencilfuncValues[ndx]); 1481 expectError(GL_NO_ERROR); 1482 } 1483 } 1484private: 1485 StateVerifier* m_verifier; 1486 GLenum m_stencilFuncName; 1487 GLenum m_stencilFuncFace; 1488}; 1489 1490class StencilMaskTestCase : public ApiCase 1491{ 1492public: 1493 StencilMaskTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName) 1494 : ApiCase (context, name, description) 1495 , m_verifier (verifier) 1496 , m_testTargetName (testTargetName) 1497 { 1498 } 1499 1500 void test (void) 1501 { 1502 const int stencilBits = m_context.getRenderTarget().getStencilBits(); 1503 1504 m_verifier->verifyStencilMaskInitial(m_testCtx, m_testTargetName, stencilBits); 1505 expectError(GL_NO_ERROR); 1506 1507 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit) 1508 { 1509 const int mask = 1 << stencilBit; 1510 1511 glStencilFunc(GL_ALWAYS, 0, mask); 1512 expectError(GL_NO_ERROR); 1513 1514 m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask); 1515 expectError(GL_NO_ERROR); 1516 } 1517 } 1518private: 1519 StateVerifier* m_verifier; 1520 GLenum m_testTargetName; 1521}; 1522 1523class StencilMaskSeparateTestCase : public ApiCase 1524{ 1525public: 1526 StencilMaskSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, GLenum stencilFuncTargetFace) 1527 : ApiCase (context, name, description) 1528 , m_verifier (verifier) 1529 , m_testTargetName (testTargetName) 1530 , m_stencilFuncTargetFace (stencilFuncTargetFace) 1531 { 1532 } 1533 1534 void test (void) 1535 { 1536 const int stencilBits = m_context.getRenderTarget().getStencilBits(); 1537 1538 m_verifier->verifyStencilMaskInitial(m_testCtx, m_testTargetName, stencilBits); 1539 expectError(GL_NO_ERROR); 1540 1541 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit) 1542 { 1543 const int mask = 1 << stencilBit; 1544 1545 glStencilFuncSeparate(m_stencilFuncTargetFace, GL_ALWAYS, 0, mask); 1546 expectError(GL_NO_ERROR); 1547 1548 m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask); 1549 expectError(GL_NO_ERROR); 1550 } 1551 } 1552private: 1553 StateVerifier* m_verifier; 1554 GLenum m_testTargetName; 1555 GLenum m_stencilFuncTargetFace; 1556}; 1557 1558class StencilWriteMaskTestCase : public ApiCase 1559{ 1560public: 1561 StencilWriteMaskTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName) 1562 : ApiCase (context, name, description) 1563 , m_verifier (verifier) 1564 , m_testTargetName (testTargetName) 1565 { 1566 } 1567 1568 void test (void) 1569 { 1570 const int stencilBits = m_context.getRenderTarget().getStencilBits(); 1571 1572 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit) 1573 { 1574 const int mask = 1 << stencilBit; 1575 1576 glStencilMask(mask); 1577 expectError(GL_NO_ERROR); 1578 1579 m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask); 1580 expectError(GL_NO_ERROR); 1581 } 1582 } 1583private: 1584 StateVerifier* m_verifier; 1585 GLenum m_testTargetName; 1586}; 1587 1588class StencilWriteMaskSeparateTestCase : public ApiCase 1589{ 1590public: 1591 StencilWriteMaskSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, GLenum stencilTargetFace) 1592 : ApiCase (context, name, description) 1593 , m_verifier (verifier) 1594 , m_testTargetName (testTargetName) 1595 , m_stencilTargetFace (stencilTargetFace) 1596 { 1597 } 1598 1599 void test (void) 1600 { 1601 const int stencilBits = m_context.getRenderTarget().getStencilBits(); 1602 1603 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit) 1604 { 1605 const int mask = 1 << stencilBit; 1606 1607 glStencilMaskSeparate(m_stencilTargetFace, mask); 1608 expectError(GL_NO_ERROR); 1609 1610 m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask); 1611 expectError(GL_NO_ERROR); 1612 } 1613 } 1614private: 1615 StateVerifier* m_verifier; 1616 GLenum m_testTargetName; 1617 GLenum m_stencilTargetFace; 1618}; 1619 1620class PixelStoreTestCase : public ApiCase 1621{ 1622public: 1623 PixelStoreTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue) 1624 : ApiCase (context, name, description) 1625 , m_verifier (verifier) 1626 , m_testTargetName (testTargetName) 1627 , m_initialValue (initialValue) 1628 { 1629 } 1630 1631 void test (void) 1632 { 1633 de::Random rnd(0xabcdef); 1634 1635 m_verifier->verifyInteger(m_testCtx, m_testTargetName, m_initialValue); 1636 expectError(GL_NO_ERROR); 1637 1638 const int numIterations = 120; 1639 for (int i = 0; i < numIterations; ++i) 1640 { 1641 const int referenceValue = rnd.getInt(0, 64000); 1642 1643 glPixelStorei(m_testTargetName, referenceValue); 1644 expectError(GL_NO_ERROR); 1645 1646 m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue); 1647 expectError(GL_NO_ERROR); 1648 } 1649 } 1650 1651private: 1652 StateVerifier* m_verifier; 1653 GLenum m_testTargetName; 1654 int m_initialValue; 1655}; 1656 1657class PixelStoreAlignTestCase : public ApiCase 1658{ 1659public: 1660 PixelStoreAlignTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName) 1661 : ApiCase (context, name, description) 1662 , m_verifier (verifier) 1663 , m_testTargetName (testTargetName) 1664 { 1665 } 1666 1667 void test (void) 1668 { 1669 m_verifier->verifyInteger(m_testCtx, m_testTargetName, 4); 1670 expectError(GL_NO_ERROR); 1671 1672 const int alignments[] = {1, 2, 4, 8}; 1673 1674 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(alignments); ++ndx) 1675 { 1676 const int referenceValue = alignments[ndx]; 1677 1678 glPixelStorei(m_testTargetName, referenceValue); 1679 expectError(GL_NO_ERROR); 1680 1681 m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue); 1682 expectError(GL_NO_ERROR); 1683 } 1684 } 1685 1686private: 1687 StateVerifier* m_verifier; 1688 GLenum m_testTargetName; 1689}; 1690 1691class BlendFuncTestCase : public ApiCase 1692{ 1693public: 1694 BlendFuncTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue) 1695 : ApiCase (context, name, description) 1696 , m_verifier (verifier) 1697 , m_testTargetName (testTargetName) 1698 , m_initialValue (initialValue) 1699 { 1700 } 1701 1702 void test (void) 1703 { 1704 m_verifier->verifyInteger(m_testCtx, m_testTargetName, m_initialValue); 1705 expectError(GL_NO_ERROR); 1706 1707 const GLenum blendFuncValues[] = 1708 { 1709 GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, 1710 GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_CONSTANT_COLOR, 1711 GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, 1712 GL_SRC_ALPHA_SATURATE 1713 }; 1714 1715 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(blendFuncValues); ++ndx) 1716 { 1717 const GLenum referenceValue = blendFuncValues[ndx]; 1718 1719 SetBlendFunc(referenceValue); 1720 expectError(GL_NO_ERROR); 1721 1722 m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue); 1723 expectError(GL_NO_ERROR); 1724 } 1725 } 1726protected: 1727 virtual void SetBlendFunc (GLenum func) 1728 { 1729 switch (m_testTargetName) 1730 { 1731 case GL_BLEND_SRC_RGB: 1732 case GL_BLEND_SRC_ALPHA: 1733 glBlendFunc(func, GL_ZERO); 1734 break; 1735 1736 case GL_BLEND_DST_RGB: 1737 case GL_BLEND_DST_ALPHA: 1738 glBlendFunc(GL_ZERO, func); 1739 break; 1740 1741 default: 1742 DE_ASSERT(false && "should not happen"); 1743 break; 1744 } 1745 } 1746 1747 StateVerifier* m_verifier; 1748 GLenum m_testTargetName; 1749 int m_initialValue; 1750}; 1751 1752class BlendFuncSeparateTestCase : public BlendFuncTestCase 1753{ 1754public: 1755 BlendFuncSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue) 1756 : BlendFuncTestCase (context, verifier, name, description, testTargetName, initialValue) 1757 { 1758 } 1759 1760 void SetBlendFunc (GLenum func) 1761 { 1762 switch (m_testTargetName) 1763 { 1764 case GL_BLEND_SRC_RGB: 1765 glBlendFuncSeparate(func, GL_ZERO, GL_ZERO, GL_ZERO); 1766 break; 1767 1768 case GL_BLEND_DST_RGB: 1769 glBlendFuncSeparate(GL_ZERO, func, GL_ZERO, GL_ZERO); 1770 break; 1771 1772 case GL_BLEND_SRC_ALPHA: 1773 glBlendFuncSeparate(GL_ZERO, GL_ZERO, func, GL_ZERO); 1774 break; 1775 1776 case GL_BLEND_DST_ALPHA: 1777 glBlendFuncSeparate(GL_ZERO, GL_ZERO, GL_ZERO, func); 1778 break; 1779 1780 default: 1781 DE_ASSERT(false && "should not happen"); 1782 break; 1783 } 1784 } 1785}; 1786 1787class BlendEquationTestCase : public ApiCase 1788{ 1789public: 1790 BlendEquationTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue) 1791 : ApiCase (context, name, description) 1792 , m_verifier (verifier) 1793 , m_testTargetName (testTargetName) 1794 , m_initialValue (initialValue) 1795 { 1796 } 1797 1798 void test (void) 1799 { 1800 m_verifier->verifyInteger(m_testCtx, m_testTargetName, m_initialValue); 1801 expectError(GL_NO_ERROR); 1802 1803 const GLenum blendFuncValues[] = 1804 { 1805 GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX 1806 }; 1807 1808 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(blendFuncValues); ++ndx) 1809 { 1810 const GLenum referenceValue = blendFuncValues[ndx]; 1811 1812 SetBlendEquation(referenceValue); 1813 expectError(GL_NO_ERROR); 1814 1815 m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue); 1816 expectError(GL_NO_ERROR); 1817 } 1818 } 1819protected: 1820 virtual void SetBlendEquation (GLenum equation) 1821 { 1822 glBlendEquation(equation); 1823 } 1824 1825 StateVerifier* m_verifier; 1826 GLenum m_testTargetName; 1827 int m_initialValue; 1828}; 1829class BlendEquationSeparateTestCase : public BlendEquationTestCase 1830{ 1831public: 1832 BlendEquationSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue) 1833 : BlendEquationTestCase (context, verifier, name, description, testTargetName, initialValue) 1834 { 1835 } 1836 1837protected: 1838 void SetBlendEquation (GLenum equation) 1839 { 1840 switch (m_testTargetName) 1841 { 1842 case GL_BLEND_EQUATION_RGB: 1843 glBlendEquationSeparate(equation, GL_FUNC_ADD); 1844 break; 1845 1846 case GL_BLEND_EQUATION_ALPHA: 1847 glBlendEquationSeparate(GL_FUNC_ADD, equation); 1848 break; 1849 1850 default: 1851 DE_ASSERT(false && "should not happen"); 1852 break; 1853 } 1854 } 1855}; 1856 1857class ImplementationArrayTestCase : public ApiCase 1858{ 1859public: 1860 ImplementationArrayTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, GLenum testTargetLengthTargetName, int minValue) 1861 : ApiCase (context, name, description) 1862 , m_verifier (verifier) 1863 , m_testTargetName (testTargetName) 1864 , m_testTargetLengthTargetName (testTargetLengthTargetName) 1865 , m_minValue (minValue) 1866 { 1867 } 1868 1869 void test (void) 1870 { 1871 m_verifier->verifyIntegerGreaterOrEqual(m_testCtx, m_testTargetLengthTargetName, m_minValue); 1872 expectError(GL_NO_ERROR); 1873 1874 GLint targetArrayLength = 0; 1875 glGetIntegerv(m_testTargetLengthTargetName, &targetArrayLength); 1876 expectError(GL_NO_ERROR); 1877 1878 if (targetArrayLength) 1879 { 1880 std::vector<GLint> queryResult; 1881 queryResult.resize(targetArrayLength, 0); 1882 1883 glGetIntegerv(m_testTargetName, &queryResult[0]); 1884 expectError(GL_NO_ERROR); 1885 } 1886 } 1887 1888private: 1889 StateVerifier* m_verifier; 1890 GLenum m_testTargetName; 1891 GLenum m_testTargetLengthTargetName; 1892 int m_minValue; 1893}; 1894 1895class BindingTest : public TestCase 1896{ 1897public: 1898 BindingTest (Context& context, 1899 const char* name, 1900 const char* desc, 1901 QueryType type); 1902 1903 IterateResult iterate (void); 1904 1905 virtual void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const = 0; 1906 1907protected: 1908 const QueryType m_type; 1909}; 1910 1911BindingTest::BindingTest (Context& context, 1912 const char* name, 1913 const char* desc, 1914 QueryType type) 1915 : TestCase (context, name, desc) 1916 , m_type (type) 1917{ 1918} 1919 1920BindingTest::IterateResult BindingTest::iterate (void) 1921{ 1922 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog()); 1923 tcu::ResultCollector result (m_context.getTestContext().getLog(), " // ERROR: "); 1924 1925 gl.enableLogging(true); 1926 1927 test(gl, result); 1928 1929 result.setTestContextResult(m_testCtx); 1930 return STOP; 1931} 1932 1933class TransformFeedbackBindingTestCase : public BindingTest 1934{ 1935public: 1936 TransformFeedbackBindingTestCase (Context& context, QueryType type, const char* name) 1937 : BindingTest(context, name, "GL_TRANSFORM_FEEDBACK_BINDING", type) 1938 { 1939 } 1940 1941 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const 1942 { 1943 static const char* transformFeedbackTestVertSource = 1944 "#version 300 es\n" 1945 "void main (void)\n" 1946 "{\n" 1947 " gl_Position = vec4(0.0);\n" 1948 "}\n\0"; 1949 static const char* transformFeedbackTestFragSource = 1950 "#version 300 es\n" 1951 "layout(location = 0) out mediump vec4 fragColor;" 1952 "void main (void)\n" 1953 "{\n" 1954 " fragColor = vec4(0.0);\n" 1955 "}\n\0"; 1956 1957 GLuint shaderVert; 1958 GLuint shaderFrag; 1959 GLuint shaderProg; 1960 GLuint transformfeedback = 0; 1961 GLuint feedbackBufferId = 0; 1962 1963 { 1964 const tcu::ScopedLogSection section(gl.getLog(), "Initial", "Initial"); 1965 verifyStateInteger(result, gl, GL_TRANSFORM_FEEDBACK_BINDING, 0, m_type); 1966 } 1967 1968 gl.glGenTransformFeedbacks(1, &transformfeedback); 1969 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenTransformFeedbacks"); 1970 1971 { 1972 const tcu::ScopedLogSection section(gl.getLog(), "VertexShader", "Vertex Shader"); 1973 1974 GLint compileStatus = -1; 1975 1976 shaderVert = gl.glCreateShader(GL_VERTEX_SHADER); 1977 gl.glShaderSource(shaderVert, 1, &transformFeedbackTestVertSource, DE_NULL); 1978 gl.glCompileShader(shaderVert); 1979 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glCompileShader"); 1980 1981 gl.glGetShaderiv(shaderVert, GL_COMPILE_STATUS, &compileStatus); 1982 if (compileStatus != GL_TRUE) 1983 result.fail("expected GL_TRUE"); 1984 } 1985 { 1986 const tcu::ScopedLogSection section(gl.getLog(), "FragmentShader", "Fragment Shader"); 1987 1988 GLint compileStatus = -1; 1989 1990 shaderFrag = gl.glCreateShader(GL_FRAGMENT_SHADER); 1991 gl.glShaderSource(shaderFrag, 1, &transformFeedbackTestFragSource, DE_NULL); 1992 gl.glCompileShader(shaderFrag); 1993 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glCompileShader"); 1994 1995 gl.glGetShaderiv(shaderFrag, GL_COMPILE_STATUS, &compileStatus); 1996 if (compileStatus != GL_TRUE) 1997 result.fail("expected GL_TRUE"); 1998 } 1999 { 2000 const tcu::ScopedLogSection section(gl.getLog(), "Program", "Create and bind program"); 2001 2002 const char* transform_feedback_outputs = "gl_Position"; 2003 GLint linkStatus = -1; 2004 2005 shaderProg = gl.glCreateProgram(); 2006 gl.glAttachShader(shaderProg, shaderVert); 2007 gl.glAttachShader(shaderProg, shaderFrag); 2008 gl.glTransformFeedbackVaryings(shaderProg, 1, &transform_feedback_outputs, GL_INTERLEAVED_ATTRIBS); 2009 gl.glLinkProgram(shaderProg); 2010 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glLinkProgram"); 2011 2012 gl.glGetProgramiv(shaderProg, GL_LINK_STATUS, &linkStatus); 2013 if (linkStatus != GL_TRUE) 2014 result.fail("expected GL_TRUE"); 2015 } 2016 2017 gl.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformfeedback); 2018 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTransformFeedback"); 2019 2020 gl.glGenBuffers(1, &feedbackBufferId); 2021 gl.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackBufferId); 2022 gl.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_DYNAMIC_READ); 2023 gl.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, feedbackBufferId); 2024 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind buffers"); 2025 2026 gl.glUseProgram(shaderProg); 2027 2028 verifyStateInteger(result, gl, GL_TRANSFORM_FEEDBACK_BINDING, transformfeedback, m_type); 2029 2030 gl.glUseProgram(0); 2031 gl.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); 2032 gl.glDeleteTransformFeedbacks(1, &transformfeedback); 2033 2034 verifyStateInteger(result, gl, GL_TRANSFORM_FEEDBACK_BINDING, 0, m_type); 2035 2036 gl.glDeleteBuffers(1, &feedbackBufferId); 2037 gl.glDeleteShader(shaderVert); 2038 gl.glDeleteShader(shaderFrag); 2039 gl.glDeleteProgram(shaderProg); 2040 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteProgram"); 2041 } 2042}; 2043 2044class CurrentProgramBindingTestCase : public BindingTest 2045{ 2046public: 2047 CurrentProgramBindingTestCase (Context& context, QueryType type, const char* name, const char* description) 2048 : BindingTest(context, name, description, type) 2049 { 2050 } 2051 2052 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const 2053 { 2054 static const char* testVertSource = 2055 "#version 300 es\n" 2056 "void main (void)\n" 2057 "{\n" 2058 " gl_Position = vec4(0.0);\n" 2059 "}\n\0"; 2060 static const char* testFragSource = 2061 "#version 300 es\n" 2062 "layout(location = 0) out mediump vec4 fragColor;" 2063 "void main (void)\n" 2064 "{\n" 2065 " fragColor = vec4(0.0);\n" 2066 "}\n\0"; 2067 2068 GLuint shaderVert; 2069 GLuint shaderFrag; 2070 GLuint shaderProg; 2071 2072 { 2073 const tcu::ScopedLogSection section(gl.getLog(), "Initial", "Initial"); 2074 2075 verifyStateInteger(result, gl, GL_CURRENT_PROGRAM, 0, m_type); 2076 } 2077 { 2078 const tcu::ScopedLogSection section(gl.getLog(), "VertexShader", "Vertex Shader"); 2079 2080 GLint compileStatus = -1; 2081 2082 shaderVert = gl.glCreateShader(GL_VERTEX_SHADER); 2083 gl.glShaderSource(shaderVert, 1, &testVertSource, DE_NULL); 2084 gl.glCompileShader(shaderVert); 2085 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glCompileShader"); 2086 2087 gl.glGetShaderiv(shaderVert, GL_COMPILE_STATUS, &compileStatus); 2088 if (compileStatus != GL_TRUE) 2089 result.fail("expected GL_TRUE"); 2090 } 2091 { 2092 const tcu::ScopedLogSection section(gl.getLog(), "FragmentShader", "Fragment Shader"); 2093 2094 GLint compileStatus = -1; 2095 2096 shaderFrag = gl.glCreateShader(GL_FRAGMENT_SHADER); 2097 gl.glShaderSource(shaderFrag, 1, &testFragSource, DE_NULL); 2098 gl.glCompileShader(shaderFrag); 2099 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glCompileShader"); 2100 2101 gl.glGetShaderiv(shaderFrag, GL_COMPILE_STATUS, &compileStatus); 2102 if (compileStatus != GL_TRUE) 2103 result.fail("expected GL_TRUE"); 2104 } 2105 { 2106 const tcu::ScopedLogSection section(gl.getLog(), "Program", "Create and bind program"); 2107 2108 GLint linkStatus = -1; 2109 2110 shaderProg = gl.glCreateProgram(); 2111 gl.glAttachShader(shaderProg, shaderVert); 2112 gl.glAttachShader(shaderProg, shaderFrag); 2113 gl.glLinkProgram(shaderProg); 2114 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glLinkProgram"); 2115 2116 gl.glGetProgramiv(shaderProg, GL_LINK_STATUS, &linkStatus); 2117 if (linkStatus != GL_TRUE) 2118 result.fail("expected GL_TRUE"); 2119 2120 gl.glUseProgram(shaderProg); 2121 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glUseProgram"); 2122 2123 verifyStateInteger(result, gl, GL_CURRENT_PROGRAM, shaderProg, m_type); 2124 } 2125 { 2126 const tcu::ScopedLogSection section(gl.getLog(), "Delete", "Delete program while in use"); 2127 2128 gl.glDeleteShader(shaderVert); 2129 gl.glDeleteShader(shaderFrag); 2130 gl.glDeleteProgram(shaderProg); 2131 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteProgram"); 2132 2133 verifyStateInteger(result, gl, GL_CURRENT_PROGRAM, shaderProg, m_type); 2134 } 2135 { 2136 const tcu::ScopedLogSection section(gl.getLog(), "Unbind", "Unbind program"); 2137 gl.glUseProgram(0); 2138 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glUseProgram"); 2139 2140 verifyStateInteger(result, gl, GL_CURRENT_PROGRAM, 0, m_type); 2141 } 2142 } 2143}; 2144 2145class VertexArrayBindingTestCase : public BindingTest 2146{ 2147public: 2148 VertexArrayBindingTestCase (Context& context, QueryType type, const char* name, const char* description) 2149 : BindingTest(context, name, description, type) 2150 { 2151 } 2152 2153 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const 2154 { 2155 verifyStateInteger(result, gl, GL_VERTEX_ARRAY_BINDING, 0, m_type); 2156 2157 GLuint vertexArrayObject = 0; 2158 gl.glGenVertexArrays(1, &vertexArrayObject); 2159 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenVertexArrays"); 2160 2161 gl.glBindVertexArray(vertexArrayObject); 2162 verifyStateInteger(result, gl, GL_VERTEX_ARRAY_BINDING, vertexArrayObject, m_type); 2163 2164 gl.glDeleteVertexArrays(1, &vertexArrayObject); 2165 verifyStateInteger(result, gl, GL_VERTEX_ARRAY_BINDING, 0, m_type); 2166 } 2167}; 2168 2169class BufferBindingTestCase : public BindingTest 2170{ 2171public: 2172 BufferBindingTestCase (Context& context, QueryType type, const char* name, const char* description, GLenum bufferBindingName, GLenum bufferType) 2173 : BindingTest (context, name, description, type) 2174 , m_bufferBindingName (bufferBindingName) 2175 , m_bufferType (bufferType) 2176 { 2177 } 2178 2179 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const 2180 { 2181 verifyStateInteger(result, gl, m_bufferBindingName, 0, m_type); 2182 2183 GLuint bufferObject = 0; 2184 gl.glGenBuffers(1, &bufferObject); 2185 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenBuffers"); 2186 2187 gl.glBindBuffer(m_bufferType, bufferObject); 2188 verifyStateInteger(result, gl, m_bufferBindingName, bufferObject, m_type); 2189 2190 gl.glDeleteBuffers(1, &bufferObject); 2191 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteBuffers"); 2192 2193 verifyStateInteger(result, gl, m_bufferBindingName, 0, m_type); 2194 } 2195 2196private: 2197 const GLenum m_bufferBindingName; 2198 const GLenum m_bufferType; 2199}; 2200 2201class ElementArrayBufferBindingTestCase : public BindingTest 2202{ 2203public: 2204 ElementArrayBufferBindingTestCase (Context& context, QueryType type, const char* name) 2205 : BindingTest(context, name, "GL_ELEMENT_ARRAY_BUFFER_BINDING", type) 2206 { 2207 } 2208 2209 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const 2210 { 2211 // Test with default VAO 2212 { 2213 const tcu::ScopedLogSection section(gl.getLog(), "DefaultVAO", "Test with default VAO"); 2214 2215 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, 0, m_type); 2216 2217 GLuint bufferObject = 0; 2218 gl.glGenBuffers(1, &bufferObject); 2219 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenBuffers"); 2220 2221 gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferObject); 2222 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, bufferObject, m_type); 2223 2224 gl.glDeleteBuffers(1, &bufferObject); 2225 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, 0, m_type); 2226 } 2227 2228 // Test with multiple VAOs 2229 { 2230 const tcu::ScopedLogSection section(gl.getLog(), "WithVAO", "Test with VAO"); 2231 2232 GLuint vaos[2] = {0}; 2233 GLuint buffers[2] = {0}; 2234 2235 gl.glGenVertexArrays(2, vaos); 2236 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenVertexArrays"); 2237 2238 gl.glGenBuffers(2, buffers); 2239 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenBuffers"); 2240 2241 // initial 2242 gl.glBindVertexArray(vaos[0]); 2243 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, 0, m_type); 2244 2245 // after setting 2246 gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[0]); 2247 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, buffers[0], m_type); 2248 2249 // initial of vao 2 2250 gl.glBindVertexArray(vaos[1]); 2251 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, 0, m_type); 2252 2253 // after setting to 2 2254 gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]); 2255 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, buffers[1], m_type); 2256 2257 // vao 1 still has buffer 1 bound? 2258 gl.glBindVertexArray(vaos[0]); 2259 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, buffers[0], m_type); 2260 2261 // deleting clears from bound vaos ... 2262 gl.glDeleteBuffers(2, buffers); 2263 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, 0, m_type); 2264 2265 // ... but does not from non-bound vaos? 2266 gl.glBindVertexArray(vaos[1]); 2267 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, buffers[1], m_type); 2268 2269 gl.glDeleteVertexArrays(2, vaos); 2270 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteVertexArrays"); 2271 } 2272 } 2273}; 2274 2275class StencilClearValueTestCase : public ApiCase 2276{ 2277public: 2278 StencilClearValueTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 2279 : ApiCase (context, name, description) 2280 , m_verifier (verifier) 2281 { 2282 } 2283 2284 void test (void) 2285 { 2286 m_verifier->verifyInteger(m_testCtx, GL_STENCIL_CLEAR_VALUE, 0); 2287 expectError(GL_NO_ERROR); 2288 2289 const int stencilBits = m_context.getRenderTarget().getStencilBits(); 2290 2291 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit) 2292 { 2293 const int ref = 1 << stencilBit; 2294 2295 glClearStencil(ref); // mask should not affect the REF 2296 expectError(GL_NO_ERROR); 2297 2298 m_verifier->verifyInteger(m_testCtx, GL_STENCIL_CLEAR_VALUE, ref); 2299 expectError(GL_NO_ERROR); 2300 } 2301 } 2302 2303private: 2304 StateVerifier* m_verifier; 2305}; 2306 2307class ActiveTextureTestCase : public ApiCase 2308{ 2309public: 2310 ActiveTextureTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 2311 : ApiCase (context, name, description) 2312 , m_verifier (verifier) 2313 { 2314 } 2315 2316 void test (void) 2317 { 2318 m_verifier->verifyInteger(m_testCtx, GL_ACTIVE_TEXTURE, GL_TEXTURE0); 2319 expectError(GL_NO_ERROR); 2320 2321 GLint textureUnits = 0; 2322 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &textureUnits); 2323 expectError(GL_NO_ERROR); 2324 2325 for (int ndx = 0; ndx < textureUnits; ++ndx) 2326 { 2327 glActiveTexture(GL_TEXTURE0 + ndx); 2328 expectError(GL_NO_ERROR); 2329 2330 m_verifier->verifyInteger(m_testCtx, GL_ACTIVE_TEXTURE, GL_TEXTURE0 + ndx); 2331 expectError(GL_NO_ERROR); 2332 } 2333 } 2334 2335private: 2336 StateVerifier* m_verifier; 2337}; 2338 2339class RenderbufferBindingTestCase : public BindingTest 2340{ 2341public: 2342 RenderbufferBindingTestCase (Context& context, QueryType type, const char* name, const char* description) 2343 : BindingTest(context, name, description, type) 2344 { 2345 } 2346 2347 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const 2348 { 2349 verifyStateInteger(result, gl, GL_RENDERBUFFER_BINDING, 0, m_type); 2350 2351 GLuint renderBuffer = 0; 2352 gl.glGenRenderbuffers(1, &renderBuffer); 2353 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenRenderbuffers"); 2354 2355 gl.glBindRenderbuffer(GL_RENDERBUFFER, renderBuffer); 2356 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindRenderbuffer"); 2357 2358 verifyStateInteger(result, gl, GL_RENDERBUFFER_BINDING, renderBuffer, m_type); 2359 2360 gl.glDeleteRenderbuffers(1, &renderBuffer); 2361 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteRenderbuffers"); 2362 2363 verifyStateInteger(result, gl, GL_RENDERBUFFER_BINDING, 0, m_type); 2364 } 2365}; 2366 2367class SamplerObjectBindingTestCase : public BindingTest 2368{ 2369public: 2370 SamplerObjectBindingTestCase (Context& context, QueryType type, const char* name, const char* description) 2371 : BindingTest(context, name, description, type) 2372 { 2373 } 2374 2375 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const 2376 { 2377 verifyStateInteger(result, gl, GL_SAMPLER_BINDING, 0, m_type); 2378 2379 { 2380 const tcu::ScopedLogSection section(gl.getLog(), "SingleUnit", "Single unit"); 2381 2382 GLuint sampler = 0; 2383 gl.glGenSamplers(1, &sampler); 2384 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenSamplers"); 2385 2386 gl.glBindSampler(0, sampler); 2387 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindSampler"); 2388 2389 verifyStateInteger(result, gl, GL_SAMPLER_BINDING, sampler, m_type); 2390 2391 gl.glDeleteSamplers(1, &sampler); 2392 verifyStateInteger(result, gl, GL_SAMPLER_BINDING, 0, m_type); 2393 } 2394 2395 { 2396 const tcu::ScopedLogSection section(gl.getLog(), "MultipleUnits", "Multiple units"); 2397 2398 GLuint samplerA = 0; 2399 GLuint samplerB = 0; 2400 gl.glGenSamplers(1, &samplerA); 2401 gl.glGenSamplers(1, &samplerB); 2402 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenSamplers"); 2403 2404 gl.glBindSampler(1, samplerA); 2405 gl.glBindSampler(2, samplerB); 2406 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindSampler"); 2407 2408 verifyStateInteger(result, gl, GL_SAMPLER_BINDING, 0, m_type); 2409 2410 gl.glActiveTexture(GL_TEXTURE1); 2411 verifyStateInteger(result, gl, GL_SAMPLER_BINDING, samplerA, m_type); 2412 2413 gl.glActiveTexture(GL_TEXTURE2); 2414 verifyStateInteger(result, gl, GL_SAMPLER_BINDING, samplerB, m_type); 2415 2416 gl.glDeleteSamplers(1, &samplerB); 2417 gl.glDeleteSamplers(1, &samplerA); 2418 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteSamplers"); 2419 } 2420 } 2421}; 2422 2423class TextureBindingTestCase : public BindingTest 2424{ 2425public: 2426 TextureBindingTestCase (Context& context, QueryType type, const char* name, const char* description, GLenum testBindingName, GLenum textureType) 2427 : BindingTest (context, name, description, type) 2428 , m_testBindingName (testBindingName) 2429 , m_textureType (textureType) 2430 { 2431 } 2432 2433 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const 2434 { 2435 verifyStateInteger(result, gl, m_testBindingName, 0, m_type); 2436 2437 GLuint texture = 0; 2438 gl.glGenTextures(1, &texture); 2439 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenTextures"); 2440 2441 gl.glBindTexture(m_textureType, texture); 2442 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture"); 2443 2444 verifyStateInteger(result, gl, m_testBindingName, texture, m_type); 2445 2446 gl.glDeleteTextures(1, &texture); 2447 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures"); 2448 2449 verifyStateInteger(result, gl, m_testBindingName, 0, m_type); 2450 } 2451private: 2452 const GLenum m_testBindingName; 2453 const GLenum m_textureType; 2454}; 2455 2456class FrameBufferBindingTestCase : public BindingTest 2457{ 2458public: 2459 FrameBufferBindingTestCase (Context& context, QueryType type, const char* name, const char* description) 2460 : BindingTest(context, name, description, type) 2461 { 2462 } 2463 2464 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const 2465 { 2466 verifyStateInteger(result, gl, GL_DRAW_FRAMEBUFFER_BINDING, 0, m_type); 2467 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING, 0, m_type); 2468 verifyStateInteger(result, gl, GL_READ_FRAMEBUFFER_BINDING, 0, m_type); 2469 2470 GLuint framebufferId = 0; 2471 gl.glGenFramebuffers(1, &framebufferId); 2472 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenFramebuffers"); 2473 2474 gl.glBindFramebuffer(GL_FRAMEBUFFER, framebufferId); 2475 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind GL_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.glBindFramebuffer(GL_FRAMEBUFFER, 0); 2482 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "unbind GL_FRAMEBUFFER"); 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 gl.glBindFramebuffer(GL_READ_FRAMEBUFFER, framebufferId); 2489 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind GL_READ_FRAMEBUFFER"); 2490 2491 verifyStateInteger(result, gl, GL_DRAW_FRAMEBUFFER_BINDING, 0, m_type); 2492 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING, 0, m_type); 2493 verifyStateInteger(result, gl, GL_READ_FRAMEBUFFER_BINDING, framebufferId, m_type); 2494 2495 gl.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebufferId); 2496 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind GL_DRAW_FRAMEBUFFER"); 2497 2498 verifyStateInteger(result, gl, GL_DRAW_FRAMEBUFFER_BINDING, framebufferId, m_type); 2499 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING, framebufferId, m_type); 2500 verifyStateInteger(result, gl, GL_READ_FRAMEBUFFER_BINDING, framebufferId, m_type); 2501 2502 gl.glDeleteFramebuffers(1, &framebufferId); 2503 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteFramebuffers"); 2504 2505 verifyStateInteger(result, gl, GL_DRAW_FRAMEBUFFER_BINDING, 0, m_type); 2506 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING, 0, m_type); 2507 verifyStateInteger(result, gl, GL_READ_FRAMEBUFFER_BINDING, 0, m_type); 2508 } 2509}; 2510 2511class ImplementationColorReadTestCase : public ApiCase 2512{ 2513public: 2514 ImplementationColorReadTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 2515 : ApiCase (context, name, description) 2516 , m_verifier (verifier) 2517 { 2518 } 2519 2520 void test (void) 2521 { 2522 const GLint defaultColorTypes[] = 2523 { 2524 GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, 2525 GL_UNSIGNED_INT, GL_INT, GL_HALF_FLOAT, GL_FLOAT, GL_UNSIGNED_SHORT_5_6_5, 2526 GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_5_5_5_1, 2527 GL_UNSIGNED_INT_2_10_10_10_REV, GL_UNSIGNED_INT_10F_11F_11F_REV 2528 }; 2529 const GLint defaultColorFormats[] = 2530 { 2531 GL_RGBA, GL_RGBA_INTEGER, GL_RGB, GL_RGB_INTEGER, 2532 GL_RG, GL_RG_INTEGER, GL_RED, GL_RED_INTEGER 2533 }; 2534 2535 std::vector<GLint> validColorTypes; 2536 std::vector<GLint> validColorFormats; 2537 2538 // Defined by the spec 2539 2540 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(defaultColorTypes); ++ndx) 2541 validColorTypes.push_back(defaultColorTypes[ndx]); 2542 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(defaultColorFormats); ++ndx) 2543 validColorFormats.push_back(defaultColorFormats[ndx]); 2544 2545 // Extensions 2546 2547 if (m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_format_BGRA8888") || 2548 m_context.getContextInfo().isExtensionSupported("GL_APPLE_texture_format_BGRA8888")) 2549 validColorFormats.push_back(GL_BGRA); 2550 2551 if (m_context.getContextInfo().isExtensionSupported("GL_EXT_read_format_bgra")) 2552 { 2553 validColorFormats.push_back(GL_BGRA); 2554 validColorTypes.push_back(GL_UNSIGNED_SHORT_4_4_4_4_REV); 2555 validColorTypes.push_back(GL_UNSIGNED_SHORT_1_5_5_5_REV); 2556 } 2557 2558 if (m_context.getContextInfo().isExtensionSupported("GL_IMG_read_format")) 2559 { 2560 validColorFormats.push_back(GL_BGRA); 2561 validColorTypes.push_back(GL_UNSIGNED_SHORT_4_4_4_4_REV); 2562 } 2563 2564 if (m_context.getContextInfo().isExtensionSupported("GL_NV_sRGB_formats")) 2565 { 2566 validColorFormats.push_back(GL_SLUMINANCE_NV); 2567 validColorFormats.push_back(GL_SLUMINANCE_ALPHA_NV); 2568 } 2569 2570 if (m_context.getContextInfo().isExtensionSupported("GL_NV_bgr")) 2571 { 2572 validColorFormats.push_back(GL_BGR_NV); 2573 } 2574 2575 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_IMPLEMENTATION_COLOR_READ_TYPE, &validColorTypes[0], validColorTypes.size()); 2576 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_IMPLEMENTATION_COLOR_READ_FORMAT, &validColorFormats[0], validColorFormats.size()); 2577 expectError(GL_NO_ERROR); 2578 } 2579 2580private: 2581 StateVerifier* m_verifier; 2582}; 2583 2584class ReadBufferCase : public ApiCase 2585{ 2586public: 2587 ReadBufferCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 2588 : ApiCase (context, name, description) 2589 , m_verifier (verifier) 2590 { 2591 } 2592 2593 void test (void) 2594 { 2595 const bool isGlCore45 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)); 2596 const GLenum colorAttachment = isGlCore45 ? GL_FRONT : GL_BACK; 2597 const GLint validInitialValues[] = {(GLint)colorAttachment, GL_BACK, GL_NONE}; 2598 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_READ_BUFFER, validInitialValues, DE_LENGTH_OF_ARRAY(validInitialValues)); 2599 expectError(GL_NO_ERROR); 2600 2601 glReadBuffer(GL_NONE); 2602 m_verifier->verifyInteger(m_testCtx, GL_READ_BUFFER, GL_NONE); 2603 expectError(GL_NO_ERROR); 2604 2605 glReadBuffer(colorAttachment); 2606 m_verifier->verifyInteger(m_testCtx, GL_READ_BUFFER, colorAttachment); 2607 expectError(GL_NO_ERROR); 2608 2609 // test GL_READ_BUFFER with framebuffers 2610 2611 GLuint framebufferId = 0; 2612 glGenFramebuffers(1, &framebufferId); 2613 expectError(GL_NO_ERROR); 2614 2615 GLuint renderbuffer_id = 0; 2616 glGenRenderbuffers(1, &renderbuffer_id); 2617 expectError(GL_NO_ERROR); 2618 2619 glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer_id); 2620 expectError(GL_NO_ERROR); 2621 2622 glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 128, 128); 2623 expectError(GL_NO_ERROR); 2624 2625 glBindFramebuffer(GL_READ_FRAMEBUFFER, framebufferId); 2626 expectError(GL_NO_ERROR); 2627 2628 glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffer_id); 2629 expectError(GL_NO_ERROR); 2630 2631 m_verifier->verifyInteger(m_testCtx, GL_READ_BUFFER, GL_COLOR_ATTACHMENT0); 2632 2633 glDeleteFramebuffers(1, &framebufferId); 2634 glDeleteRenderbuffers(1, &renderbuffer_id); 2635 expectError(GL_NO_ERROR); 2636 2637 m_verifier->verifyInteger(m_testCtx, GL_READ_BUFFER, colorAttachment); 2638 expectError(GL_NO_ERROR); 2639 } 2640private: 2641 StateVerifier* m_verifier; 2642}; 2643 2644class DrawBufferCase : public ApiCase 2645{ 2646public: 2647 DrawBufferCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 2648 : ApiCase (context, name, description) 2649 , m_verifier (verifier) 2650 { 2651 } 2652 2653 void test (void) 2654 { 2655 const GLint validInitialValues[] = {GL_FRONT, GL_BACK, GL_NONE}; 2656 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_DRAW_BUFFER0, validInitialValues, DE_LENGTH_OF_ARRAY(validInitialValues)); 2657 expectError(GL_NO_ERROR); 2658 2659 GLenum bufs = GL_NONE; 2660 glDrawBuffers(1, &bufs); 2661 m_verifier->verifyInteger(m_testCtx, GL_DRAW_BUFFER0, GL_NONE); 2662 expectError(GL_NO_ERROR); 2663 2664 bufs = GL_BACK; 2665 glDrawBuffers(1, &bufs); 2666 const GLint validDraw0Values[] = {GL_FRONT_LEFT, GL_BACK}; 2667 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_DRAW_BUFFER0, validDraw0Values, DE_LENGTH_OF_ARRAY(validDraw0Values)); 2668 expectError(GL_NO_ERROR); 2669 2670 // test GL_DRAW_BUFFER with framebuffers 2671 2672 GLuint framebufferId = 0; 2673 glGenFramebuffers(1, &framebufferId); 2674 expectError(GL_NO_ERROR); 2675 2676 GLuint renderbuffer_ids[2] = {0}; 2677 glGenRenderbuffers(2, renderbuffer_ids); 2678 expectError(GL_NO_ERROR); 2679 2680 glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer_ids[0]); 2681 expectError(GL_NO_ERROR); 2682 glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 128, 128); 2683 expectError(GL_NO_ERROR); 2684 2685 glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer_ids[1]); 2686 expectError(GL_NO_ERROR); 2687 glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 128, 128); 2688 expectError(GL_NO_ERROR); 2689 2690 glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebufferId); 2691 expectError(GL_NO_ERROR); 2692 2693 glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffer_ids[0]); 2694 expectError(GL_NO_ERROR); 2695 glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_RENDERBUFFER, renderbuffer_ids[1]); 2696 expectError(GL_NO_ERROR); 2697 2698 // only the initial state the draw buffer for fragment color zero is defined 2699 m_verifier->verifyInteger(m_testCtx, GL_DRAW_BUFFER0, GL_COLOR_ATTACHMENT0); 2700 2701 GLenum bufTargets[2] = {GL_NONE, GL_COLOR_ATTACHMENT1}; 2702 glDrawBuffers(2, bufTargets); 2703 m_verifier->verifyInteger(m_testCtx, GL_DRAW_BUFFER0, GL_NONE); 2704 m_verifier->verifyInteger(m_testCtx, GL_DRAW_BUFFER1, GL_COLOR_ATTACHMENT1); 2705 2706 glDeleteFramebuffers(1, &framebufferId); 2707 glDeleteRenderbuffers(2, renderbuffer_ids); 2708 expectError(GL_NO_ERROR); 2709 2710 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_DRAW_BUFFER0, validDraw0Values, DE_LENGTH_OF_ARRAY(validDraw0Values)); 2711 expectError(GL_NO_ERROR); 2712 } 2713private: 2714 StateVerifier* m_verifier; 2715}; 2716 2717static const char* getQueryTypeSuffix (QueryType type) 2718{ 2719 switch (type) 2720 { 2721 case QUERY_BOOLEAN: return "_getboolean"; 2722 case QUERY_INTEGER: return "_getinteger"; 2723 case QUERY_INTEGER64: return "_getinteger64"; 2724 case QUERY_FLOAT: return "_getfloat"; 2725 default: 2726 DE_ASSERT(DE_FALSE); 2727 return DE_NULL; 2728 } 2729} 2730 2731#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \ 2732 do { \ 2733 for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \ 2734 { \ 2735 StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \ 2736 CODE_BLOCK; \ 2737 } \ 2738 } while (0) 2739 2740#define FOR_EACH_QUERYTYPE(QUERYTYPES, CODE_BLOCK) \ 2741 do { \ 2742 for (int _queryTypeNdx = 0; _queryTypeNdx < DE_LENGTH_OF_ARRAY(QUERYTYPES); _queryTypeNdx++) \ 2743 { \ 2744 const QueryType queryType = (QUERYTYPES)[_queryTypeNdx]; \ 2745 CODE_BLOCK; \ 2746 } \ 2747 } while (0) 2748 2749} // anonymous 2750 2751IntegerStateQueryTests::IntegerStateQueryTests (Context& context) 2752 : TestCaseGroup (context, "integers", "Integer Values") 2753 , m_verifierBoolean (DE_NULL) 2754 , m_verifierInteger (DE_NULL) 2755 , m_verifierInteger64 (DE_NULL) 2756 , m_verifierFloat (DE_NULL) 2757{ 2758} 2759 2760IntegerStateQueryTests::~IntegerStateQueryTests (void) 2761{ 2762 deinit(); 2763} 2764 2765void IntegerStateQueryTests::init (void) 2766{ 2767 static const QueryType queryTypes[] = 2768 { 2769 QUERY_BOOLEAN, 2770 QUERY_INTEGER, 2771 QUERY_INTEGER64, 2772 QUERY_FLOAT, 2773 }; 2774 2775 DE_ASSERT(m_verifierBoolean == DE_NULL); 2776 DE_ASSERT(m_verifierInteger == DE_NULL); 2777 DE_ASSERT(m_verifierInteger64 == DE_NULL); 2778 DE_ASSERT(m_verifierFloat == DE_NULL); 2779 2780 m_verifierBoolean = new GetBooleanVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog()); 2781 m_verifierInteger = new GetIntegerVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog()); 2782 m_verifierInteger64 = new GetInteger64Verifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog()); 2783 m_verifierFloat = new GetFloatVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog()); 2784 2785 const struct LimitedStateInteger 2786 { 2787 const char* name; 2788 const char* description; 2789 GLenum targetName; 2790 GLint value; 2791 bool skipForGl; 2792 } implementationMinLimits[] = 2793 { 2794 { "subpixel_bits", "SUBPIXEL_BITS has minimum value of 4", GL_SUBPIXEL_BITS, 4 , false}, 2795 { "max_3d_texture_size", "MAX_3D_TEXTURE_SIZE has minimum value of 256", GL_MAX_3D_TEXTURE_SIZE, 256 , false }, 2796 { "max_texture_size", "MAX_TEXTURE_SIZE has minimum value of 2048", GL_MAX_TEXTURE_SIZE, 2048 , false }, 2797 { "max_array_texture_layers", "MAX_ARRAY_TEXTURE_LAYERS has minimum value of 256", GL_MAX_ARRAY_TEXTURE_LAYERS, 256 , false }, 2798 { "max_cube_map_texture_size", "MAX_CUBE_MAP_TEXTURE_SIZE has minimum value of 2048", GL_MAX_CUBE_MAP_TEXTURE_SIZE, 2048 , false }, 2799 { "max_renderbuffer_size", "MAX_RENDERBUFFER_SIZE has minimum value of 2048", GL_MAX_RENDERBUFFER_SIZE, 2048 , false }, 2800 { "max_draw_buffers", "MAX_DRAW_BUFFERS has minimum value of 4", GL_MAX_DRAW_BUFFERS, 4 , false }, 2801 { "max_color_attachments", "MAX_COLOR_ATTACHMENTS has minimum value of 4", GL_MAX_COLOR_ATTACHMENTS, 4 , false }, 2802 { "max_elements_indices", "MAX_ELEMENTS_INDICES has minimum value of 0", GL_MAX_ELEMENTS_INDICES, 0 , false }, 2803 { "max_elements_vertices", "MAX_ELEMENTS_VERTICES has minimum value of 0", GL_MAX_ELEMENTS_VERTICES, 0 , false }, 2804 { "num_extensions", "NUM_EXTENSIONS has minimum value of 0", GL_NUM_EXTENSIONS, 0 , false }, 2805 { "major_version", "MAJOR_VERSION has minimum value of 3", GL_MAJOR_VERSION, 3 , false }, 2806 { "minor_version", "MINOR_VERSION has minimum value of 0", GL_MINOR_VERSION, 0 , false }, 2807 { "max_vertex_attribs", "MAX_VERTEX_ATTRIBS has minimum value of 16", GL_MAX_VERTEX_ATTRIBS, 16 , false }, 2808 { "max_vertex_uniform_components", "MAX_VERTEX_UNIFORM_COMPONENTS has minimum value of 1024", GL_MAX_VERTEX_UNIFORM_COMPONENTS, 1024 , false }, 2809 { "max_vertex_uniform_vectors", "MAX_VERTEX_UNIFORM_VECTORS has minimum value of 256", GL_MAX_VERTEX_UNIFORM_VECTORS, 256 , false }, 2810 { "max_vertex_uniform_blocks", "MAX_VERTEX_UNIFORM_BLOCKS has minimum value of 12", GL_MAX_VERTEX_UNIFORM_BLOCKS, 12 , false }, 2811 { "max_vertex_output_components", "MAX_VERTEX_OUTPUT_COMPONENTS has minimum value of 64", GL_MAX_VERTEX_OUTPUT_COMPONENTS, 64 , false }, 2812 { "max_vertex_texture_image_units", "MAX_VERTEX_TEXTURE_IMAGE_UNITS has minimum value of 16", GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, 16 , false }, 2813 { "max_fragment_uniform_components", "MAX_FRAGMENT_UNIFORM_COMPONENTS has minimum value of 896", GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, 896 , false }, 2814 { "max_fragment_uniform_vectors", "MAX_FRAGMENT_UNIFORM_VECTORS has minimum value of 224", GL_MAX_FRAGMENT_UNIFORM_VECTORS, 224 , false }, 2815 { "max_fragment_uniform_blocks", "MAX_FRAGMENT_UNIFORM_BLOCKS has minimum value of 12", GL_MAX_FRAGMENT_UNIFORM_BLOCKS, 12 , false }, 2816 { "max_fragment_input_components", "MAX_FRAGMENT_INPUT_COMPONENTS has minimum value of 60", GL_MAX_FRAGMENT_INPUT_COMPONENTS, 60 , false }, 2817 { "max_texture_image_units", "MAX_TEXTURE_IMAGE_UNITS has minimum value of 16", GL_MAX_TEXTURE_IMAGE_UNITS, 16 , false }, 2818 { "max_program_texel_offset", "MAX_PROGRAM_TEXEL_OFFSET has minimum value of 7", GL_MAX_PROGRAM_TEXEL_OFFSET, 7 , false }, 2819 { "max_uniform_buffer_bindings", "MAX_UNIFORM_BUFFER_BINDINGS has minimum value of 24", GL_MAX_UNIFORM_BUFFER_BINDINGS, 24 , false }, 2820 { "max_combined_uniform_blocks", "MAX_COMBINED_UNIFORM_BLOCKS has minimum value of 24", GL_MAX_COMBINED_UNIFORM_BLOCKS, 24 , false }, 2821 { "max_varying_components", "MAX_VARYING_COMPONENTS has minimum value of 60", GL_MAX_VARYING_COMPONENTS, 60 , false }, 2822 { "max_varying_vectors", "MAX_VARYING_VECTORS has minimum value of 15", GL_MAX_VARYING_VECTORS, 15 , false }, 2823 { "max_combined_texture_image_units", "MAX_COMBINED_TEXTURE_IMAGE_UNITS has minimum value of 32", GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, 32 , false }, 2824 { "max_transform_feedback_interleaved_components", "MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS has minimum value of 64", GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS, 64 , false }, 2825 { "max_transform_feedback_separate_attribs", "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS has minimum value of 4", GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, 4 , false }, 2826 { "max_transform_feedback_separate_components", "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS has minimum value of 4", GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS, 4 , false }, 2827 { "max_samples", "MAX_SAMPLES has minimum value of 4", GL_MAX_SAMPLES, 4 , false }, 2828 { "red_bits", "RED_BITS has minimum value of 0", GL_RED_BITS, 0, true }, 2829 { "green_bits", "GREEN_BITS has minimum value of 0", GL_GREEN_BITS, 0, true }, 2830 { "blue_bits", "BLUE_BITS has minimum value of 0", GL_BLUE_BITS, 0, true }, 2831 { "alpha_bits", "ALPHA_BITS has minimum value of 0", GL_ALPHA_BITS, 0, true }, 2832 { "depth_bits", "DEPTH_BITS has minimum value of 0", GL_DEPTH_BITS, 0, true }, 2833 { "stencil_bits", "STENCIL_BITS has minimum value of 0", GL_STENCIL_BITS, 0, true }, 2834 }; 2835 const LimitedStateInteger implementationMaxLimits[] = 2836 { 2837 { "min_program_texel_offset", "MIN_PROGRAM_TEXEL_OFFSET has maximum value of -8", GL_MIN_PROGRAM_TEXEL_OFFSET, -8 , false }, 2838 { "uniform_buffer_offset_alignment", "UNIFORM_BUFFER_OFFSET_ALIGNMENT has minimum value of 1", GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, 256 , false }, 2839 }; 2840 2841 // \note implementation defined limits have their own tests so just check the conversions to boolean, int64 and float 2842 StateVerifier* implementationLimitVerifiers[] = {m_verifierBoolean, m_verifierInteger64, m_verifierFloat}; 2843 2844 const bool isGlCore45 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)); 2845 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(implementationMinLimits); testNdx++) 2846 { 2847 if (implementationMinLimits[testNdx].skipForGl && isGlCore45) 2848 continue; 2849 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))); 2850 } 2851 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(implementationMaxLimits); testNdx++) 2852 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))); 2853 2854 StateVerifier* normalVerifiers[] = {m_verifierBoolean, m_verifierInteger, m_verifierInteger64, m_verifierFloat}; 2855 2856 FOR_EACH_VERIFIER(implementationLimitVerifiers, addChild(new SampleBuffersTestCase (m_context, verifier, (std::string("sample_buffers") + verifier->getTestNamePostfix()).c_str(), "SAMPLE_BUFFERS"))); 2857 2858 FOR_EACH_VERIFIER(normalVerifiers, addChild(new SamplesTestCase (m_context, verifier, (std::string("samples") + verifier->getTestNamePostfix()).c_str(), "SAMPLES"))); 2859 if (!isGlCore45) 2860 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))); 2861 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))); 2862 FOR_EACH_VERIFIER(normalVerifiers, addChild(new DepthFuncTestCase (m_context, verifier, (std::string("depth_func") + verifier->getTestNamePostfix()).c_str(), "DEPTH_FUNC"))); 2863 FOR_EACH_VERIFIER(normalVerifiers, addChild(new CullFaceTestCase (m_context, verifier, (std::string("cull_face_mode") + verifier->getTestNamePostfix()).c_str(), "CULL_FACE_MODE"))); 2864 FOR_EACH_VERIFIER(normalVerifiers, addChild(new FrontFaceTestCase (m_context, verifier, (std::string("front_face_mode") + verifier->getTestNamePostfix()).c_str(), "FRONT_FACE"))); 2865 FOR_EACH_VERIFIER(normalVerifiers, addChild(new ViewPortTestCase (m_context, verifier, (std::string("viewport") + verifier->getTestNamePostfix()).c_str(), "VIEWPORT"))); 2866 FOR_EACH_VERIFIER(normalVerifiers, addChild(new ScissorBoxTestCase (m_context, verifier, (std::string("scissor_box") + verifier->getTestNamePostfix()).c_str(), "SCISSOR_BOX"))); 2867 FOR_EACH_VERIFIER(normalVerifiers, addChild(new MaxViewportDimsTestCase (m_context, verifier, (std::string("max_viewport_dims") + verifier->getTestNamePostfix()).c_str(), "MAX_VIEWPORT_DIMS"))); 2868 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefTestCase (m_context, verifier, (std::string("stencil_ref") + verifier->getTestNamePostfix()).c_str(), "STENCIL_REF", GL_STENCIL_REF))); 2869 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))); 2870 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))); 2871 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))); 2872 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))); 2873 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))); 2874 2875 const struct NamedStencilOp 2876 { 2877 const char* name; 2878 2879 const char* frontDescription; 2880 GLenum frontTarget; 2881 const char* backDescription; 2882 GLenum backTarget; 2883 } stencilOps[] = 2884 { 2885 { "fail", "STENCIL_FAIL", GL_STENCIL_FAIL, "STENCIL_BACK_FAIL", GL_STENCIL_BACK_FAIL }, 2886 { "depth_fail", "STENCIL_PASS_DEPTH_FAIL", GL_STENCIL_PASS_DEPTH_FAIL, "STENCIL_BACK_PASS_DEPTH_FAIL", GL_STENCIL_BACK_PASS_DEPTH_FAIL }, 2887 { "depth_pass", "STENCIL_PASS_DEPTH_PASS", GL_STENCIL_PASS_DEPTH_PASS, "STENCIL_BACK_PASS_DEPTH_PASS", GL_STENCIL_BACK_PASS_DEPTH_PASS } 2888 }; 2889 2890 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(stencilOps); testNdx++) 2891 { 2892 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))); 2893 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))); 2894 2895 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))); 2896 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))); 2897 2898 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))); 2899 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))); 2900 } 2901 2902 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilFuncTestCase (m_context, verifier, (std::string("stencil_func") + verifier->getTestNamePostfix()).c_str(), "STENCIL_FUNC"))); 2903 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))); 2904 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))); 2905 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))); 2906 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))); 2907 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))); 2908 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))); 2909 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))); 2910 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))); 2911 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))); 2912 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))); 2913 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskTestCase (m_context, verifier, (std::string("stencil_writemask") + verifier->getTestNamePostfix()).c_str(), "STENCIL_WRITEMASK", GL_STENCIL_WRITEMASK))); 2914 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))); 2915 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))); 2916 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))); 2917 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))); 2918 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))); 2919 2920 const struct PixelStoreState 2921 { 2922 const char* name; 2923 const char* description; 2924 GLenum target; 2925 int initialValue; 2926 } pixelStoreStates[] = 2927 { 2928 { "unpack_image_height","UNPACK_IMAGE_HEIGHT", GL_UNPACK_IMAGE_HEIGHT, 0 }, 2929 { "unpack_skip_images", "UNPACK_SKIP_IMAGES", GL_UNPACK_SKIP_IMAGES, 0 }, 2930 { "unpack_row_length", "UNPACK_ROW_LENGTH", GL_UNPACK_ROW_LENGTH, 0 }, 2931 { "unpack_skip_rows", "UNPACK_SKIP_ROWS", GL_UNPACK_SKIP_ROWS, 0 }, 2932 { "unpack_skip_pixels", "UNPACK_SKIP_PIXELS", GL_UNPACK_SKIP_PIXELS, 0 }, 2933 { "pack_row_length", "PACK_ROW_LENGTH", GL_PACK_ROW_LENGTH, 0 }, 2934 { "pack_skip_rows", "PACK_SKIP_ROWS", GL_PACK_SKIP_ROWS, 0 }, 2935 { "pack_skip_pixels", "PACK_SKIP_PIXELS", GL_PACK_SKIP_PIXELS, 0 } 2936 }; 2937 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(pixelStoreStates); testNdx++) 2938 { 2939 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))); 2940 } 2941 2942 FOR_EACH_VERIFIER(normalVerifiers, addChild(new PixelStoreAlignTestCase(m_context, verifier, (std::string("unpack_alignment") + verifier->getTestNamePostfix()).c_str(), "UNPACK_ALIGNMENT", GL_UNPACK_ALIGNMENT))); 2943 FOR_EACH_VERIFIER(normalVerifiers, addChild(new PixelStoreAlignTestCase(m_context, verifier, (std::string("pack_alignment") + verifier->getTestNamePostfix()).c_str(), "PACK_ALIGNMENT", GL_PACK_ALIGNMENT))); 2944 2945 const struct BlendColorState 2946 { 2947 const char* name; 2948 const char* description; 2949 GLenum target; 2950 int initialValue; 2951 } blendColorStates[] = 2952 { 2953 { "blend_src_rgb", "BLEND_SRC_RGB", GL_BLEND_SRC_RGB, GL_ONE }, 2954 { "blend_src_alpha", "BLEND_SRC_ALPHA", GL_BLEND_SRC_ALPHA, GL_ONE }, 2955 { "blend_dst_rgb", "BLEND_DST_RGB", GL_BLEND_DST_RGB, GL_ZERO }, 2956 { "blend_dst_alpha", "BLEND_DST_ALPHA", GL_BLEND_DST_ALPHA, GL_ZERO } 2957 }; 2958 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(blendColorStates); testNdx++) 2959 { 2960 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))); 2961 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))); 2962 } 2963 2964 const struct BlendEquationState 2965 { 2966 const char* name; 2967 const char* description; 2968 GLenum target; 2969 int initialValue; 2970 } blendEquationStates[] = 2971 { 2972 { "blend_equation_rgb", "BLEND_EQUATION_RGB", GL_BLEND_EQUATION_RGB, GL_FUNC_ADD }, 2973 { "blend_equation_alpha", "BLEND_EQUATION_ALPHA", GL_BLEND_EQUATION_ALPHA, GL_FUNC_ADD } 2974 }; 2975 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(blendEquationStates); testNdx++) 2976 { 2977 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))); 2978 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))); 2979 } 2980 2981 const struct ImplementationArrayReturningState 2982 { 2983 const char* name; 2984 const char* description; 2985 GLenum target; 2986 GLenum targetLengthTarget; 2987 int minLength; 2988 } implementationArrayReturningStates[] = 2989 { 2990 { "compressed_texture_formats", "COMPRESSED_TEXTURE_FORMATS", GL_COMPRESSED_TEXTURE_FORMATS, GL_NUM_COMPRESSED_TEXTURE_FORMATS, 10 }, 2991 { "program_binary_formats", "PROGRAM_BINARY_FORMATS", GL_PROGRAM_BINARY_FORMATS, GL_NUM_PROGRAM_BINARY_FORMATS, 0 }, 2992 { "shader_binary_formats", "SHADER_BINARY_FORMATS", GL_SHADER_BINARY_FORMATS, GL_NUM_SHADER_BINARY_FORMATS, 0 } 2993 }; 2994 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(implementationArrayReturningStates); testNdx++) 2995 { 2996 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))); 2997 } 2998 2999 const struct BufferBindingState 3000 { 3001 const char* name; 3002 const char* description; 3003 GLenum target; 3004 GLenum type; 3005 } bufferBindingStates[] = 3006 { 3007 { "array_buffer_binding", "ARRAY_BUFFER_BINDING", GL_ARRAY_BUFFER_BINDING, GL_ARRAY_BUFFER }, 3008 { "uniform_buffer_binding", "UNIFORM_BUFFER_BINDING", GL_UNIFORM_BUFFER_BINDING, GL_UNIFORM_BUFFER }, 3009 { "pixel_pack_buffer_binding", "PIXEL_PACK_BUFFER_BINDING", GL_PIXEL_PACK_BUFFER_BINDING, GL_PIXEL_PACK_BUFFER }, 3010 { "pixel_unpack_buffer_binding", "PIXEL_UNPACK_BUFFER_BINDING", GL_PIXEL_UNPACK_BUFFER_BINDING, GL_PIXEL_UNPACK_BUFFER }, 3011 { "transform_feedback_buffer_binding", "TRANSFORM_FEEDBACK_BUFFER_BINDING", GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, GL_TRANSFORM_FEEDBACK_BUFFER}, 3012 { "copy_read_buffer_binding", "COPY_READ_BUFFER_BINDING", GL_COPY_READ_BUFFER_BINDING, GL_COPY_READ_BUFFER }, 3013 { "copy_write_buffer_binding", "COPY_WRITE_BUFFER_BINDING", GL_COPY_WRITE_BUFFER_BINDING, GL_COPY_WRITE_BUFFER } 3014 }; 3015 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(bufferBindingStates); testNdx++) 3016 { 3017 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))); 3018 } 3019 3020 FOR_EACH_QUERYTYPE(queryTypes, addChild(new ElementArrayBufferBindingTestCase (m_context, queryType, (std::string("element_array_buffer_binding") + getQueryTypeSuffix(queryType)).c_str()))); 3021 FOR_EACH_QUERYTYPE(queryTypes, addChild(new TransformFeedbackBindingTestCase (m_context, queryType, (std::string("transform_feedback_binding") + getQueryTypeSuffix(queryType)).c_str()))); 3022 FOR_EACH_QUERYTYPE(queryTypes, addChild(new CurrentProgramBindingTestCase (m_context, queryType, (std::string("current_program_binding") + getQueryTypeSuffix(queryType)).c_str(), "CURRENT_PROGRAM"))); 3023 FOR_EACH_QUERYTYPE(queryTypes, addChild(new VertexArrayBindingTestCase (m_context, queryType, (std::string("vertex_array_binding") + getQueryTypeSuffix(queryType)).c_str(), "VERTEX_ARRAY_BINDING"))); 3024 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilClearValueTestCase (m_context, verifier, (std::string("stencil_clear_value") + verifier->getTestNamePostfix()).c_str(), "STENCIL_CLEAR_VALUE"))); 3025 FOR_EACH_VERIFIER(normalVerifiers, addChild(new ActiveTextureTestCase (m_context, verifier, (std::string("active_texture") + verifier->getTestNamePostfix()).c_str(), "ACTIVE_TEXTURE"))); 3026 FOR_EACH_QUERYTYPE(queryTypes, addChild(new RenderbufferBindingTestCase (m_context, queryType, (std::string("renderbuffer_binding") + getQueryTypeSuffix(queryType)).c_str(), "RENDERBUFFER_BINDING"))); 3027 FOR_EACH_QUERYTYPE(queryTypes, addChild(new SamplerObjectBindingTestCase (m_context, queryType, (std::string("sampler_binding") + getQueryTypeSuffix(queryType)).c_str(), "SAMPLER_BINDING"))); 3028 3029 const struct TextureBinding 3030 { 3031 const char* name; 3032 const char* description; 3033 GLenum target; 3034 GLenum type; 3035 } textureBindings[] = 3036 { 3037 { "texture_binding_2d", "TEXTURE_BINDING_2D", GL_TEXTURE_BINDING_2D, GL_TEXTURE_2D }, 3038 { "texture_binding_3d", "TEXTURE_BINDING_3D", GL_TEXTURE_BINDING_3D, GL_TEXTURE_3D }, 3039 { "texture_binding_2d_array", "TEXTURE_BINDING_2D_ARRAY", GL_TEXTURE_BINDING_2D_ARRAY, GL_TEXTURE_2D_ARRAY }, 3040 { "texture_binding_cube_map", "TEXTURE_BINDING_CUBE_MAP", GL_TEXTURE_BINDING_CUBE_MAP, GL_TEXTURE_CUBE_MAP } 3041 }; 3042 3043 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(textureBindings); testNdx++) 3044 { 3045 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))); 3046 } 3047 3048 3049 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"))); 3050 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"))); 3051 FOR_EACH_VERIFIER(normalVerifiers, addChild(new ReadBufferCase (m_context, verifier, (std::string("read_buffer") + verifier->getTestNamePostfix()).c_str(), "READ_BUFFER"))); 3052 FOR_EACH_VERIFIER(normalVerifiers, addChild(new DrawBufferCase (m_context, verifier, (std::string("draw_buffer") + verifier->getTestNamePostfix()).c_str(), "DRAW_BUFFER"))); 3053} 3054 3055void IntegerStateQueryTests::deinit (void) 3056{ 3057 if (m_verifierBoolean) 3058 { 3059 delete m_verifierBoolean; 3060 m_verifierBoolean = DE_NULL; 3061 } 3062 if (m_verifierInteger) 3063 { 3064 delete m_verifierInteger; 3065 m_verifierInteger = DE_NULL; 3066 } 3067 if (m_verifierInteger64) 3068 { 3069 delete m_verifierInteger64; 3070 m_verifierInteger64 = DE_NULL; 3071 } 3072 if (m_verifierFloat) 3073 { 3074 delete m_verifierFloat; 3075 m_verifierFloat = DE_NULL; 3076 } 3077 3078 this->TestCaseGroup::deinit(); 3079} 3080 3081} // Functional 3082} // gles3 3083} // deqp 3084