1 #ifndef _GLSSTATEQUERYUTIL_HPP 2 #define _GLSSTATEQUERYUTIL_HPP 3 /*------------------------------------------------------------------------- 4 * drawElements Quality Program OpenGL (ES) Module 5 * ----------------------------------------------- 6 * 7 * Copyright 2014 The Android Open Source Project 8 * 9 * Licensed under the Apache License, Version 2.0 (the "License"); 10 * you may not use this file except in compliance with the License. 11 * You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 * 21 *//*! 22 * \file 23 * \brief State Query test utils. 24 *//*--------------------------------------------------------------------*/ 25 26 #include "tcuDefs.hpp" 27 #include "tcuTestLog.hpp" 28 #include "tcuTestContext.hpp" 29 #include "tcuResultCollector.hpp" 30 #include "glwDefs.hpp" 31 #include "deMath.h" 32 33 namespace glu 34 { 35 class CallLogWrapper; 36 } // glu 37 38 namespace deqp 39 { 40 namespace gls 41 { 42 namespace StateQueryUtil 43 { 44 45 #define GLS_COLLECT_GL_ERROR(RES, ERR, MSG) \ 46 do \ 47 { \ 48 const deUint32 err = (ERR); \ 49 if (err != GL_NO_ERROR) \ 50 (RES).fail(std::string("Got Error ") + glu::getErrorStr(err).toString() + ": " + (MSG)); \ 51 } \ 52 while (deGetFalse()) 53 54 /*--------------------------------------------------------------------*//*! 55 * \brief Rounds given float to the nearest integer (half up). 56 * 57 * Returns the nearest integer for a float argument. In the case that there 58 * are two nearest integers at the equal distance (aka. the argument is of 59 * form x.5), the integer with the higher value is chosen. (x.5 rounds to x+1) 60 *//*--------------------------------------------------------------------*/ 61 template <typename T> 62 T roundGLfloatToNearestIntegerHalfUp (float val) 63 { 64 return (T)(deFloatFloor(val + 0.5f)); 65 } 66 67 /*--------------------------------------------------------------------*//*! 68 * \brief Rounds given float to the nearest integer (half down). 69 * 70 * Returns the nearest integer for a float argument. In the case that there 71 * are two nearest integers at the equal distance (aka. the argument is of 72 * form x.5), the integer with the higher value is chosen. (x.5 rounds to x) 73 *//*--------------------------------------------------------------------*/ 74 template <typename T> 75 T roundGLfloatToNearestIntegerHalfDown (float val) 76 { 77 return (T)(deFloatCeil(val - 0.5f)); 78 } 79 80 template <typename T> 81 class StateQueryMemoryWriteGuard 82 { 83 public: 84 StateQueryMemoryWriteGuard (void); 85 86 operator T& (void); 87 T* operator & (void); 88 89 bool isUndefined (void) const; 90 bool isMemoryContaminated (void) const; 91 bool isPreguardContaminated (void) const; 92 bool isPostguardContaminated (void) const; 93 bool verifyValidity (tcu::TestContext& testCtx) const; 94 bool verifyValidity (tcu::ResultCollector& result) const; 95 96 const T& get (void) const { return m_value; } 97 98 private: 99 enum 100 { 101 WRITE_GUARD_VALUE = 0xDE 102 }; 103 104 T m_preguard; 105 T m_value; 106 T m_postguard; // \note guards are not const qualified since the GL implementation might modify them 107 }; 108 109 template <typename T> 110 StateQueryMemoryWriteGuard<T>::StateQueryMemoryWriteGuard (void) 111 { 112 DE_STATIC_ASSERT(sizeof(T) * 3 == sizeof(StateQueryMemoryWriteGuard<T>)); // tightly packed 113 114 for (size_t i = 0; i < sizeof(T); ++i) 115 { 116 ((deUint8*)&m_preguard)[i] = (deUint8)WRITE_GUARD_VALUE; 117 ((deUint8*)&m_value)[i] = (deUint8)WRITE_GUARD_VALUE; 118 ((deUint8*)&m_postguard)[i] = (deUint8)WRITE_GUARD_VALUE; 119 } 120 } 121 122 template <typename T> 123 StateQueryMemoryWriteGuard<T>::operator T& (void) 124 { 125 return m_value; 126 } 127 128 template <typename T> 129 T* StateQueryMemoryWriteGuard<T>::operator & (void) 130 { 131 return &m_value; 132 } 133 134 template <typename T> 135 bool StateQueryMemoryWriteGuard<T>::isUndefined () const 136 { 137 for (size_t i = 0; i < sizeof(T); ++i) 138 if (((deUint8*)&m_value)[i] != (deUint8)WRITE_GUARD_VALUE) 139 return false; 140 return true; 141 } 142 143 template <typename T> 144 bool StateQueryMemoryWriteGuard<T>::isMemoryContaminated () const 145 { 146 return isPreguardContaminated() || isPostguardContaminated(); 147 } 148 149 template <typename T> 150 bool StateQueryMemoryWriteGuard<T>::isPreguardContaminated (void) const 151 { 152 for (size_t i = 0; i < sizeof(T); ++i) 153 if (((deUint8*)&m_preguard)[i] != (deUint8)WRITE_GUARD_VALUE) 154 return true; 155 return false; 156 } 157 158 template <typename T> 159 bool StateQueryMemoryWriteGuard<T>::isPostguardContaminated (void) const 160 { 161 for (size_t i = 0; i < sizeof(T); ++i) 162 if (((deUint8*)&m_postguard)[i] != (deUint8)WRITE_GUARD_VALUE) 163 return true; 164 return false; 165 } 166 167 template <typename T> 168 bool StateQueryMemoryWriteGuard<T>::verifyValidity (tcu::TestContext& testCtx) const 169 { 170 using tcu::TestLog; 171 172 if (isPreguardContaminated()) 173 { 174 testCtx.getLog() << TestLog::Message << "// ERROR: Pre-guard value was modified " << TestLog::EndMessage; 175 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS || 176 testCtx.getTestResult() == QP_TEST_RESULT_LAST) 177 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Get* did an illegal memory write"); 178 179 return false; 180 } 181 else if (isPostguardContaminated()) 182 { 183 testCtx.getLog() << TestLog::Message << "// ERROR: Post-guard value was modified " << TestLog::EndMessage; 184 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS || 185 testCtx.getTestResult() == QP_TEST_RESULT_LAST) 186 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Get* did an illegal memory write"); 187 188 return false; 189 } 190 else if (isUndefined()) 191 { 192 testCtx.getLog() << TestLog::Message << "// ERROR: Get* did not return a value" << TestLog::EndMessage; 193 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS || 194 testCtx.getTestResult() == QP_TEST_RESULT_LAST) 195 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Get* did not return a value"); 196 197 return false; 198 } 199 200 return true; 201 } 202 203 template <typename T> 204 bool StateQueryMemoryWriteGuard<T>::verifyValidity (tcu::ResultCollector& result) const 205 { 206 using tcu::TestLog; 207 208 if (isPreguardContaminated()) 209 { 210 result.fail("pre-guard value was modified"); 211 return false; 212 } 213 else if (isPostguardContaminated()) 214 { 215 result.fail("post-guard value was modified"); 216 return false; 217 } 218 else if (isUndefined()) 219 { 220 result.fail("Get* did not return a value"); 221 return false; 222 } 223 224 return true; 225 } 226 227 template<typename T> 228 std::ostream& operator<< (std::ostream& str, const StateQueryMemoryWriteGuard<T>& guard) 229 { 230 return str << guard.get(); 231 } 232 233 // Verifiers 234 235 enum QueryType 236 { 237 QUERY_BOOLEAN = 0, 238 QUERY_BOOLEAN_VEC4, 239 QUERY_ISENABLED, 240 QUERY_INTEGER, 241 QUERY_INTEGER64, 242 QUERY_FLOAT, 243 244 // indexed 245 QUERY_INDEXED_BOOLEAN, 246 QUERY_INDEXED_BOOLEAN_VEC4, 247 QUERY_INDEXED_ISENABLED, 248 QUERY_INDEXED_INTEGER, 249 QUERY_INDEXED_INTEGER_VEC4, 250 QUERY_INDEXED_INTEGER64, 251 QUERY_INDEXED_INTEGER64_VEC4, 252 253 // attributes 254 QUERY_ATTRIBUTE_INTEGER, 255 QUERY_ATTRIBUTE_FLOAT, 256 QUERY_ATTRIBUTE_PURE_INTEGER, 257 QUERY_ATTRIBUTE_PURE_UNSIGNED_INTEGER, 258 259 // fb 260 QUERY_FRAMEBUFFER_INTEGER, 261 262 // program 263 QUERY_PROGRAM_INTEGER, 264 QUERY_PROGRAM_INTEGER_VEC3, 265 266 // program pipeline 267 QUERY_PIPELINE_INTEGER, 268 269 // texture param 270 QUERY_TEXTURE_PARAM_INTEGER, 271 QUERY_TEXTURE_PARAM_FLOAT, 272 QUERY_TEXTURE_PARAM_PURE_INTEGER, 273 QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER, 274 QUERY_TEXTURE_PARAM_INTEGER_VEC4, 275 QUERY_TEXTURE_PARAM_FLOAT_VEC4, 276 QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4, 277 QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4, 278 279 // texture level 280 QUERY_TEXTURE_LEVEL_INTEGER, 281 QUERY_TEXTURE_LEVEL_FLOAT, 282 283 // pointer 284 QUERY_POINTER, 285 286 // object states 287 QUERY_ISTEXTURE, 288 289 // query queries 290 QUERY_QUERY, 291 292 // sampler state 293 QUERY_SAMPLER_PARAM_INTEGER, 294 QUERY_SAMPLER_PARAM_FLOAT, 295 QUERY_SAMPLER_PARAM_PURE_INTEGER, 296 QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER, 297 QUERY_SAMPLER_PARAM_INTEGER_VEC4, 298 QUERY_SAMPLER_PARAM_FLOAT_VEC4, 299 QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4, 300 QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4, 301 302 QUERY_LAST 303 }; 304 305 enum DataType 306 { 307 DATATYPE_BOOLEAN = 0, 308 DATATYPE_INTEGER, 309 DATATYPE_INTEGER64, 310 DATATYPE_FLOAT, 311 DATATYPE_UNSIGNED_INTEGER, 312 DATATYPE_INTEGER_VEC3, 313 DATATYPE_FLOAT_VEC4, 314 DATATYPE_INTEGER_VEC4, 315 DATATYPE_INTEGER64_VEC4, 316 DATATYPE_UNSIGNED_INTEGER_VEC4, 317 DATATYPE_BOOLEAN_VEC4, 318 DATATYPE_POINTER, 319 320 DATATYPE_LAST 321 }; 322 323 class QueriedState 324 { 325 public: 326 typedef glw::GLint GLIntVec3[3]; 327 typedef glw::GLint GLIntVec4[4]; 328 typedef glw::GLuint GLUintVec4[4]; 329 typedef glw::GLfloat GLFloatVec4[4]; 330 typedef bool BooleanVec4[4]; 331 typedef glw::GLint64 GLInt64Vec4[4]; 332 333 QueriedState (void); 334 explicit QueriedState (glw::GLint); 335 explicit QueriedState (glw::GLint64); 336 explicit QueriedState (bool); 337 explicit QueriedState (glw::GLfloat); 338 explicit QueriedState (glw::GLuint); 339 explicit QueriedState (const GLIntVec3&); 340 explicit QueriedState (void*); 341 explicit QueriedState (const GLIntVec4&); 342 explicit QueriedState (const GLUintVec4&); 343 explicit QueriedState (const GLFloatVec4&); 344 explicit QueriedState (const BooleanVec4&); 345 explicit QueriedState (const GLInt64Vec4&); 346 347 bool isUndefined (void) const; 348 DataType getType (void) const; 349 350 glw::GLint& getIntAccess (void); 351 glw::GLint64& getInt64Access (void); 352 bool& getBoolAccess (void); 353 glw::GLfloat& getFloatAccess (void); 354 glw::GLuint& getUintAccess (void); 355 GLIntVec3& getIntVec3Access (void); 356 void*& getPtrAccess (void); 357 GLIntVec4& getIntVec4Access (void); 358 GLUintVec4& getUintVec4Access (void); 359 GLFloatVec4& getFloatVec4Access (void); 360 BooleanVec4& getBooleanVec4Access (void); 361 GLInt64Vec4& getInt64Vec4Access (void); 362 363 private: 364 DataType m_type; 365 union 366 { 367 glw::GLint vInt; 368 glw::GLint64 vInt64; 369 bool vBool; 370 glw::GLfloat vFloat; 371 glw::GLuint vUint; 372 GLIntVec3 vIntVec3; 373 void* vPtr; 374 GLIntVec4 vIntVec4; 375 GLUintVec4 vUintVec4; 376 GLFloatVec4 vFloatVec4; 377 BooleanVec4 vBooleanVec4; 378 GLInt64Vec4 vInt64Vec4; 379 } m_v; 380 }; 381 382 // query functions 383 384 void queryState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum pname, QueriedState& state); 385 void queryIndexedState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, int index, QueriedState& state); 386 void queryAttributeState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, int index, QueriedState& state); 387 void queryFramebufferState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, glw::GLenum pname, QueriedState& state); 388 void queryProgramState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint program, glw::GLenum pname, QueriedState& state); 389 void queryPipelineState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint pipeline, glw::GLenum pname, QueriedState& state); 390 void queryTextureParamState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, glw::GLenum pname, QueriedState& state); 391 void queryTextureLevelState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, int level, glw::GLenum pname, QueriedState& state); 392 void queryPointerState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum pname, QueriedState& state); 393 void queryObjectState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint handle, QueriedState& state); 394 void queryQueryState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, glw::GLenum pname, QueriedState& state); 395 void querySamplerState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint sampler, glw::GLenum pname, QueriedState& state); 396 397 // verification functions 398 399 void verifyBoolean (tcu::ResultCollector& result, QueriedState& state, bool expected); 400 void verifyInteger (tcu::ResultCollector& result, QueriedState& state, int expected); 401 void verifyIntegerMin (tcu::ResultCollector& result, QueriedState& state, int minValue); 402 void verifyIntegerMax (tcu::ResultCollector& result, QueriedState& state, int maxValue); 403 void verifyIntegersEqual (tcu::ResultCollector& result, QueriedState& stateA, QueriedState& stateB); 404 void verifyFloat (tcu::ResultCollector& result, QueriedState& state, float expected); 405 void verifyFloatMin (tcu::ResultCollector& result, QueriedState& state, float minValue); 406 void verifyFloatMax (tcu::ResultCollector& result, QueriedState& state, float maxValue); 407 void verifyIntegerVec3 (tcu::ResultCollector& result, QueriedState& state, const tcu::IVec3& expected); 408 void verifyIntegerVec4 (tcu::ResultCollector& result, QueriedState& state, const tcu::IVec4& expected); 409 void verifyUnsignedIntegerVec4 (tcu::ResultCollector& result, QueriedState& state, const tcu::UVec4& expected); 410 void verifyFloatVec4 (tcu::ResultCollector& result, QueriedState& state, const tcu::Vec4& expected); 411 void verifyBooleanVec4 (tcu::ResultCollector& result, QueriedState& state, const tcu::BVec4& expected); 412 void verifyPointer (tcu::ResultCollector& result, QueriedState& state, const void* expected); 413 void verifyNormalizedI32Vec4 (tcu::ResultCollector& result, QueriedState& state, const tcu::IVec4& expected); 414 415 // Helper functions that both query and verify 416 417 void verifyStateBoolean (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, bool expected, QueryType type); 418 void verifyStateInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int expected, QueryType type); 419 void verifyStateIntegerMin (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int minValue, QueryType type); 420 void verifyStateIntegerMax (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int maxValue, QueryType type); 421 void verifyStateIntegerEqualToOther (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum other, QueryType type); 422 void verifyStateFloat (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, float reference, QueryType type); 423 void verifyStateFloatMin (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, float minValue, QueryType type); 424 void verifyStateFloatMax (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, float maxValue, QueryType type); 425 void verifyStatePointer (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, const void* expected, QueryType type); 426 void verifyStateIndexedBoolean (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, bool expected, QueryType type); 427 void verifyStateIndexedBooleanVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, const tcu::BVec4& expected, QueryType type); 428 void verifyStateIndexedInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, int expected, QueryType type); 429 void verifyStateIndexedIntegerMin (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, int minValue, QueryType type); 430 void verifyStateAttributeInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, int expected, QueryType type); 431 void verifyStateFramebufferInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, int expected, QueryType type); 432 void verifyStateFramebufferIntegerMin (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, int minValue, QueryType type); 433 void verifyStateProgramInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint program, glw::GLenum pname, int expected, QueryType type); 434 void verifyStateProgramIntegerVec3 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint program, glw::GLenum pname, const tcu::IVec3& expected, QueryType type); 435 void verifyStatePipelineInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint pipeline, glw::GLenum pname, int expected, QueryType type); 436 void verifyStateTextureParamInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, int expected, QueryType type); 437 void verifyStateTextureParamFloat (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, float expected, QueryType type); 438 void verifyStateTextureParamFloatVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, const tcu::Vec4& expected, QueryType type); 439 void verifyStateTextureParamNormalizedI32Vec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, const tcu::IVec4& expected, QueryType type); 440 void verifyStateTextureParamIntegerVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, const tcu::IVec4& expected, QueryType type); 441 void verifyStateTextureParamUnsignedIntegerVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, const tcu::UVec4& expected, QueryType type); 442 void verifyStateTextureLevelInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int level, glw::GLenum pname, int expected, QueryType type); 443 void verifyStateObjectBoolean (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint handle, bool expected, QueryType type); 444 void verifyStateQueryInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, int expected, QueryType type); 445 void verifyStateSamplerParamInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, int expected, QueryType type); 446 void verifyStateSamplerParamFloat (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, float expected, QueryType type); 447 void verifyStateSamplerParamFloatVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, const tcu::Vec4& expected, QueryType type); 448 void verifyStateSamplerParamNormalizedI32Vec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, const tcu::IVec4& expected, QueryType type); 449 void verifyStateSamplerParamIntegerVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, const tcu::IVec4& expected, QueryType type); 450 void verifyStateSamplerParamUnsignedIntegerVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, const tcu::UVec4& expected, QueryType type); 451 452 } // StateQueryUtil 453 } // gls 454 } // deqp 455 456 #endif // _GLSSTATEQUERYUTIL_HPP 457
