1 #ifndef _GL4CKHRDEBUGTESTS_HPP 2 #define _GL4CKHRDEBUGTESTS_HPP 3 /*------------------------------------------------------------------------- 4 * OpenGL Conformance Test Suite 5 * ----------------------------- 6 * 7 * Copyright (c) 2015-2016 The Khronos Group Inc. 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 24 */ /*-------------------------------------------------------------------*/ 25 26 /** 27 * \file gl4cKHRDebugTests.hpp 28 * \brief Declares test classes for "KHR Debug" functionality. 29 */ /*-------------------------------------------------------------------*/ 30 31 #include "glcTestCase.hpp" 32 #include "glwDefs.hpp" 33 34 #include "deThreadLocal.hpp" 35 36 namespace glu 37 { 38 class RenderContext; 39 } 40 41 namespace glw 42 { 43 class Functions; 44 } 45 46 namespace gl4cts 47 { 48 namespace KHRDebug 49 { 50 /** Base of all test cases. 51 * Manages rendering context 52 **/ 53 class TestBase 54 { 55 public: 56 /* Public methods */ 57 TestBase(deqp::Context& context, bool is_debug); 58 virtual ~TestBase(); 59 60 protected: 61 /* Protected methods */ 62 void init(); 63 void done(); 64 65 /* Protected fields */ 66 const glw::Functions* m_gl; 67 const bool m_is_debug; 68 glu::RenderContext* m_rc; 69 70 private: 71 /* Private methods */ 72 void initDebug(); 73 void initNonDebug(); 74 75 /* Private fields */ 76 deqp::Context& m_test_base_context; 77 glu::RenderContext* m_orig_rc; 78 }; 79 80 /** Implementation of test APIErrors. Description follows: 81 * 82 * This test verifies that errors are generated as expected. 83 * 84 * This test should be executed for DEBUG and NON-DEBUG contexts. 85 * 86 * DebugMessageControl function should generate: 87 * - INVALID_ENUM when <source> is invalid; 88 * - INVALID_ENUM when <type> is invalid; 89 * - INVALID_ENUM when <severity> is invalid; 90 * - INVALID_VALUE when <count> is negative; 91 * - INVALID_OPERATION when <count> is not zero and <source> is DONT_CARE; 92 * - INVALID_OPERATION when <count> is not zero and <type> is DONT_CARE; 93 * - INVALID_OPERATION when <count> is not zero and <severity> is not 94 * DONT_CARE. 95 * 96 * GetDebugMessageLog function should generate: 97 * - INVALID_VALUE when <bufSize> is negative and messageLog is not NULL. 98 * 99 * DebugMessageInsert function should generate: 100 * - INVALID_ENUM when <source> is not DEBUG_SOURCE_APPLICATION or 101 * DEBUG_SOURCE_THIRD_PARTY; 102 * - INVALID_ENUM when <type> is invalid; 103 * - INVALID_ENUM when <severity> is invalid; 104 * - INVALID_VALUE when length of string <buf> is not less than 105 * MAX_DEBUG_MESSAGE_LENGTH. 106 * 107 * PushDebugGroup function should generate: 108 * - INVALID_ENUM when <source> is not DEBUG_SOURCE_APPLICATION or 109 * DEBUG_SOURCE_THIRD_PARTY; 110 * - INVALID_VALUE when length of string <message> is not less than 111 * MAX_DEBUG_MESSAGE_LENGTH; 112 * - STACK_OVERFLOW when stack contains MAX_DEBUG_GROUP_STACK_DEPTH entries. 113 * 114 * PopDebugGroup function should generate: 115 * - STACK_UNDERFLOW when stack contains no entries. 116 * 117 * ObjectLabel function should generate: 118 * - INVALID_ENUM when <identifier> is invalid; 119 * - INVALID_VALUE when if <name> is not valid object name of type specified by 120 * <identifier>; 121 * - INVALID_VALUE when length of string <label> is not less than 122 * MAX_LABEL_LENGTH. 123 * 124 * GetObjectLabel function should generate: 125 * - INVALID_ENUM when <identifier> is invalid; 126 * - INVALID_VALUE when if <name> is not valid object name of type specified by 127 * <identifier>; 128 * - INVALID_VALUE when <bufSize> is negative. 129 * 130 * ObjectPtrLabel function should generate: 131 * - INVALID_VALUE when <ptr> is not the name of sync object; 132 * - INVALID_VALUE when length of string <label> is not less than 133 * MAX_LABEL_LENGTH. 134 * 135 * GetObjectPtrLabel function should generate: 136 * - INVALID_VALUE when <ptr> is not the name of sync object; 137 * - INVALID_VALUE when <bufSize> is negative. 138 * 139 * GetPointerv function should generate: 140 * - INVALID_ENUM when <pname> is invalid. 141 **/ 142 class APIErrorsTest : public deqp::TestCase, public TestBase 143 { 144 public: 145 /* Public methods */ 146 APIErrorsTest(deqp::Context& context, bool is_debug, const glw::GLchar* name); 147 148 virtual ~APIErrorsTest() 149 { 150 } 151 152 /* Public methods inherited from TestCase */ 153 virtual tcu::TestNode::IterateResult iterate(void); 154 }; 155 156 /** Implementation of test Labels. Description follows: 157 * 158 * This test verifies that it is possible to assign and query labels. 159 * 160 * This test should be executed for DEBUG and NON-DEBUG contexts. 161 * 162 * For each valid object type: 163 * - create new object; 164 * - query label; It is expected that result will be an empty string and length 165 * will be zero; 166 * - assign label to object; 167 * - query label; It is expected that result will be equal to the provided 168 * label and length will be correct; 169 * - query length only; Correct value is expected; 170 * - query label with <bufSize> less than actual length of label; It is 171 * expected that only <bufSize> characters will be stored in buffer (including 172 * NULL); 173 * - query label with <bufSize> equal zero; It is expected that buffer contents 174 * will not be modified; 175 * - assign empty string as label to object; 176 * - query label, it is expected that result will be an empty string and length 177 * will be zero; 178 * - assign NULL as label to object; 179 * - query label, it is expected that result will be an empty string and length 180 * will be zero; 181 * - delete object. 182 **/ 183 class LabelsTest : public deqp::TestCase, public TestBase 184 { 185 public: 186 /* Public methods */ 187 LabelsTest(deqp::Context& context, bool is_debug, const glw::GLchar* name); 188 189 virtual ~LabelsTest() 190 { 191 } 192 193 /* Public methods inherited from TestCase */ 194 virtual tcu::TestNode::IterateResult iterate(void); 195 196 private: 197 /* Private routines */ 198 static glw::GLuint createBuffer(const glw::Functions* gl, const glu::RenderContext* rc); 199 static glw::GLuint createFramebuffer(const glw::Functions* gl, const glu::RenderContext* rc); 200 static glw::GLuint createProgram(const glw::Functions* gl, const glu::RenderContext* rc); 201 static glw::GLuint createProgramPipeline(const glw::Functions* gl, const glu::RenderContext* rc); 202 static glw::GLuint createQuery(const glw::Functions* gl, const glu::RenderContext* rc); 203 static glw::GLuint createRenderbuffer(const glw::Functions* gl, const glu::RenderContext* rc); 204 static glw::GLuint createSampler(const glw::Functions* gl, const glu::RenderContext* rc); 205 static glw::GLuint createShader(const glw::Functions* gl, const glu::RenderContext* rc); 206 static glw::GLuint createTexture(const glw::Functions* gl, const glu::RenderContext* rc); 207 static glw::GLuint createTransformFeedback(const glw::Functions* gl, const glu::RenderContext* rc); 208 static glw::GLuint createVertexArray(const glw::Functions* gl, const glu::RenderContext* rc); 209 210 static glw::GLvoid deleteBuffer(const glw::Functions* gl, glw::GLuint id); 211 static glw::GLvoid deleteFramebuffer(const glw::Functions* gl, glw::GLuint id); 212 static glw::GLvoid deleteProgram(const glw::Functions* gl, glw::GLuint id); 213 static glw::GLvoid deleteProgramPipeline(const glw::Functions* gl, glw::GLuint id); 214 static glw::GLvoid deleteQuery(const glw::Functions* gl, glw::GLuint id); 215 static glw::GLvoid deleteRenderbuffer(const glw::Functions* gl, glw::GLuint id); 216 static glw::GLvoid deleteSampler(const glw::Functions* gl, glw::GLuint id); 217 static glw::GLvoid deleteShader(const glw::Functions* gl, glw::GLuint id); 218 static glw::GLvoid deleteTexture(const glw::Functions* gl, glw::GLuint id); 219 static glw::GLvoid deleteTransformFeedback(const glw::Functions* gl, glw::GLuint id); 220 static glw::GLvoid deleteVertexArray(const glw::Functions* gl, glw::GLuint id); 221 }; 222 223 /** Implementation of test ReceiveingMessages. Description follows: 224 * 225 * This test verifies that it is possible to receive messages. 226 * 227 * This test should be executed for DEBUG contexts only. 228 * 229 * Callback used during the test should make use of <userParam> to inform the 230 * test about any calls. 231 * 232 * Steps: 233 * - verify that the state of DEBUG_OUTPUT is enabled as it should be by 234 * default; 235 * - verify that state of DEBUG_CALLBACK_FUNCTION and 236 * DEBUG_CALLBACK_USER_PARAM are NULL; 237 * 238 * - insert a message with DebugMessageInsert; 239 * - inspect message log to check if the message is reported; 240 * - inspect message log again, there should be no messages; 241 * 242 * - disable DEBUG_OUTPUT; 243 * - insert a message with DebugMessageInsert; 244 * - inspect message log again, there should be no messages; 245 * 246 * - enable DEBUG_OUTPUT; 247 * - register debug message callback with DebugMessageCallback; 248 * - verify that the state of DEBUG_CALLBACK_FUNCTION and 249 * DEBUG_CALLBACK_USER_PARAM are correct; 250 * - insert a message with DebugMessageInsert; 251 * - it is expected that debug message callback will be executed for 252 * the message; 253 * - inspect message log to check there are no messages; 254 * 255 * - disable DEBUG_OUTPUT; 256 * - insert a message with DebugMessageInsert; 257 * - debug message callback should not be called; 258 * - inspect message log to check there are no messages; 259 * 260 * - enable DEBUG_OUTPUT; 261 * - execute DebugMessageControl with <type> DEBUG_TYPE_ERROR, <severity> 262 * DEBUG_SEVERITY_HIGH and <enabled> FALSE; 263 * - insert a message with DebugMessageInsert, set <type> to DEBUG_TYPE_ERROR 264 * and <severity> DEBUG_SEVERITY_MEDIUM; 265 * - insert a message with DebugMessageInsert, set <type> to DEBUG_TYPE_OTHER 266 * and <severity> DEBUG_SEVERITY_HIGH; 267 * - insert a message with DebugMessageInsert, set <type> to DEBUG_TYPE_OTHER 268 * and <severity> DEBUG_SEVERITY_LOW; 269 * - debug message callback should not be called; 270 * - inspect message log to check there are no messages; 271 * 272 * - set NULL as debug message callback; 273 * - verify that state of DEBUG_CALLBACK_FUNCTION and 274 * DEBUG_CALLBACK_USER_PARAM are NULL; 275 * - insert a message with DebugMessageInsert, set <type> to DEBUG_TYPE_ERROR 276 * and <severity> DEBUG_SEVERITY_MEDIUM; 277 * - insert a message with DebugMessageInsert, set <type> to DEBUG_TYPE_OTHER 278 * and <severity> DEBUG_SEVERITY_HIGH; 279 * - insert a message with DebugMessageInsert, set <type> to DEBUG_TYPE_OTHER 280 * and <severity> DEBUG_SEVERITY_LOW; 281 * - inspect message log to check there are no messages; 282 * 283 * - execute DebugMessageControl to enable messages of <type> DEBUG_TYPE_ERROR 284 * and <severity> DEBUG_SEVERITY_HIGH. 285 * 286 * - insert MAX_DEBUG_LOGGED_MESSAGES + 1 unique messages with 287 * DebugMessageInsert; 288 * - check state of DEBUG_LOGGED_MESSAGES; It is expected that 289 * MAX_DEBUG_LOGGED_MESSAGES will be reported; 290 * 291 * If MAX_DEBUG_LOGGED_MESSAGES is greater than 1: 292 * - inspect first half of the message log by specifying proper <count>; Verify 293 * that messages are reported in order from the oldest to the newest; Check 294 * that <count> messages were stored into provided buffers; 295 * - check state of DEBUG_LOGGED_MESSAGES; It is expected that <count> messages 296 * were removed from log; 297 * - inspect rest of the message log with <bufSize> too small to held last 298 * message; Verify that messages are reported in order from the oldest to the 299 * newest; Verify that maximum <bufSize> characters were written to 300 * <messageLog>; 301 * - check state of DEBUG_LOGGED_MESSAGES; It is expected that one message is 302 * available; 303 * - fetch the message and verify it is the newest one; 304 **/ 305 class ReceiveingMessagesTest : public deqp::TestCase, public TestBase 306 { 307 public: 308 /* Public methods */ 309 ReceiveingMessagesTest(deqp::Context& context); 310 311 virtual ~ReceiveingMessagesTest() 312 { 313 } 314 315 /* Public methods inherited from TestCase */ 316 virtual tcu::TestNode::IterateResult iterate(void); 317 318 private: 319 /* Private routines */ 320 static void GLW_APIENTRY debug_proc(glw::GLenum source, glw::GLenum type, glw::GLuint id, glw::GLenum severity, 321 glw::GLsizei length, const glw::GLchar* message, const void* info); 322 323 void inspectCallbackCounter(glw::GLuint& callback_counter, glw::GLuint expected_number_of_messages) const; 324 325 void inspectDebugState(glw::GLboolean expected_state, glw::GLDEBUGPROC expected_callback, 326 glw::GLvoid* expected_user_info) const; 327 328 void inspectMessageLog(glw::GLuint expected_number_of_messages) const; 329 }; 330 331 /** Implementation of test Groups. Description follows: 332 * 333 * This test verifies that debug message groups can be used to control which 334 * messages are being generated. 335 * 336 * This test should be executed for DEBUG contexts only. 337 * 338 * Steps: 339 * - check state of DEBUG_GROUP_STACK_DEPTH; It should be 1; 340 * 341 * - insert message with <type> DEBUG_TYPE_ERROR; 342 * - inspect message log to check if the message is reported; 343 * - insert message with <type> DEBUG_TYPE_OTHER; 344 * - inspect message log to check if the message is reported; 345 * 346 * - push debug group with unique <id> and <message>; 347 * - inspect message log to check if the message about push is reported; 348 * - disable messages with <type> DEBUG_TYPE_ERROR; 349 * - insert message with <type> DEBUG_TYPE_ERROR; 350 * - inspect message log to check there are no messages; 351 * - insert message with <type> DEBUG_TYPE_OTHER; 352 * - inspect message log to check if the message is reported; 353 * 354 * - check state of DEBUG_GROUP_STACK_DEPTH; It should be 2; 355 * 356 * - push debug group with unique <id> and <message>; 357 * - inspect message log to check if the message about push is reported; 358 * - disable messages with <type> DEBUG_TYPE_OTHER; 359 * - insert message with <type> DEBUG_TYPE_ERROR; 360 * - inspect message log to check there are no messages; 361 * - insert message with <type> DEBUG_TYPE_OTHER; 362 * - inspect message log to check there are no messages; 363 * 364 * - check state of DEBUG_GROUP_STACK_DEPTH; It should be 3; 365 * 366 * - pop debug group; 367 * - inspect message log to check if the message about pop is reported and 368 * corresponds with the second push; 369 * - insert message with <type> DEBUG_TYPE_ERROR; 370 * - inspect message log to check there are no messages; 371 * - insert message with <type> DEBUG_TYPE_OTHER; 372 * - inspect message log to check if the message is reported; 373 * 374 * - check state of DEBUG_GROUP_STACK_DEPTH; It should be 2; 375 * 376 * - pop debug group; 377 * - inspect message log to check if the message about pop is reported and 378 * corresponds with the first push; 379 * - insert message with <type> DEBUG_TYPE_ERROR; 380 * - inspect message log to check if the message is reported; 381 * - insert message with <type> DEBUG_TYPE_OTHER; 382 * - inspect message log to check if the message is reported; 383 * 384 * - check state of DEBUG_GROUP_STACK_DEPTH; It should be 1. 385 **/ 386 class GroupsTest : public deqp::TestCase, public TestBase 387 { 388 public: 389 /* Public methods */ 390 GroupsTest(deqp::Context& context); 391 392 virtual ~GroupsTest() 393 { 394 } 395 396 /* Public methods inherited from TestCase */ 397 virtual tcu::TestNode::IterateResult iterate(void); 398 399 private: 400 /* Private routines */ 401 void inspectGroupStack(glw::GLuint expected_depth) const; 402 void inspectMessageLog(glw::GLenum expected_source, glw::GLenum expected_type, glw::GLuint expected_id, 403 glw::GLenum expected_severity, glw::GLsizei expected_length, 404 const glw::GLchar* expected_label) const; 405 void verifyEmptyLog() const; 406 }; 407 408 /** Implementation of test SynchronousCalls. Description follows: 409 * 410 * This test verifies that implementation execute debug message callback in 411 * synchronous way when DEBUG_OUTPUT_SYNCHRONOUS is enabled. 412 * 413 * This test should be executed for DEBUG contexts only. 414 * 415 * Steps: 416 * - create an instance of the following structure 417 * - set callback_executed to 0; 418 * - enable DEBUG_OUTPUT_SYNCHRONOUS; 419 * - register debug message callback with DebugMessageCallback; Provide the 420 * instance of UserParam structure as <userParam>; Routine should do the 421 * following: 422 * * set callback_executed to 1; 423 * * store thread_id; 424 * - insert a message with DebugMessageInsert; 425 * - check if: 426 * * callback_executed is set to 1; 427 * * the message is recorded by the current thread. 428 * - reset userParam object; 429 * - execute BindBufferBase with GL_ARRAY_BUFFER <target>, GL_INVALID_ENUM 430 * error should be generated; 431 * - test pass if: 432 * * callback_executed is set to 0 - implementation does not send messages; 433 * * callback_executed is set to 1 and thread_id is the same 434 * as "test" thread - implementation sent message to proper thread; 435 **/ 436 class SynchronousCallsTest : public deqp::TestCase, public TestBase 437 { 438 public: 439 /* Public methods */ 440 SynchronousCallsTest(deqp::Context& context); 441 ~SynchronousCallsTest(void); 442 443 /* Public methods inherited from TestCase */ 444 virtual tcu::TestNode::IterateResult iterate(void); 445 446 private: 447 /* Private routines */ 448 static void GLW_APIENTRY debug_proc(glw::GLenum source, glw::GLenum type, glw::GLuint id, glw::GLenum severity, 449 glw::GLsizei length, const glw::GLchar* message, const void* info); 450 451 de::ThreadLocal m_tls; 452 deUint32 m_uid; 453 }; 454 } /* KHRDebug */ 455 456 /** Group class for khr debug conformance tests */ 457 class KHRDebugTests : public deqp::TestCaseGroup 458 { 459 public: 460 /* Public methods */ 461 KHRDebugTests(deqp::Context& context); 462 463 virtual ~KHRDebugTests(void) 464 { 465 } 466 467 virtual void init(void); 468 469 private: 470 /* Private methods */ 471 KHRDebugTests(const KHRDebugTests& other); 472 KHRDebugTests& operator=(const KHRDebugTests& other); 473 }; 474 475 } /* gl4cts */ 476 477 #endif // _GL4CKHRDEBUGTESTS_HPP 478
