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 Float State Query tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es3fFloatStateQueryTests.hpp" 25 #include "glsStateQueryUtil.hpp" 26 #include "es3fApiCase.hpp" 27 #include "gluRenderContext.hpp" 28 #include "tcuRenderTarget.hpp" 29 #include "tcuFormatUtil.hpp" 30 #include "deRandom.hpp" 31 #include "deMath.h" 32 #include "glwEnums.hpp" 33 34 #include <limits> 35 36 using namespace glw; // GLint and other GL types 37 using namespace deqp::gls; 38 using deqp::gls::StateQueryUtil::StateQueryMemoryWriteGuard; 39 40 namespace deqp 41 { 42 namespace gles3 43 { 44 namespace Functional 45 { 46 namespace FloatStateQueryVerifiers 47 { 48 namespace 49 { 50 51 const int FLOAT_EXPANSION_E = 0x03FF; // 10 bits error allowed, requires 22 accurate bits 52 const int FLOAT_EXPANSION_E_64 = 0x07FF; 53 54 GLint64 expandGLFloatToInteger (GLfloat f) 55 { 56 const GLuint64 referenceValue = (GLint64)(f * 2147483647.0); 57 return referenceValue; 58 } 59 60 GLint clampToGLint (GLint64 val) 61 { 62 return (GLint)de::clamp<GLint64>(val, std::numeric_limits<GLint>::min(), std::numeric_limits<GLint>::max()); 63 } 64 65 } // anonymous 66 67 // StateVerifier 68 69 class StateVerifier : protected glu::CallLogWrapper 70 { 71 public: 72 StateVerifier (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix); 73 virtual ~StateVerifier (); // make GCC happy 74 75 const char* getTestNamePostfix (void) const; 76 77 virtual void verifyFloat (tcu::TestContext& testCtx, GLenum name, GLfloat reference) = DE_NULL; 78 79 // "Expanded" == Float to int conversion converts from [-1.0 to 1.0] -> [MIN_INT MAX_INT] 80 virtual void verifyFloatExpanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference) = DE_NULL; 81 virtual void verifyFloat2Expanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1) = DE_NULL; 82 virtual void verifyFloat4Color (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1, GLfloat reference2, GLfloat reference3) = DE_NULL; 83 84 // verify that the given range is completely whitin the GL state range 85 virtual void verifyFloatRange (tcu::TestContext& testCtx, GLenum name, GLfloat min, GLfloat max) = DE_NULL; 86 virtual void verifyFloatGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLfloat reference) = DE_NULL; 87 88 private: 89 const char* const m_testNamePostfix; 90 }; 91 92 StateVerifier::StateVerifier (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix) 93 : glu::CallLogWrapper (gl, log) 94 , m_testNamePostfix (testNamePostfix) 95 { 96 enableLogging(true); 97 } 98 99 StateVerifier::~StateVerifier () 100 { 101 } 102 103 const char* StateVerifier::getTestNamePostfix (void) const 104 { 105 return m_testNamePostfix; 106 } 107 108 // GetBooleanVerifier 109 110 class GetBooleanVerifier : public StateVerifier 111 { 112 public: 113 GetBooleanVerifier (const glw::Functions& gl, tcu::TestLog& log); 114 void verifyFloat (tcu::TestContext& testCtx, GLenum name, GLfloat reference); 115 void verifyFloatExpanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference); 116 void verifyFloat2Expanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1); 117 void verifyFloat4Color (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1, GLfloat reference2, GLfloat reference3); 118 void verifyFloatRange (tcu::TestContext& testCtx, GLenum name, GLfloat min, GLfloat max); 119 void verifyFloatGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLfloat reference); 120 }; 121 122 GetBooleanVerifier::GetBooleanVerifier (const glw::Functions& gl, tcu::TestLog& log) 123 : StateVerifier(gl, log, "_getboolean") 124 { 125 } 126 127 void GetBooleanVerifier::verifyFloat (tcu::TestContext& testCtx, GLenum name, GLfloat reference) 128 { 129 using tcu::TestLog; 130 131 StateQueryMemoryWriteGuard<GLboolean> state; 132 glGetBooleanv(name, &state); 133 134 if (!state.verifyValidity(testCtx)) 135 return; 136 137 const GLboolean expectedGLState = reference != 0.0f ? GL_TRUE : GL_FALSE; 138 139 if (state != expectedGLState) 140 { 141 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; 142 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 143 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value"); 144 } 145 } 146 147 void GetBooleanVerifier::verifyFloatExpanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference) 148 { 149 DE_ASSERT(de::inRange(reference, -1.0f, 1.0f)); 150 verifyFloat(testCtx, name, reference); 151 } 152 153 void GetBooleanVerifier::verifyFloat2Expanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1) 154 { 155 DE_ASSERT(de::inRange(reference0, -1.0f, 1.0f)); 156 DE_ASSERT(de::inRange(reference1, -1.0f, 1.0f)); 157 158 using tcu::TestLog; 159 160 StateQueryMemoryWriteGuard<GLboolean[2]> boolVector2; 161 glGetBooleanv(name, boolVector2); 162 163 if (!boolVector2.verifyValidity(testCtx)) 164 return; 165 166 const GLboolean referenceAsGLBoolean[] = 167 { 168 reference0 != 0.0f ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE), 169 reference1 != 0.0f ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE), 170 }; 171 172 if (boolVector2[0] != referenceAsGLBoolean[0] || 173 boolVector2[1] != referenceAsGLBoolean[1]) 174 { 175 testCtx.getLog() << TestLog::Message << "// ERROR: expected " 176 << (boolVector2[0] ? "GL_TRUE" : "GL_FALSE") << " " 177 << (boolVector2[1] ? "GL_TRUE" : "GL_FALSE") << " " 178 << TestLog::EndMessage; 179 180 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 181 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value"); 182 } 183 } 184 185 void GetBooleanVerifier::verifyFloat4Color (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1, GLfloat reference2, GLfloat reference3) 186 { 187 using tcu::TestLog; 188 189 StateQueryMemoryWriteGuard<GLboolean[4]> boolVector4; 190 glGetBooleanv(name, boolVector4); 191 192 if (!boolVector4.verifyValidity(testCtx)) 193 return; 194 195 const GLboolean referenceAsGLBoolean[] = 196 { 197 reference0 != 0.0f ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE), 198 reference1 != 0.0f ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE), 199 reference2 != 0.0f ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE), 200 reference3 != 0.0f ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE), 201 }; 202 203 if (boolVector4[0] != referenceAsGLBoolean[0] || 204 boolVector4[1] != referenceAsGLBoolean[1] || 205 boolVector4[2] != referenceAsGLBoolean[2] || 206 boolVector4[3] != referenceAsGLBoolean[3]) 207 { 208 testCtx.getLog() << TestLog::Message << "// ERROR: expected " 209 << (referenceAsGLBoolean[0] ? "GL_TRUE" : "GL_FALSE") << " " 210 << (referenceAsGLBoolean[1] ? "GL_TRUE" : "GL_FALSE") << " " 211 << (referenceAsGLBoolean[2] ? "GL_TRUE" : "GL_FALSE") << " " 212 << (referenceAsGLBoolean[3] ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage; 213 214 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 215 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value"); 216 } 217 } 218 219 void GetBooleanVerifier::verifyFloatRange (tcu::TestContext& testCtx, GLenum name, GLfloat min, GLfloat max) 220 { 221 using tcu::TestLog; 222 223 StateQueryMemoryWriteGuard<GLboolean[2]> range; 224 glGetBooleanv(name, range); 225 226 if (!range.verifyValidity(testCtx)) 227 return; 228 229 if (range[0] == GL_FALSE) 230 { 231 if (max < 0 || min < 0) 232 { 233 testCtx.getLog() << TestLog::Message << "// ERROR: range [" << min << ", " << max << "] is not in range [" << (range[0] == GL_TRUE ? "GL_TRUE" : (range[0] == GL_FALSE ? "GL_FALSE" : "non-boolean")) << ", " << (range[1] == GL_TRUE ? "GL_TRUE" : (range[1] == GL_FALSE ? "GL_FALSE" : "non-boolean")) << "]" << TestLog::EndMessage; 234 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 235 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean range"); 236 return; 237 } 238 } 239 if (range[1] == GL_FALSE) 240 { 241 if (max > 0 || min > 0) 242 { 243 testCtx.getLog() << TestLog::Message << "// ERROR: range [" << min << ", " << max << "] is not in range [" << (range[0] == GL_TRUE ? "GL_TRUE" : (range[0] == GL_FALSE ? "GL_FALSE" : "non-boolean")) << ", " << (range[1] == GL_TRUE ? "GL_TRUE" : (range[1] == GL_FALSE ? "GL_FALSE" : "non-boolean")) << "]" << TestLog::EndMessage; 244 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 245 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean range"); 246 return; 247 } 248 } 249 } 250 251 void GetBooleanVerifier::verifyFloatGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLfloat reference) 252 { 253 using tcu::TestLog; 254 255 StateQueryMemoryWriteGuard<GLboolean> state; 256 glGetBooleanv(name, &state); 257 258 if (!state.verifyValidity(testCtx)) 259 return; 260 261 if (state == GL_TRUE) // state is non-zero, could be greater than reference (correct) 262 return; 263 264 if (state == GL_FALSE) // state is zero 265 { 266 if (reference > 0) // and reference is greater than zero? 267 { 268 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage; 269 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 270 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value"); 271 } 272 } 273 else 274 { 275 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE or GL_FALSE" << TestLog::EndMessage; 276 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 277 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value"); 278 } 279 } 280 281 //GetIntegerVerifier 282 283 class GetIntegerVerifier : public StateVerifier 284 { 285 public: 286 GetIntegerVerifier (const glw::Functions& gl, tcu::TestLog& log); 287 void verifyFloat (tcu::TestContext& testCtx, GLenum name, GLfloat reference); 288 void verifyFloatExpanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference); 289 void verifyFloat2Expanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1); 290 void verifyFloat4Color (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1, GLfloat reference2, GLfloat reference3); 291 void verifyFloatRange (tcu::TestContext& testCtx, GLenum name, GLfloat min, GLfloat max); 292 void verifyFloatGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLfloat reference); 293 }; 294 295 GetIntegerVerifier::GetIntegerVerifier (const glw::Functions& gl, tcu::TestLog& log) 296 : StateVerifier(gl, log, "_getinteger") 297 { 298 } 299 300 void GetIntegerVerifier::verifyFloat (tcu::TestContext& testCtx, GLenum name, GLfloat reference) 301 { 302 using tcu::TestLog; 303 304 const GLint expectedGLStateMax = StateQueryUtil::roundGLfloatToNearestIntegerHalfUp<GLint>(reference); 305 const GLint expectedGLStateMin = StateQueryUtil::roundGLfloatToNearestIntegerHalfDown<GLint>(reference); 306 307 StateQueryMemoryWriteGuard<GLint> state; 308 glGetIntegerv(name, &state); 309 310 if (!state.verifyValidity(testCtx)) 311 return; 312 313 if (state < expectedGLStateMin || state > expectedGLStateMax) 314 { 315 testCtx.getLog() << TestLog::Message << "// ERROR: expected rounding to the nearest integer, valid range [" << expectedGLStateMin << "," << expectedGLStateMax << "]; got " << state << TestLog::EndMessage; 316 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 317 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value"); 318 } 319 } 320 321 void GetIntegerVerifier::verifyFloatExpanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference) 322 { 323 DE_ASSERT(de::inRange(reference, -1.0f, 1.0f)); 324 325 using tcu::TestLog; 326 using tcu::toHex; 327 328 StateQueryMemoryWriteGuard<GLint> state; 329 glGetIntegerv(name, &state); 330 331 if (!state.verifyValidity(testCtx)) 332 return; 333 334 const GLint expectedGLStateMax = clampToGLint(expandGLFloatToInteger(reference) + FLOAT_EXPANSION_E); 335 const GLint expectedGLStateMin = clampToGLint(expandGLFloatToInteger(reference) - FLOAT_EXPANSION_E); 336 337 if (state < expectedGLStateMin || state > expectedGLStateMax) 338 { 339 testCtx.getLog() << TestLog::Message << "// ERROR: expected in range [" << toHex(expectedGLStateMin) << "," << toHex(expectedGLStateMax) << "]; got " << toHex((GLint)state) << TestLog::EndMessage; 340 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 341 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value"); 342 } 343 } 344 345 void GetIntegerVerifier::verifyFloat2Expanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1) 346 { 347 DE_ASSERT(de::inRange(reference0, -1.0f, 1.0f)); 348 DE_ASSERT(de::inRange(reference1, -1.0f, 1.0f)); 349 350 using tcu::TestLog; 351 using tcu::toHex; 352 353 StateQueryMemoryWriteGuard<GLint[2]> floatVector2; 354 glGetIntegerv(name, floatVector2); 355 356 if (!floatVector2.verifyValidity(testCtx)) 357 return; 358 359 const GLint referenceAsGLintMin[] = 360 { 361 clampToGLint(expandGLFloatToInteger(reference0) - FLOAT_EXPANSION_E), 362 clampToGLint(expandGLFloatToInteger(reference1) - FLOAT_EXPANSION_E) 363 }; 364 const GLint referenceAsGLintMax[] = 365 { 366 clampToGLint(expandGLFloatToInteger(reference0) + FLOAT_EXPANSION_E), 367 clampToGLint(expandGLFloatToInteger(reference1) + FLOAT_EXPANSION_E) 368 }; 369 370 if (floatVector2[0] < referenceAsGLintMin[0] || floatVector2[0] > referenceAsGLintMax[0] || 371 floatVector2[1] < referenceAsGLintMin[1] || floatVector2[1] > referenceAsGLintMax[1]) 372 { 373 testCtx.getLog() << TestLog::Message 374 << "// ERROR: expected in ranges " 375 << "[" << toHex(referenceAsGLintMin[0]) << " " << toHex(referenceAsGLintMax[0]) << "], " 376 << "[" << toHex(referenceAsGLintMin[1]) << " " << toHex(referenceAsGLintMax[1]) << "]" 377 << "; got " 378 << toHex(floatVector2[0]) << ", " 379 << toHex(floatVector2[1]) << " "<< TestLog::EndMessage; 380 381 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 382 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value"); 383 } 384 } 385 386 void GetIntegerVerifier::verifyFloat4Color (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1, GLfloat reference2, GLfloat reference3) 387 { 388 using tcu::TestLog; 389 using tcu::toHex; 390 391 StateQueryMemoryWriteGuard<GLint[4]> floatVector4; 392 glGetIntegerv(name, floatVector4); 393 394 if (!floatVector4.verifyValidity(testCtx)) 395 return; 396 397 const GLint referenceAsGLintMin[] = 398 { 399 clampToGLint(expandGLFloatToInteger(reference0) - FLOAT_EXPANSION_E), 400 clampToGLint(expandGLFloatToInteger(reference1) - FLOAT_EXPANSION_E), 401 clampToGLint(expandGLFloatToInteger(reference2) - FLOAT_EXPANSION_E), 402 clampToGLint(expandGLFloatToInteger(reference3) - FLOAT_EXPANSION_E) 403 }; 404 const GLint referenceAsGLintMax[] = 405 { 406 clampToGLint(expandGLFloatToInteger(reference0) + FLOAT_EXPANSION_E), 407 clampToGLint(expandGLFloatToInteger(reference1) + FLOAT_EXPANSION_E), 408 clampToGLint(expandGLFloatToInteger(reference2) + FLOAT_EXPANSION_E), 409 clampToGLint(expandGLFloatToInteger(reference3) + FLOAT_EXPANSION_E) 410 }; 411 412 if (floatVector4[0] < referenceAsGLintMin[0] || floatVector4[0] > referenceAsGLintMax[0] || 413 floatVector4[1] < referenceAsGLintMin[1] || floatVector4[1] > referenceAsGLintMax[1] || 414 floatVector4[2] < referenceAsGLintMin[2] || floatVector4[2] > referenceAsGLintMax[2] || 415 floatVector4[3] < referenceAsGLintMin[3] || floatVector4[3] > referenceAsGLintMax[3]) 416 { 417 testCtx.getLog() << TestLog::Message 418 << "// ERROR: expected in ranges " 419 << "[" << toHex(referenceAsGLintMin[0]) << " " << toHex(referenceAsGLintMax[0]) << "], " 420 << "[" << toHex(referenceAsGLintMin[1]) << " " << toHex(referenceAsGLintMax[1]) << "], " 421 << "[" << toHex(referenceAsGLintMin[2]) << " " << toHex(referenceAsGLintMax[2]) << "], " 422 << "[" << toHex(referenceAsGLintMin[3]) << " " << toHex(referenceAsGLintMax[3]) << "]" 423 << "; got " 424 << toHex(floatVector4[0]) << ", " 425 << toHex(floatVector4[1]) << ", " 426 << toHex(floatVector4[2]) << ", " 427 << toHex(floatVector4[3]) << " "<< TestLog::EndMessage; 428 429 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 430 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value"); 431 } 432 } 433 434 void GetIntegerVerifier::verifyFloatRange (tcu::TestContext& testCtx, GLenum name, GLfloat min, GLfloat max) 435 { 436 using tcu::TestLog; 437 438 StateQueryMemoryWriteGuard<GLint[2]> range; 439 glGetIntegerv(name, range); 440 441 if (!range.verifyValidity(testCtx)) 442 return; 443 444 const GLint testRangeAsGLint[] = 445 { 446 StateQueryUtil::roundGLfloatToNearestIntegerHalfUp<GLint>(min), 447 StateQueryUtil::roundGLfloatToNearestIntegerHalfDown<GLint>(max) 448 }; 449 450 // check if test range outside of gl state range 451 if (testRangeAsGLint[0] < range[0] || 452 testRangeAsGLint[1] > range[1]) 453 { 454 testCtx.getLog() << TestLog::Message 455 << "// ERROR: range [" 456 << testRangeAsGLint[0] << ", " 457 << testRangeAsGLint[1] << "]" 458 << " is not in range [" 459 << range[0] << ", " 460 << range[1] << "]" << TestLog::EndMessage; 461 462 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 463 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer range"); 464 } 465 } 466 467 void GetIntegerVerifier::verifyFloatGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLfloat reference) 468 { 469 using tcu::TestLog; 470 471 StateQueryMemoryWriteGuard<GLint> state; 472 glGetIntegerv(name, &state); 473 474 if (!state.verifyValidity(testCtx)) 475 return; 476 477 const GLint referenceAsInt = StateQueryUtil::roundGLfloatToNearestIntegerHalfDown<GLint>(reference); 478 479 if (state < referenceAsInt) 480 { 481 testCtx.getLog() << TestLog::Message << "// ERROR: expected expected greater or equal to " << referenceAsInt << "; got " << state << TestLog::EndMessage; 482 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 483 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value"); 484 } 485 } 486 487 //GetInteger64Verifier 488 489 class GetInteger64Verifier : public StateVerifier 490 { 491 public: 492 GetInteger64Verifier (const glw::Functions& gl, tcu::TestLog& log); 493 void verifyFloat (tcu::TestContext& testCtx, GLenum name, GLfloat reference); 494 void verifyFloatExpanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference); 495 void verifyFloat2Expanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1); 496 void verifyFloat4Color (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1, GLfloat reference2, GLfloat reference3); 497 void verifyFloatRange (tcu::TestContext& testCtx, GLenum name, GLfloat min, GLfloat max); 498 void verifyFloatGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLfloat reference); 499 }; 500 501 GetInteger64Verifier::GetInteger64Verifier (const glw::Functions& gl, tcu::TestLog& log) 502 : StateVerifier(gl, log, "_getinteger64") 503 { 504 } 505 506 void GetInteger64Verifier::verifyFloat (tcu::TestContext& testCtx, GLenum name, GLfloat reference) 507 { 508 using tcu::TestLog; 509 510 const GLint64 expectedGLStateMax = StateQueryUtil::roundGLfloatToNearestIntegerHalfUp<GLint64>(reference); 511 const GLint64 expectedGLStateMin = StateQueryUtil::roundGLfloatToNearestIntegerHalfDown<GLint64>(reference); 512 513 StateQueryMemoryWriteGuard<GLint64> state; 514 glGetInteger64v(name, &state); 515 516 if (!state.verifyValidity(testCtx)) 517 return; 518 519 if (state < expectedGLStateMin || state > expectedGLStateMax) 520 { 521 testCtx.getLog() << TestLog::Message << "// ERROR: expected rounding to the nearest integer, valid range [" << expectedGLStateMin << "," << expectedGLStateMax << "]; got " << state << TestLog::EndMessage; 522 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 523 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value"); 524 } 525 } 526 527 void GetInteger64Verifier::verifyFloatExpanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference) 528 { 529 DE_ASSERT(de::inRange(reference, -1.0f, 1.0f)); 530 531 using tcu::TestLog; 532 using tcu::toHex; 533 534 StateQueryMemoryWriteGuard<GLint64> state; 535 glGetInteger64v(name, &state); 536 537 if (!state.verifyValidity(testCtx)) 538 return; 539 540 const GLint64 expectedGLStateMax = expandGLFloatToInteger(reference) + FLOAT_EXPANSION_E_64; 541 const GLint64 expectedGLStateMin = expandGLFloatToInteger(reference) - FLOAT_EXPANSION_E_64; 542 543 if (state < expectedGLStateMin || state > expectedGLStateMax) 544 { 545 testCtx.getLog() << TestLog::Message << "// ERROR: expected in range [" << toHex(expectedGLStateMin) << "," << toHex(expectedGLStateMax) << "]; got " << toHex((GLint64)state) << TestLog::EndMessage; 546 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 547 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value"); 548 } 549 } 550 551 void GetInteger64Verifier::verifyFloat2Expanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1) 552 { 553 DE_ASSERT(de::inRange(reference0, -1.0f, 1.0f)); 554 DE_ASSERT(de::inRange(reference1, -1.0f, 1.0f)); 555 556 using tcu::TestLog; 557 using tcu::toHex; 558 559 StateQueryMemoryWriteGuard<GLint64[2]> floatVector2; 560 glGetInteger64v(name, floatVector2); 561 562 if (!floatVector2.verifyValidity(testCtx)) 563 return; 564 565 const GLint64 referenceAsGLintMin[] = 566 { 567 expandGLFloatToInteger(reference0) - FLOAT_EXPANSION_E_64, 568 expandGLFloatToInteger(reference1) - FLOAT_EXPANSION_E_64 569 }; 570 const GLint64 referenceAsGLintMax[] = 571 { 572 expandGLFloatToInteger(reference0) + FLOAT_EXPANSION_E_64, 573 expandGLFloatToInteger(reference1) + FLOAT_EXPANSION_E_64 574 }; 575 576 if (floatVector2[0] < referenceAsGLintMin[0] || floatVector2[0] > referenceAsGLintMax[0] || 577 floatVector2[1] < referenceAsGLintMin[1] || floatVector2[1] > referenceAsGLintMax[1]) 578 { 579 testCtx.getLog() << TestLog::Message 580 << "// ERROR: expected in ranges " 581 << "[" << toHex(referenceAsGLintMin[0]) << " " << toHex(referenceAsGLintMax[0]) << "], " 582 << "[" << toHex(referenceAsGLintMin[1]) << " " << toHex(referenceAsGLintMax[1]) << "]" 583 << "; got " 584 << toHex(floatVector2[0]) << ", " 585 << toHex(floatVector2[1]) << " "<< TestLog::EndMessage; 586 587 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 588 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value"); 589 } 590 } 591 592 void GetInteger64Verifier::verifyFloat4Color (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1, GLfloat reference2, GLfloat reference3) 593 { 594 using tcu::TestLog; 595 using tcu::toHex; 596 597 StateQueryMemoryWriteGuard<GLint64[4]> floatVector4; 598 glGetInteger64v(name, floatVector4); 599 600 if (!floatVector4.verifyValidity(testCtx)) 601 return; 602 603 const GLint64 referenceAsGLintMin[] = 604 { 605 expandGLFloatToInteger(reference0) - FLOAT_EXPANSION_E_64, 606 expandGLFloatToInteger(reference1) - FLOAT_EXPANSION_E_64, 607 expandGLFloatToInteger(reference2) - FLOAT_EXPANSION_E_64, 608 expandGLFloatToInteger(reference3) - FLOAT_EXPANSION_E_64 609 }; 610 const GLint64 referenceAsGLintMax[] = 611 { 612 expandGLFloatToInteger(reference0) + FLOAT_EXPANSION_E_64, 613 expandGLFloatToInteger(reference1) + FLOAT_EXPANSION_E_64, 614 expandGLFloatToInteger(reference2) + FLOAT_EXPANSION_E_64, 615 expandGLFloatToInteger(reference3) + FLOAT_EXPANSION_E_64 616 }; 617 618 if (floatVector4[0] < referenceAsGLintMin[0] || floatVector4[0] > referenceAsGLintMax[0] || 619 floatVector4[1] < referenceAsGLintMin[1] || floatVector4[1] > referenceAsGLintMax[1] || 620 floatVector4[2] < referenceAsGLintMin[2] || floatVector4[2] > referenceAsGLintMax[2] || 621 floatVector4[3] < referenceAsGLintMin[3] || floatVector4[3] > referenceAsGLintMax[3]) 622 { 623 testCtx.getLog() << TestLog::Message 624 << "// ERROR: expected in ranges " 625 << "[" << toHex(referenceAsGLintMin[0]) << " " << toHex(referenceAsGLintMax[0]) << "], " 626 << "[" << toHex(referenceAsGLintMin[1]) << " " << toHex(referenceAsGLintMax[1]) << "], " 627 << "[" << toHex(referenceAsGLintMin[2]) << " " << toHex(referenceAsGLintMax[2]) << "], " 628 << "[" << toHex(referenceAsGLintMin[3]) << " " << toHex(referenceAsGLintMax[3]) << "]" 629 << "; got " 630 << toHex(floatVector4[0]) << ", " 631 << toHex(floatVector4[1]) << ", " 632 << toHex(floatVector4[2]) << ", " 633 << toHex(floatVector4[3]) << " "<< TestLog::EndMessage; 634 635 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 636 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value"); 637 } 638 } 639 640 void GetInteger64Verifier::verifyFloatRange (tcu::TestContext& testCtx, GLenum name, GLfloat min, GLfloat max) 641 { 642 using tcu::TestLog; 643 644 StateQueryMemoryWriteGuard<GLint64[2]> range; 645 glGetInteger64v(name, range); 646 647 if (!range.verifyValidity(testCtx)) 648 return; 649 650 const GLint64 testRangeAsGLint[] = 651 { 652 StateQueryUtil::roundGLfloatToNearestIntegerHalfUp<GLint64>(min), 653 StateQueryUtil::roundGLfloatToNearestIntegerHalfDown<GLint64>(max) 654 }; 655 656 // check if test range outside of gl state range 657 if (testRangeAsGLint[0] < range[0] || 658 testRangeAsGLint[1] > range[1]) 659 { 660 testCtx.getLog() << TestLog::Message 661 << "// ERROR: range [" 662 << testRangeAsGLint[0] << ", " 663 << testRangeAsGLint[1] << "]" 664 << " is not in range [" 665 << range[0] << ", " 666 << range[1] << "]" << TestLog::EndMessage; 667 668 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 669 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer range"); 670 } 671 } 672 673 void GetInteger64Verifier::verifyFloatGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLfloat reference) 674 { 675 using tcu::TestLog; 676 677 StateQueryMemoryWriteGuard<GLint64> state; 678 glGetInteger64v(name, &state); 679 680 if (!state.verifyValidity(testCtx)) 681 return; 682 683 const GLint64 referenceAsInt = StateQueryUtil::roundGLfloatToNearestIntegerHalfDown<GLint64>(reference); 684 685 if (state < referenceAsInt) 686 { 687 testCtx.getLog() << TestLog::Message << "// ERROR: expected expected greater or equal to " << referenceAsInt << "; got " << state << TestLog::EndMessage; 688 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 689 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value"); 690 } 691 } 692 693 //GetFloatVerifier 694 695 class GetFloatVerifier : public StateVerifier 696 { 697 public: 698 GetFloatVerifier (const glw::Functions& gl, tcu::TestLog& log); 699 void verifyFloat (tcu::TestContext& testCtx, GLenum name, GLfloat reference); 700 void verifyFloatExpanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference); 701 void verifyFloat2Expanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1); 702 void verifyFloat4Color (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1, GLfloat reference2, GLfloat reference3); 703 void verifyFloatRange (tcu::TestContext& testCtx, GLenum name, GLfloat min, GLfloat max); 704 void verifyFloatGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLfloat reference); 705 }; 706 707 GetFloatVerifier::GetFloatVerifier (const glw::Functions& gl, tcu::TestLog& log) 708 : StateVerifier(gl, log, "_getfloat") 709 { 710 } 711 712 void GetFloatVerifier::verifyFloat (tcu::TestContext& testCtx, GLenum name, GLfloat reference) 713 { 714 using tcu::TestLog; 715 716 StateQueryMemoryWriteGuard<GLfloat> state; 717 glGetFloatv(name, &state); 718 719 if (!state.verifyValidity(testCtx)) 720 return; 721 722 if (state != reference) 723 { 724 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state << TestLog::EndMessage; 725 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 726 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value"); 727 } 728 } 729 730 void GetFloatVerifier::verifyFloatExpanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference) 731 { 732 DE_ASSERT(de::inRange(reference, -1.0f, 1.0f)); 733 verifyFloat(testCtx, name, reference); 734 } 735 736 void GetFloatVerifier::verifyFloat2Expanded (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1) 737 { 738 DE_ASSERT(de::inRange(reference0, -1.0f, 1.0f)); 739 DE_ASSERT(de::inRange(reference1, -1.0f, 1.0f)); 740 741 using tcu::TestLog; 742 743 StateQueryMemoryWriteGuard<GLfloat[2]> floatVector2; 744 glGetFloatv(name, floatVector2); 745 746 if (!floatVector2.verifyValidity(testCtx)) 747 return; 748 749 if (floatVector2[0] != reference0 || 750 floatVector2[1] != reference1) 751 { 752 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference0 << ", " << reference1 << "; got " << floatVector2[0] << " " << floatVector2[1] << TestLog::EndMessage; 753 754 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 755 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value"); 756 } 757 } 758 759 void GetFloatVerifier::verifyFloat4Color (tcu::TestContext& testCtx, GLenum name, GLfloat reference0, GLfloat reference1, GLfloat reference2, GLfloat reference3) 760 { 761 using tcu::TestLog; 762 763 StateQueryMemoryWriteGuard<GLfloat[4]> floatVector4; 764 glGetFloatv(name, floatVector4); 765 766 if (!floatVector4.verifyValidity(testCtx)) 767 return; 768 769 if (floatVector4[0] != reference0 || 770 floatVector4[1] != reference1 || 771 floatVector4[2] != reference2 || 772 floatVector4[3] != reference3) 773 { 774 testCtx.getLog() << TestLog::Message 775 << "// ERROR: expected "<< reference0 << ", " << reference1 << ", " << reference2 << ", " << reference3 776 << "; got " << floatVector4[0] << ", " << floatVector4[1] << ", " << floatVector4[2] << ", " << floatVector4[3] 777 << TestLog::EndMessage; 778 779 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 780 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value"); 781 } 782 } 783 784 void GetFloatVerifier::verifyFloatRange (tcu::TestContext& testCtx, GLenum name, GLfloat min, GLfloat max) 785 { 786 using tcu::TestLog; 787 788 StateQueryMemoryWriteGuard<GLfloat[2]> floatVector2; 789 glGetFloatv(name, floatVector2); 790 791 if (!floatVector2.verifyValidity(testCtx)) 792 return; 793 794 if (floatVector2[0] > min || 795 floatVector2[1] < max) 796 { 797 testCtx.getLog() << TestLog::Message << "// ERROR: expected in range [" << min << ", " << max << "]; got [" << floatVector2[0] << " " << floatVector2[1] << "]" << TestLog::EndMessage; 798 799 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 800 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float range"); 801 } 802 } 803 804 void GetFloatVerifier::verifyFloatGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLfloat reference) 805 { 806 using tcu::TestLog; 807 808 StateQueryMemoryWriteGuard<GLfloat> state; 809 glGetFloatv(name, &state); 810 811 if (!state.verifyValidity(testCtx)) 812 return; 813 814 if (state < reference) 815 { 816 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << reference << "; got " << state << TestLog::EndMessage; 817 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) 818 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value"); 819 } 820 } 821 822 823 } // FloatStateQueryVerifiers 824 825 namespace 826 { 827 828 using namespace FloatStateQueryVerifiers; 829 830 class DepthRangeCase : public ApiCase 831 { 832 public: 833 DepthRangeCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 834 : ApiCase (context, name, description) 835 , m_verifier (verifier) 836 { 837 } 838 839 void test (void) 840 { 841 de::Random rnd(0xabcdef); 842 843 m_verifier->verifyFloat2Expanded(m_testCtx, GL_DEPTH_RANGE, 0.0f, 1.0f); 844 expectError(GL_NO_ERROR); 845 846 const struct FixedTest 847 { 848 float n, f; 849 } fixedTests[] = 850 { 851 { 0.5f, 1.0f }, 852 { 0.0f, 0.5f }, 853 { 0.0f, 0.0f }, 854 { 1.0f, 1.0f } 855 }; 856 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(fixedTests); ++ndx) 857 { 858 glDepthRangef(fixedTests[ndx].n, fixedTests[ndx].f); 859 860 m_verifier->verifyFloat2Expanded(m_testCtx, GL_DEPTH_RANGE, fixedTests[ndx].n, fixedTests[ndx].f); 861 expectError(GL_NO_ERROR); 862 } 863 864 const int numIterations = 120; 865 for (int i = 0; i < numIterations; ++i) 866 { 867 GLfloat n = rnd.getFloat(0, 1); 868 GLfloat f = rnd.getFloat(0, 1); 869 870 glDepthRangef(n, f); 871 m_verifier->verifyFloat2Expanded(m_testCtx, GL_DEPTH_RANGE, n, f); 872 expectError(GL_NO_ERROR); 873 } 874 } 875 private: 876 StateVerifier* m_verifier; 877 }; 878 879 class LineWidthCase : public ApiCase 880 { 881 public: 882 LineWidthCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 883 : ApiCase (context, name, description) 884 , m_verifier (verifier) 885 { 886 } 887 888 void test (void) 889 { 890 de::Random rnd(0xabcdef); 891 892 m_verifier->verifyFloat(m_testCtx, GL_LINE_WIDTH, 1.0f); 893 expectError(GL_NO_ERROR); 894 895 GLfloat range[2] = {1}; 896 glGetFloatv(GL_ALIASED_LINE_WIDTH_RANGE, range); 897 expectError(GL_NO_ERROR); 898 899 const int numIterations = 120; 900 for (int i = 0; i < numIterations; ++i) 901 { 902 const GLfloat reference = rnd.getFloat(range[0], range[1]); 903 904 glLineWidth(reference); 905 m_verifier->verifyFloat(m_testCtx, GL_LINE_WIDTH, reference); 906 expectError(GL_NO_ERROR); 907 } 908 } 909 private: 910 StateVerifier* m_verifier; 911 }; 912 913 class PolygonOffsetFactorCase : public ApiCase 914 { 915 public: 916 PolygonOffsetFactorCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 917 : ApiCase (context, name, description) 918 , m_verifier (verifier) 919 { 920 } 921 922 void test (void) 923 { 924 de::Random rnd(0xabcdef); 925 926 m_verifier->verifyFloat(m_testCtx, GL_POLYGON_OFFSET_FACTOR, 0.0f); 927 expectError(GL_NO_ERROR); 928 929 const float fixedTests[] = 930 { 931 0.0f, 0.5f, -0.5f, 1.5f 932 }; 933 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(fixedTests); ++ndx) 934 { 935 glPolygonOffset(fixedTests[ndx], 0); 936 m_verifier->verifyFloat(m_testCtx, GL_POLYGON_OFFSET_FACTOR, fixedTests[ndx]); 937 expectError(GL_NO_ERROR); 938 } 939 940 const int numIterations = 120; 941 for (int i = 0; i < numIterations; ++i) 942 { 943 const GLfloat reference = rnd.getFloat(-64000, 64000); 944 945 glPolygonOffset(reference, 0); 946 m_verifier->verifyFloat(m_testCtx, GL_POLYGON_OFFSET_FACTOR, reference); 947 expectError(GL_NO_ERROR); 948 } 949 } 950 private: 951 StateVerifier* m_verifier; 952 }; 953 954 class PolygonOffsetUnitsCase : public ApiCase 955 { 956 public: 957 PolygonOffsetUnitsCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 958 : ApiCase (context, name, description) 959 , m_verifier (verifier) 960 { 961 } 962 963 void test (void) 964 { 965 de::Random rnd(0xabcdef); 966 967 m_verifier->verifyFloat(m_testCtx, GL_POLYGON_OFFSET_UNITS, 0.0f); 968 expectError(GL_NO_ERROR); 969 970 const float fixedTests[] = 971 { 972 0.0f, 0.5f, -0.5f, 1.5f 973 }; 974 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(fixedTests); ++ndx) 975 { 976 glPolygonOffset(0, fixedTests[ndx]); 977 m_verifier->verifyFloat(m_testCtx, GL_POLYGON_OFFSET_UNITS, fixedTests[ndx]); 978 expectError(GL_NO_ERROR); 979 } 980 981 const int numIterations = 120; 982 for (int i = 0; i < numIterations; ++i) 983 { 984 const GLfloat reference = rnd.getFloat(-64000, 64000); 985 986 glPolygonOffset(0, reference); 987 m_verifier->verifyFloat(m_testCtx, GL_POLYGON_OFFSET_UNITS, reference); 988 expectError(GL_NO_ERROR); 989 } 990 } 991 private: 992 StateVerifier* m_verifier; 993 }; 994 995 class SampleCoverageCase : public ApiCase 996 { 997 public: 998 SampleCoverageCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 999 : ApiCase (context, name, description) 1000 , m_verifier (verifier) 1001 { 1002 } 1003 1004 void test (void) 1005 { 1006 de::Random rnd(0xabcdef); 1007 1008 m_verifier->verifyFloat(m_testCtx, GL_SAMPLE_COVERAGE_VALUE, 1.0f); 1009 expectError(GL_NO_ERROR); 1010 1011 { 1012 const float fixedTests[] = 1013 { 1014 0.0f, 0.5f, 0.45f, 0.55f 1015 }; 1016 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(fixedTests); ++ndx) 1017 { 1018 glSampleCoverage(fixedTests[ndx], GL_FALSE); 1019 m_verifier->verifyFloat(m_testCtx, GL_SAMPLE_COVERAGE_VALUE, fixedTests[ndx]); 1020 expectError(GL_NO_ERROR); 1021 } 1022 } 1023 1024 { 1025 const float clampTests[] = 1026 { 1027 -1.0f, -1.5f, 1.45f, 3.55f 1028 }; 1029 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(clampTests); ++ndx) 1030 { 1031 glSampleCoverage(clampTests[ndx], GL_FALSE); 1032 m_verifier->verifyFloat(m_testCtx, GL_SAMPLE_COVERAGE_VALUE, de::clamp(clampTests[ndx], 0.0f, 1.0f)); 1033 expectError(GL_NO_ERROR); 1034 } 1035 } 1036 1037 { 1038 const int numIterations = 120; 1039 for (int i = 0; i < numIterations; ++i) 1040 { 1041 GLfloat reference = rnd.getFloat(0, 1); 1042 GLboolean invert = rnd.getBool() ? GL_TRUE : GL_FALSE; 1043 1044 glSampleCoverage(reference, invert); 1045 m_verifier->verifyFloat(m_testCtx, GL_SAMPLE_COVERAGE_VALUE, reference); 1046 expectError(GL_NO_ERROR); 1047 } 1048 } 1049 } 1050 private: 1051 StateVerifier* m_verifier; 1052 }; 1053 1054 class BlendColorCase : public ApiCase 1055 { 1056 public: 1057 BlendColorCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 1058 : ApiCase (context, name, description) 1059 , m_verifier (verifier) 1060 { 1061 } 1062 1063 void test (void) 1064 { 1065 de::Random rnd(0xabcdef); 1066 1067 m_verifier->verifyFloat4Color(m_testCtx, GL_BLEND_COLOR, 0, 0, 0, 0); 1068 expectError(GL_NO_ERROR); 1069 1070 const struct FixedTest 1071 { 1072 float r, g, b, a; 1073 } fixedTests[] = 1074 { 1075 { 0.5f, 1.0f, 0.5f, 1.0f }, 1076 { 0.0f, 0.5f, 0.0f, 0.5f }, 1077 { 0.0f, 0.0f, 0.0f, 0.0f }, 1078 { 1.0f, 1.0f, 1.0f, 1.0f }, 1079 }; 1080 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(fixedTests); ++ndx) 1081 { 1082 glBlendColor(fixedTests[ndx].r, fixedTests[ndx].g, fixedTests[ndx].b, fixedTests[ndx].a); 1083 m_verifier->verifyFloat4Color(m_testCtx, GL_BLEND_COLOR, fixedTests[ndx].r, fixedTests[ndx].g, fixedTests[ndx].b, fixedTests[ndx].a); 1084 expectError(GL_NO_ERROR); 1085 } 1086 1087 const int numIterations = 120; 1088 for (int i = 0; i < numIterations; ++i) 1089 { 1090 const GLfloat r = rnd.getFloat(0, 1); 1091 const GLfloat g = rnd.getFloat(0, 1); 1092 const GLfloat b = rnd.getFloat(0, 1); 1093 const GLfloat a = rnd.getFloat(0, 1); 1094 1095 glBlendColor(r, g, b, a); 1096 m_verifier->verifyFloat4Color(m_testCtx, GL_BLEND_COLOR, r, g, b, a); 1097 expectError(GL_NO_ERROR); 1098 } 1099 } 1100 private: 1101 StateVerifier* m_verifier; 1102 }; 1103 1104 class ColorClearCase : public ApiCase 1105 { 1106 public: 1107 ColorClearCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 1108 : ApiCase (context, name, description) 1109 , m_verifier (verifier) 1110 { 1111 } 1112 1113 void test (void) 1114 { 1115 de::Random rnd(0xabcdef); 1116 1117 // \note Initial color clear value check is temorarily removed. (until the framework does not alter it) 1118 //m_verifier->verifyFloat4Color(m_testCtx, GL_COLOR_CLEAR_VALUE, 0, 0, 0, 0); 1119 //expectError(GL_NO_ERROR); 1120 1121 const struct FixedTest 1122 { 1123 float r, g, b, a; 1124 } fixedTests[] = 1125 { 1126 { 0.5f, 1.0f, 0.5f, 1.0f }, 1127 { 0.0f, 0.5f, 0.0f, 0.5f }, 1128 { 0.0f, 0.0f, 0.0f, 0.0f }, 1129 { 1.0f, 1.0f, 1.0f, 1.0f }, 1130 }; 1131 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(fixedTests); ++ndx) 1132 { 1133 glClearColor(fixedTests[ndx].r, fixedTests[ndx].g, fixedTests[ndx].b, fixedTests[ndx].a); 1134 m_verifier->verifyFloat4Color(m_testCtx, GL_COLOR_CLEAR_VALUE, fixedTests[ndx].r, fixedTests[ndx].g, fixedTests[ndx].b, fixedTests[ndx].a); 1135 expectError(GL_NO_ERROR); 1136 } 1137 1138 const int numIterations = 120; 1139 for (int i = 0; i < numIterations; ++i) 1140 { 1141 const GLfloat r = rnd.getFloat(0, 1); 1142 const GLfloat g = rnd.getFloat(0, 1); 1143 const GLfloat b = rnd.getFloat(0, 1); 1144 const GLfloat a = rnd.getFloat(0, 1); 1145 1146 glClearColor(r, g, b, a); 1147 m_verifier->verifyFloat4Color(m_testCtx, GL_COLOR_CLEAR_VALUE, r, g, b, a); 1148 expectError(GL_NO_ERROR); 1149 } 1150 } 1151 private: 1152 StateVerifier* m_verifier; 1153 }; 1154 1155 class DepthClearCase : public ApiCase 1156 { 1157 public: 1158 DepthClearCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 1159 : ApiCase (context, name, description) 1160 , m_verifier (verifier) 1161 { 1162 } 1163 1164 void test (void) 1165 { 1166 de::Random rnd(0xabcdef); 1167 1168 m_verifier->verifyFloatExpanded(m_testCtx, GL_DEPTH_CLEAR_VALUE, 1); 1169 expectError(GL_NO_ERROR); 1170 1171 const int numIterations = 120; 1172 for (int i = 0; i < numIterations; ++i) 1173 { 1174 const GLfloat ref = rnd.getFloat(0, 1); 1175 1176 glClearDepthf(ref); 1177 m_verifier->verifyFloatExpanded(m_testCtx, GL_DEPTH_CLEAR_VALUE, ref); 1178 expectError(GL_NO_ERROR); 1179 } 1180 } 1181 private: 1182 StateVerifier* m_verifier; 1183 }; 1184 1185 class MaxTextureLODBiasCase : public ApiCase 1186 { 1187 public: 1188 MaxTextureLODBiasCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 1189 : ApiCase (context, name, description) 1190 , m_verifier (verifier) 1191 { 1192 } 1193 1194 void test (void) 1195 { 1196 m_verifier->verifyFloatGreaterOrEqual(m_testCtx, GL_MAX_TEXTURE_LOD_BIAS, 2.0f); 1197 expectError(GL_NO_ERROR); 1198 } 1199 private: 1200 StateVerifier* m_verifier; 1201 }; 1202 1203 class AliasedPointSizeRangeCase : public ApiCase 1204 { 1205 public: 1206 AliasedPointSizeRangeCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 1207 : ApiCase (context, name, description) 1208 , m_verifier (verifier) 1209 { 1210 } 1211 1212 void test (void) 1213 { 1214 m_verifier->verifyFloatRange(m_testCtx, GL_ALIASED_POINT_SIZE_RANGE, 1, 1); 1215 expectError(GL_NO_ERROR); 1216 } 1217 private: 1218 StateVerifier* m_verifier; 1219 }; 1220 1221 class AliasedLineWidthRangeCase : public ApiCase 1222 { 1223 public: 1224 AliasedLineWidthRangeCase (Context& context, StateVerifier* verifier, const char* name, const char* description) 1225 : ApiCase (context, name, description) 1226 , m_verifier (verifier) 1227 { 1228 } 1229 1230 void test (void) 1231 { 1232 m_verifier->verifyFloatRange(m_testCtx, GL_ALIASED_LINE_WIDTH_RANGE, 1, 1); 1233 expectError(GL_NO_ERROR); 1234 } 1235 private: 1236 StateVerifier* m_verifier; 1237 }; 1238 1239 #define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \ 1240 for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \ 1241 { \ 1242 StateVerifier* verifier = VERIFIERS[_verifierNdx]; \ 1243 CODE_BLOCK; \ 1244 } 1245 1246 } // anonymous 1247 1248 FloatStateQueryTests::FloatStateQueryTests (Context& context) 1249 : TestCaseGroup (context, "floats", "Float Values") 1250 , m_verifierBoolean (DE_NULL) 1251 , m_verifierInteger (DE_NULL) 1252 , m_verifierInteger64 (DE_NULL) 1253 , m_verifierFloat (DE_NULL) 1254 { 1255 } 1256 1257 FloatStateQueryTests::~FloatStateQueryTests (void) 1258 { 1259 deinit(); 1260 } 1261 1262 void FloatStateQueryTests::init (void) 1263 { 1264 DE_ASSERT(m_verifierBoolean == DE_NULL); 1265 DE_ASSERT(m_verifierInteger == DE_NULL); 1266 DE_ASSERT(m_verifierInteger64 == DE_NULL); 1267 DE_ASSERT(m_verifierFloat == DE_NULL); 1268 1269 m_verifierBoolean = new GetBooleanVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog()); 1270 m_verifierInteger = new GetIntegerVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog()); 1271 m_verifierInteger64 = new GetInteger64Verifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog()); 1272 m_verifierFloat = new GetFloatVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog()); 1273 1274 StateVerifier* verifiers[] = {m_verifierBoolean, m_verifierInteger, m_verifierInteger64, m_verifierFloat}; 1275 1276 FOR_EACH_VERIFIER(verifiers, addChild(new DepthRangeCase (m_context, verifier, (std::string("depth_range") + verifier->getTestNamePostfix()).c_str(), "DEPTH_RANGE"))); 1277 FOR_EACH_VERIFIER(verifiers, addChild(new LineWidthCase (m_context, verifier, (std::string("line_width") + verifier->getTestNamePostfix()).c_str(), "LINE_WIDTH"))); 1278 FOR_EACH_VERIFIER(verifiers, addChild(new PolygonOffsetFactorCase (m_context, verifier, (std::string("polygon_offset_factor") + verifier->getTestNamePostfix()).c_str(), "POLYGON_OFFSET_FACTOR"))); 1279 FOR_EACH_VERIFIER(verifiers, addChild(new PolygonOffsetUnitsCase (m_context, verifier, (std::string("polygon_offset_units") + verifier->getTestNamePostfix()).c_str(), "POLYGON_OFFSET_UNITS"))); 1280 FOR_EACH_VERIFIER(verifiers, addChild(new SampleCoverageCase (m_context, verifier, (std::string("sample_coverage_value") + verifier->getTestNamePostfix()).c_str(), "SAMPLE_COVERAGE_VALUE"))); 1281 FOR_EACH_VERIFIER(verifiers, addChild(new BlendColorCase (m_context, verifier, (std::string("blend_color") + verifier->getTestNamePostfix()).c_str(), "BLEND_COLOR"))); 1282 FOR_EACH_VERIFIER(verifiers, addChild(new ColorClearCase (m_context, verifier, (std::string("color_clear_value") + verifier->getTestNamePostfix()).c_str(), "COLOR_CLEAR_VALUE"))); 1283 FOR_EACH_VERIFIER(verifiers, addChild(new DepthClearCase (m_context, verifier, (std::string("depth_clear_value") + verifier->getTestNamePostfix()).c_str(), "DEPTH_CLEAR_VALUE"))); 1284 FOR_EACH_VERIFIER(verifiers, addChild(new MaxTextureLODBiasCase (m_context, verifier, (std::string("max_texture_lod_bias") + verifier->getTestNamePostfix()).c_str(), "MAX_TEXTURE_LOD_BIAS"))); 1285 FOR_EACH_VERIFIER(verifiers, addChild(new AliasedPointSizeRangeCase (m_context, verifier, (std::string("aliased_point_size_range") + verifier->getTestNamePostfix()).c_str(), "ALIASED_POINT_SIZE_RANGE"))); 1286 FOR_EACH_VERIFIER(verifiers, addChild(new AliasedLineWidthRangeCase (m_context, verifier, (std::string("aliased_line_width_range") + verifier->getTestNamePostfix()).c_str(), "ALIASED_LINE_WIDTH_RANGE"))); 1287 } 1288 1289 void FloatStateQueryTests::deinit (void) 1290 { 1291 if (m_verifierBoolean) 1292 { 1293 delete m_verifierBoolean; 1294 m_verifierBoolean = DE_NULL; 1295 } 1296 if (m_verifierInteger) 1297 { 1298 delete m_verifierInteger; 1299 m_verifierInteger = DE_NULL; 1300 } 1301 if (m_verifierInteger64) 1302 { 1303 delete m_verifierInteger64; 1304 m_verifierInteger64 = DE_NULL; 1305 } 1306 if (m_verifierFloat) 1307 { 1308 delete m_verifierFloat; 1309 m_verifierFloat = DE_NULL; 1310 } 1311 1312 this->TestCaseGroup::deinit(); 1313 } 1314 1315 } // Functional 1316 } // gles3 1317 } // deqp 1318
