1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program EGL Module 3 * --------------------------------------- 4 * 5 * Copyright 2017 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 Robustness tests for KHR_robustness. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "teglRobustnessTests.hpp" 25 26 #include "tcuTestLog.hpp" 27 #include "tcuStringTemplate.hpp" 28 29 #include "egluConfigFilter.hpp" 30 #include "egluStrUtil.hpp" 31 #include "egluUtil.hpp" 32 #include "eglwLibrary.hpp" 33 34 #include "gluStrUtil.hpp" 35 #include "gluShaderProgram.hpp" 36 #include "gluDrawUtil.hpp" 37 38 #include "glwFunctions.hpp" 39 #include "glwEnums.hpp" 40 41 #include "deSTLUtil.hpp" 42 #include "deStringUtil.hpp" 43 #include "deThread.hpp" 44 #include "deSharedPtr.hpp" 45 46 #include <set> 47 48 using std::string; 49 using std::vector; 50 using std::set; 51 using tcu::TestLog; 52 53 using namespace eglw; 54 55 DE_STATIC_ASSERT(GL_RESET_NOTIFICATION_STRATEGY == 0x8256); 56 DE_STATIC_ASSERT(GL_LOSE_CONTEXT_ON_RESET == 0x8252); 57 DE_STATIC_ASSERT(GL_NO_RESET_NOTIFICATION == 0x8261); 58 59 namespace deqp 60 { 61 namespace egl 62 { 63 namespace 64 { 65 66 enum ContextResetType 67 { 68 CONTEXTRESETTYPE_INFINITE_LOOP, 69 CONTEXTRESETTYPE_SHADER_OOB, 70 CONTEXTRESETTYPE_FIXED_FUNC_OOB, 71 }; 72 73 enum ShaderType 74 { 75 SHADERTYPE_VERT, 76 SHADERTYPE_FRAG, 77 SHADERTYPE_COMPUTE, 78 SHADERTYPE_VERT_AND_FRAG, 79 }; 80 81 enum ReadWriteType 82 { 83 READWRITETYPE_READ, 84 READWRITETYPE_WRITE, 85 }; 86 87 enum ResourceType 88 { 89 RESOURCETYPE_UBO, 90 RESOURCETYPE_SSBO, 91 RESOURCETYPE_LOCAL_ARRAY, 92 }; 93 94 enum FixedFunctionType 95 { 96 FIXEDFUNCTIONTYPE_INDICES, 97 FIXEDFUNCTIONTYPE_VERTICES, 98 }; 99 100 enum RobustAccessType 101 { 102 ROBUSTACCESS_TRUE, 103 ROBUSTACCESS_FALSE, 104 }; 105 106 void requireEGLExtension (const Library& egl, EGLDisplay eglDisplay, const char* requiredExtension) 107 { 108 if (!eglu::hasExtension(egl, eglDisplay, requiredExtension)) 109 TCU_THROW(NotSupportedError, (string(requiredExtension) + " not supported").c_str()); 110 } 111 112 bool isWindow (const eglu::CandidateConfig& c) 113 { 114 return (c.surfaceType() & EGL_WINDOW_BIT) == EGL_WINDOW_BIT; 115 } 116 117 template <deUint32 Type> 118 bool renderable (const eglu::CandidateConfig& c) 119 { 120 return (c.renderableType() & Type) == Type; 121 } 122 123 eglu::ConfigFilter getRenderableFilter (deUint32 bits) 124 { 125 switch (bits) 126 { 127 case EGL_OPENGL_ES2_BIT: return renderable<EGL_OPENGL_ES2_BIT>; 128 case EGL_OPENGL_ES3_BIT: return renderable<EGL_OPENGL_ES3_BIT>; 129 case EGL_OPENGL_BIT: return renderable<EGL_OPENGL_BIT>; 130 default: 131 DE_FATAL("Unknown EGL bitfied value"); 132 return renderable<0>; 133 } 134 } 135 136 const char* eglResetNotificationStrategyToString (EGLint strategy) 137 { 138 switch (strategy) 139 { 140 case EGL_NO_RESET_NOTIFICATION_KHR: return "EGL_NO_RESET_NOTIFICATION_KHR"; 141 case EGL_LOSE_CONTEXT_ON_RESET_KHR: return "EGL_LOSE_CONTEXT_ON_RESET_KHR"; 142 default: 143 return "<Unknown>"; 144 } 145 } 146 147 void logAttribList (const EglTestContext& eglTestCtx, const EGLint* attribList) 148 { 149 const EGLint* iter = &(attribList[0]); 150 std::ostringstream attribListString; 151 152 while ((*iter) != EGL_NONE) 153 { 154 switch (*iter) 155 { 156 // case EGL_CONTEXT_CLIENT_VERSION: 157 case EGL_CONTEXT_MAJOR_VERSION_KHR: 158 iter++; 159 attribListString << "EGL_CONTEXT_CLIENT_VERSION, " << (*iter) << ", "; 160 iter++; 161 break; 162 163 case EGL_CONTEXT_MINOR_VERSION_KHR: 164 iter++; 165 attribListString << "EGL_CONTEXT_MINOR_VERSION_KHR, " << (*iter) << ", "; 166 iter++; 167 break; 168 169 case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT: 170 iter++; 171 attribListString << "EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, " 172 << eglResetNotificationStrategyToString(*iter) << ", "; 173 iter++; 174 break; 175 176 case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR: 177 iter++; 178 attribListString << "EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR, " 179 << eglResetNotificationStrategyToString(*iter) << ", "; 180 iter++; 181 break; 182 183 case EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT: 184 iter++; 185 attribListString << "EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, "; 186 187 if (*iter == EGL_FALSE || *iter == EGL_TRUE) 188 attribListString << (*iter ? "EGL_TRUE" : "EGL_FALSE") << ", "; 189 else 190 attribListString << (*iter) << ", "; 191 iter++; 192 break; 193 194 default: 195 DE_FATAL("Unsupported attribute"); 196 } 197 } 198 199 attribListString << "EGL_NONE"; 200 eglTestCtx.getTestContext().getLog() << TestLog::Message 201 << "EGL attrib list: { " << attribListString.str() << " }\n\n" 202 << TestLog::EndMessage; 203 } 204 205 class RobustnessTestCase: public TestCase 206 { 207 public: 208 class Params 209 { 210 public: 211 Params (void) {}; 212 213 Params (const string& name, 214 const string& description, 215 const RobustAccessType& robustAccessType, 216 const ContextResetType& contextResetType, 217 const FixedFunctionType& fixedFunctionType); 218 219 Params (const string& name, 220 const string& description, 221 const ContextResetType& contextResetType, 222 const ShaderType& shaderType); 223 224 Params (const string& name, 225 const string& description, 226 const RobustAccessType& robustAccessType, 227 const ContextResetType& contextResetType, 228 const ShaderType& shaderType, 229 const ResourceType& resourceType, 230 const ReadWriteType& readWriteType); 231 232 const string& getName (void) const { return m_name; } 233 const string& getDescription (void) const { return m_description; } 234 const ContextResetType& getContextResetType (void) const { return m_contextResetType; } 235 const ShaderType& getShaderType (void) const { return m_shaderType; } 236 const ResourceType& getResourceType (void) const { return m_resourceType; } 237 const ReadWriteType& getReadWriteType (void) const { return m_readWriteType; } 238 const FixedFunctionType& getFixedFunctionType (void) const { return m_fixedFunctionType; } 239 const RobustAccessType& getRobustAccessType (void) const { return m_robustAccessType; } 240 241 private: 242 string m_name; 243 string m_description; 244 RobustAccessType m_robustAccessType; 245 ContextResetType m_contextResetType; 246 ShaderType m_shaderType; 247 ResourceType m_resourceType; 248 ReadWriteType m_readWriteType; 249 FixedFunctionType m_fixedFunctionType; 250 }; 251 252 RobustnessTestCase (EglTestContext& eglTestCtx, const char* name, const char* description); 253 RobustnessTestCase (EglTestContext& eglTestCtx, const char* name, const char* description, Params params); 254 ~RobustnessTestCase (void); 255 256 void checkRequiredEGLExtensions (const EGLint* attribList); 257 258 protected: 259 Params m_params; 260 EGLDisplay m_eglDisplay; 261 EGLConfig m_eglConfig; 262 EGLSurface m_eglSurface; 263 264 private: 265 void init (void); 266 void deinit (void); 267 void initEGLSurface (void); 268 EGLConfig getEGLConfig (void); 269 270 eglu::NativeWindow* m_window; 271 }; 272 273 RobustnessTestCase::Params::Params (const string& name, 274 const string& description, 275 const RobustAccessType& robustAccessType, 276 const ContextResetType& contextResetType, 277 const FixedFunctionType& fixedFunctionType) 278 : m_name (name) 279 , m_description (description) 280 , m_robustAccessType (robustAccessType) 281 , m_contextResetType (contextResetType) 282 , m_fixedFunctionType (fixedFunctionType) 283 { 284 } 285 286 RobustnessTestCase::Params::Params (const string& name, 287 const string& description, 288 const ContextResetType& contextResetType, 289 const ShaderType& shaderType) 290 : m_name (name) 291 , m_description (description) 292 , m_contextResetType (contextResetType) 293 , m_shaderType (shaderType) 294 { 295 } 296 297 RobustnessTestCase::Params::Params (const string& name, 298 const string& description, 299 const RobustAccessType& robustAccessType, 300 const ContextResetType& contextResetType, 301 const ShaderType& shaderType, 302 const ResourceType& resourceType, 303 const ReadWriteType& readWriteType) 304 : m_name (name) 305 , m_description (description) 306 , m_robustAccessType (robustAccessType) 307 , m_contextResetType (contextResetType) 308 , m_shaderType (shaderType) 309 , m_resourceType (resourceType) 310 , m_readWriteType (readWriteType) 311 { 312 } 313 314 RobustnessTestCase::RobustnessTestCase (EglTestContext& eglTestCtx, const char* name, const char* description) 315 : TestCase (eglTestCtx, name, description) 316 , m_eglDisplay (EGL_NO_DISPLAY) 317 , m_eglConfig (0) 318 , m_eglSurface (EGL_NO_SURFACE) 319 , m_window (DE_NULL) 320 { 321 } 322 323 RobustnessTestCase::RobustnessTestCase (EglTestContext& eglTestCtx, const char* name, const char* description, Params params) 324 : TestCase (eglTestCtx, name, description) 325 , m_params (params) 326 , m_eglDisplay (EGL_NO_DISPLAY) 327 , m_eglConfig (0) 328 , m_eglSurface (EGL_NO_SURFACE) 329 , m_window (DE_NULL) 330 { 331 } 332 333 RobustnessTestCase::~RobustnessTestCase (void) 334 { 335 deinit(); 336 } 337 338 void RobustnessTestCase::init (void) 339 { 340 m_eglDisplay = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay()); 341 m_eglConfig = getEGLConfig(); 342 343 initEGLSurface(); 344 } 345 346 void RobustnessTestCase::deinit (void) 347 { 348 const Library& egl = m_eglTestCtx.getLibrary(); 349 350 if (m_eglSurface != EGL_NO_SURFACE) 351 { 352 egl.destroySurface(m_eglDisplay, m_eglSurface); 353 m_eglSurface = EGL_NO_SURFACE; 354 } 355 if (m_eglDisplay != EGL_NO_DISPLAY) 356 { 357 egl.terminate(m_eglDisplay); 358 m_eglDisplay = EGL_NO_DISPLAY; 359 } 360 361 delete m_window; 362 m_window = DE_NULL; 363 } 364 365 EGLConfig RobustnessTestCase::getEGLConfig (void) 366 { 367 eglu::FilterList filters; 368 filters << isWindow << getRenderableFilter(EGL_OPENGL_ES3_BIT); 369 return eglu::chooseSingleConfig(m_eglTestCtx.getLibrary(), m_eglDisplay, filters); 370 } 371 372 void RobustnessTestCase::initEGLSurface (void) 373 { 374 EGLU_CHECK_CALL(m_eglTestCtx.getLibrary(), bindAPI(EGL_OPENGL_ES_API)); 375 376 const eglu::NativeWindowFactory& factory = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine()); 377 378 const eglu::WindowParams windowParams = eglu::WindowParams(256, 256, eglu::parseWindowVisibility(m_testCtx.getCommandLine())); 379 m_window = factory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_eglDisplay, m_eglConfig, DE_NULL, windowParams); 380 m_eglSurface = eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *m_window, m_eglDisplay, m_eglConfig, DE_NULL); 381 } 382 383 glu::ApiType paramsToApiType (const RobustnessTestCase::Params& params) 384 { 385 EGLint minorVersion = 0; 386 if (params.getShaderType() == SHADERTYPE_COMPUTE || 387 params.getResourceType() == RESOURCETYPE_SSBO || 388 params.getContextResetType() == CONTEXTRESETTYPE_SHADER_OOB) 389 { 390 minorVersion = 1; 391 } 392 393 return glu::ApiType::es(3, minorVersion); 394 } 395 396 void RobustnessTestCase::checkRequiredEGLExtensions (const EGLint* attribList) 397 { 398 set<string> requiredExtensions; 399 vector<string> extensions = eglu::getDisplayExtensions(m_eglTestCtx.getLibrary(), m_eglDisplay); 400 401 { 402 const EGLint* iter = attribList; 403 404 while ((*iter) != EGL_NONE) 405 { 406 switch (*iter) 407 { 408 case EGL_CONTEXT_MAJOR_VERSION_KHR: iter++; 409 iter++; 410 break; 411 412 case EGL_CONTEXT_MINOR_VERSION_KHR: 413 iter++; 414 requiredExtensions.insert("EGL_KHR_create_context"); 415 iter++; 416 break; 417 418 case EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT: 419 case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT: 420 iter++; 421 requiredExtensions.insert("EGL_EXT_create_context_robustness"); 422 iter++; 423 break; 424 425 default: 426 DE_ASSERT(DE_FALSE); 427 } 428 } 429 } 430 431 for (std::set<string>::const_iterator reqExt = requiredExtensions.begin(); reqExt != requiredExtensions.end(); ++reqExt) 432 { 433 if (!de::contains(extensions.begin(), extensions.end(), *reqExt)) 434 { 435 const char* const extension = reqExt->c_str(); 436 requireEGLExtension(m_eglTestCtx.getLibrary(), m_eglDisplay, extension); 437 } 438 } 439 } 440 441 void checkRequiredGLSupport (const glw::Functions& gl, glu::ApiType requiredApi) 442 { 443 if (!glu::hasExtension(gl, requiredApi, "GL_KHR_robustness") && !glu::hasExtension(gl, requiredApi, "GL_EXT_robustness")) 444 { 445 TCU_THROW(NotSupportedError, (string("GL_KHR_robustness and GL_EXT_robustness") + " not supported").c_str()); 446 } 447 else 448 { 449 int realMinorVersion = 0; 450 gl.getIntegerv(GL_MINOR_VERSION, &realMinorVersion); 451 GLU_EXPECT_NO_ERROR(gl.getError(), "Get minor version failed"); 452 453 if (realMinorVersion < requiredApi.getMinorVersion()) 454 TCU_THROW(NotSupportedError, "Test case requires GLES 3.1"); 455 } 456 } 457 458 void checkGLSupportForParams (const glw::Functions& gl, const RobustnessTestCase::Params& params) 459 { 460 int minorVersion = 0; 461 if (params.getShaderType() == SHADERTYPE_COMPUTE || 462 params.getResourceType() == RESOURCETYPE_SSBO || 463 params.getContextResetType() == CONTEXTRESETTYPE_SHADER_OOB) 464 { 465 minorVersion = 1; 466 } 467 checkRequiredGLSupport(gl, glu::ApiType::es(3, minorVersion)); 468 } 469 470 class RenderingContext 471 { 472 public: 473 RenderingContext (const EglTestContext& eglTestCtx, 474 const EGLint* attribList, 475 const EGLConfig& config, 476 const EGLDisplay& display, 477 const EGLContext& sharedContext); 478 ~RenderingContext (void); 479 480 void initGLFunctions (glw::Functions* gl, const glu::ApiType apiType); 481 void makeCurrent (const EGLSurface& surface); 482 EGLContext getContext (void); 483 484 private: 485 const EglTestContext& m_eglTestCtx; 486 const EGLint* m_attribList; 487 const EGLConfig& m_config; 488 const EGLDisplay& m_display; 489 const Library& m_egl; 490 491 EGLContext m_context; 492 493 void createContext (const EGLConfig& sharedConfig); 494 void destroyContext (void); 495 496 RenderingContext (const RenderingContext&); 497 RenderingContext& operator= (const RenderingContext&); 498 }; 499 500 RenderingContext::RenderingContext (const EglTestContext& eglTestCtx, 501 const EGLint* attribList, 502 const EGLConfig& config, 503 const EGLDisplay& display, 504 const EGLContext& sharedContext) 505 : m_eglTestCtx (eglTestCtx) 506 , m_attribList (attribList) 507 , m_config (config) 508 , m_display (display) 509 , m_egl (eglTestCtx.getLibrary()) 510 , m_context (EGL_NO_CONTEXT) 511 { 512 logAttribList(eglTestCtx, m_attribList); 513 createContext(sharedContext); 514 } 515 516 RenderingContext::~RenderingContext (void) 517 { 518 destroyContext(); 519 } 520 521 void RenderingContext::createContext (const EGLConfig& sharedContext) 522 { 523 m_context = m_egl.createContext(m_display, m_config, sharedContext, m_attribList); 524 EGLU_CHECK_MSG(m_egl, "eglCreateContext()"); 525 } 526 527 void RenderingContext::destroyContext (void) 528 { 529 EGLU_CHECK_CALL(m_eglTestCtx.getLibrary(), makeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); 530 531 if (m_context != EGL_NO_CONTEXT) 532 m_egl.destroyContext(m_display, m_context); 533 } 534 535 void RenderingContext::makeCurrent (const EGLSurface& surface) 536 { 537 EGLU_CHECK_CALL(m_egl, makeCurrent(m_display, surface, surface, m_context)); 538 } 539 540 void RenderingContext::initGLFunctions (glw::Functions *gl, const glu::ApiType apiType) 541 { 542 // \todo [2017-03-23 pyry] Current version has 2 somewhat ugly hacks: 543 // 544 // 1) Core functions are loaded twice. We need glGetString(i) to query supported 545 // extensions to determine if we need to load EXT or KHR-suffixed robustness 546 // functions. This could be fixed by exposing glw::FunctionLoader in EglTestContext 547 // for example. 548 // 549 // 2) We assume that calling code will check for KHR_robustness or EXT_robustness 550 // support after calling initGLFunctions(). We could move the check here. 551 552 m_eglTestCtx.initGLFunctions(gl, apiType); 553 554 { 555 const char* const robustnessExt = glu::hasExtension(*gl, apiType, "GL_KHR_robustness") ? "GL_KHR_robustness" : "GL_EXT_robustness"; 556 const char* const extensions[] = { robustnessExt }; 557 558 m_eglTestCtx.initGLFunctions(gl, apiType, DE_LENGTH_OF_ARRAY(extensions), &extensions[0]); 559 } 560 } 561 562 EGLContext RenderingContext::getContext (void) 563 { 564 return m_context; 565 } 566 567 class ContextReset 568 { 569 public: 570 ContextReset (glw::Functions& gl, tcu::TestLog& log, FixedFunctionType fixedFunctionType); 571 ContextReset (glw::Functions& gl, tcu::TestLog& log, ShaderType shaderType); 572 ContextReset (glw::Functions& gl, tcu::TestLog& log, ShaderType shaderType, ResourceType resourceType, ReadWriteType readWriteType); 573 574 virtual ~ContextReset (void) {}; 575 576 virtual void setup (void) = 0; 577 virtual void draw (void) = 0; 578 virtual void teardown (void) = 0; 579 580 void finish (void); 581 void createSyncObject (void); 582 glw::GLint getSyncStatus (void); 583 584 void beginQuery (void); 585 void endQuery (void); 586 glw::GLint getError (void); 587 glw::GLint getGraphicsResetStatus (void); 588 glw::GLuint getQueryAvailability (void); 589 590 glw::GLsync getSyncObject (void) const { return m_sync; } 591 glw::GLuint getQueryID (void) const { return m_queryID; } 592 593 glw::Functions& m_gl; 594 tcu::TestLog& m_log; 595 ShaderType m_shaderType; 596 ResourceType m_resourceType; 597 ReadWriteType m_readWriteType; 598 FixedFunctionType m_fixedFunctionType; 599 600 private: 601 ContextReset (const ContextReset&); 602 ContextReset& operator= (const ContextReset&); 603 604 glw::GLuint m_queryID; 605 glw::GLsync m_sync; 606 }; 607 608 ContextReset::ContextReset (glw::Functions& gl, tcu::TestLog& log, FixedFunctionType fixedFunctionType) 609 : m_gl (gl) 610 , m_log (log) 611 , m_fixedFunctionType (fixedFunctionType) 612 { 613 } 614 615 ContextReset::ContextReset (glw::Functions& gl, tcu::TestLog& log, ShaderType shaderType, ResourceType resourceType, ReadWriteType readWriteType) 616 : m_gl (gl) 617 , m_log (log) 618 , m_shaderType (shaderType) 619 , m_resourceType (resourceType) 620 , m_readWriteType (readWriteType) 621 { 622 } 623 624 ContextReset::ContextReset (glw::Functions& gl, tcu::TestLog& log, ShaderType shaderType) 625 : m_gl (gl) 626 , m_log (log) 627 , m_shaderType (shaderType) 628 { 629 } 630 631 void ContextReset::finish (void) 632 { 633 GLU_CHECK_GLW_CALL(m_gl, finish()); 634 } 635 636 void ContextReset::createSyncObject (void) 637 { 638 m_sync = m_gl.fenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0); 639 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glFenceSync()"); 640 } 641 642 glw::GLint ContextReset::getError (void) 643 { 644 glw::GLint error; 645 error = m_gl.getError(); 646 647 return error; 648 } 649 650 glw::GLint ContextReset::getGraphicsResetStatus (void) 651 { 652 glw::GLint resetStatus; 653 resetStatus = m_gl.getGraphicsResetStatus(); 654 655 return resetStatus; 656 } 657 658 glw::GLint ContextReset::getSyncStatus (void) 659 { 660 glw::GLint syncStatus; 661 m_gl.getSynciv(m_sync, GL_SYNC_STATUS, sizeof(glw::GLint), NULL, &syncStatus); 662 663 return syncStatus; 664 } 665 666 void ContextReset::beginQuery (void) 667 { 668 GLU_CHECK_GLW_CALL(m_gl, genQueries(1, &m_queryID)); 669 GLU_CHECK_GLW_CALL(m_gl, beginQuery(GL_ANY_SAMPLES_PASSED, m_queryID)); 670 } 671 672 void ContextReset::endQuery (void) 673 { 674 GLU_CHECK_GLW_CALL(m_gl, endQuery(GL_ANY_SAMPLES_PASSED)); 675 } 676 677 glw::GLuint ContextReset::getQueryAvailability (void) 678 { 679 glw::GLuint queryReady = GL_FALSE; 680 m_gl.getQueryObjectuiv(m_queryID, GL_QUERY_RESULT_AVAILABLE, &queryReady); 681 682 return queryReady; 683 } 684 685 class InfiniteLoop : public ContextReset 686 { 687 public: 688 InfiniteLoop (glw::Functions& gl, tcu::TestLog& log, ShaderType shaderType); 689 ~InfiniteLoop (void); 690 691 virtual void setup (void); 692 virtual void draw (void); 693 virtual void teardown (void); 694 695 private: 696 glu::ProgramSources genComputeSource (void); 697 glu::ProgramSources genNonComputeSource (void); 698 glu::ProgramSources genSources (void); 699 700 glw::GLuint m_outputBuffer; 701 glw::GLuint m_coordinatesBuffer; 702 glw::GLint m_coordLocation; 703 }; 704 705 InfiniteLoop::InfiniteLoop (glw::Functions& gl, tcu::TestLog& log, ShaderType shaderType) 706 : ContextReset(gl, log, shaderType) 707 , m_outputBuffer (0) 708 , m_coordinatesBuffer (0) 709 , m_coordLocation (0) 710 { 711 } 712 713 InfiniteLoop::~InfiniteLoop (void) 714 { 715 try 716 { 717 // Reset GL_CONTEXT_LOST error before destroying resources 718 m_gl.getGraphicsResetStatus(); 719 teardown(); 720 } 721 catch (...) 722 { 723 // Ignore GL errors from teardown() 724 } 725 } 726 727 glu::ProgramSources InfiniteLoop::genSources(void) 728 { 729 if (m_shaderType == SHADERTYPE_COMPUTE) 730 return genComputeSource(); 731 else 732 return genNonComputeSource(); 733 } 734 735 glu::ProgramSources InfiniteLoop::genComputeSource(void) 736 { 737 const char* const computeSource = 738 "#version 310 es\n" 739 "layout(local_size_x = 1, local_size_y = 1) in;\n" 740 "uniform highp int u_iterCount;\n" 741 "writeonly buffer Output { highp int b_output_int; };\n" 742 "void main ()\n" 743 "{\n" 744 " for (highp int i = 0; i < u_iterCount || u_iterCount < 0; ++i)\n" 745 " b_output_int = u_iterCount;\n" 746 "}\n"; 747 748 return glu::ProgramSources() << glu::ComputeSource(computeSource); 749 } 750 751 glu::ProgramSources InfiniteLoop::genNonComputeSource (void) 752 { 753 const bool isVertCase = m_shaderType == SHADERTYPE_VERT; 754 const bool isFragCase = m_shaderType == SHADERTYPE_FRAG; 755 const bool isVertAndFragment = m_shaderType == SHADERTYPE_VERT_AND_FRAG; 756 757 std::ostringstream vert, frag; 758 759 vert << "#version 300 es\n" 760 << "in highp vec2 a_position;\n"; 761 762 frag << "#version 300 es\n"; 763 764 vert << "uniform highp int u_iterCount;\n"; 765 if (isFragCase || isVertAndFragment) 766 { 767 vert << "flat out highp int v_iterCount;\n"; 768 frag << "flat in highp int v_iterCount;\n"; 769 } 770 771 if (isVertCase || isVertAndFragment) 772 { 773 vert << "out mediump vec4 v_color;\n"; 774 frag << "in mediump vec4 v_color;\n"; 775 } 776 777 frag << "out mediump vec4 o_color;\n"; 778 779 vert << "\nvoid main (void)\n{\n" 780 << " gl_Position = vec4(a_position, 0.0, 1.0);\n" 781 << " gl_PointSize = 1.0;\n"; 782 783 if (isFragCase || isVertAndFragment) 784 vert << " v_iterCount = u_iterCount;\n"; 785 786 frag << "\nvoid main (void)\n{\n"; 787 788 const std::string iterCount = (isVertCase ? "u_iterCount" : "v_iterCount"); 789 const std::string loopHeader = " for (highp int i = 0; i < " + iterCount + " || " + iterCount + " < 0; ++i)\n"; 790 const char* const body = "color = cos(sin(color*1.25)*0.8);"; 791 792 if (isVertAndFragment) 793 { 794 vert << " mediump vec4 color = " << "a_position.xyxy" << ";\n"; 795 vert << loopHeader << " " << body << "\n"; 796 797 frag << " mediump vec4 color = " << "gl_FragCoord" << ";\n"; 798 frag << loopHeader << " " << body << "\n"; 799 } 800 else 801 { 802 std::ostringstream& op = isVertCase ? vert : frag; 803 op << " mediump vec4 color = " << (isVertCase ? "a_position.xyxy" : "gl_FragCoord") << ";\n"; 804 op << loopHeader << " " << body << "\n"; 805 } 806 807 if (isVertCase || isVertAndFragment) 808 { 809 vert << " v_color = color;\n"; 810 frag << " o_color = v_color;\n"; 811 } 812 else 813 frag << " o_color = color;\n"; 814 815 vert << "}\n"; 816 frag << "}\n"; 817 818 return glu::ProgramSources() << glu::VertexSource(vert.str()) << glu::FragmentSource(frag.str()); 819 } 820 821 void InfiniteLoop::setup (void) 822 { 823 glu::ShaderProgram program (m_gl, genSources()); 824 m_log << program; 825 826 if (!program.isOk()) 827 TCU_FAIL("Failed to compile shader program"); 828 829 GLU_CHECK_GLW_CALL(m_gl, useProgram(program.getProgram())); 830 831 if (m_shaderType == SHADERTYPE_COMPUTE) 832 { 833 // Output buffer setup 834 m_outputBuffer = 0; 835 GLU_CHECK_GLW_CALL(m_gl, genBuffers(1, &m_outputBuffer)); 836 GLU_CHECK_GLW_CALL(m_gl, bindBuffer(GL_SHADER_STORAGE_BUFFER, m_outputBuffer)); 837 GLU_CHECK_GLW_CALL(m_gl, bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(int), DE_NULL, GL_DYNAMIC_DRAW)); 838 GLU_CHECK_GLW_CALL(m_gl, bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_outputBuffer)); 839 } 840 else 841 { 842 const glw::GLfloat coords[] = 843 { 844 -1.0f, -1.0f, 845 +1.0f, -1.0f, 846 +1.0f, +1.0f, 847 -1.0f, +1.0f 848 }; 849 850 m_coordLocation = m_gl.getAttribLocation(program.getProgram(), "a_position"); 851 GLU_CHECK_GLW_MSG(m_gl, "glGetAttribLocation()"); 852 TCU_CHECK(m_coordLocation != (glw::GLint)-1); 853 854 // Load the vertex data 855 m_coordinatesBuffer = 0; 856 GLU_CHECK_GLW_CALL(m_gl, genBuffers(1, &m_coordinatesBuffer)); 857 GLU_CHECK_GLW_CALL(m_gl, bindBuffer(GL_ARRAY_BUFFER, m_coordinatesBuffer)); 858 GLU_CHECK_GLW_CALL(m_gl, bufferData(GL_ARRAY_BUFFER, (glw::GLsizeiptr)sizeof(coords), coords, GL_STATIC_DRAW)); 859 GLU_CHECK_GLW_CALL(m_gl, enableVertexAttribArray(m_coordLocation)); 860 GLU_CHECK_GLW_CALL(m_gl, vertexAttribPointer(m_coordLocation, 2, GL_FLOAT, GL_FALSE, 0, DE_NULL)); 861 } 862 863 glw::GLint iterCountLocation = m_gl.getUniformLocation(program.getProgram(), "u_iterCount"); 864 GLU_CHECK_GLW_MSG(m_gl, "glGetUniformLocation()"); 865 TCU_CHECK(iterCountLocation != (glw::GLint)-1); 866 867 // Set the iteration count (infinite) 868 glw::GLint iterCount = -1; 869 GLU_CHECK_GLW_CALL(m_gl, uniform1i(iterCountLocation, iterCount)); 870 } 871 872 void InfiniteLoop::draw (void) 873 { 874 if (m_shaderType == SHADERTYPE_COMPUTE) 875 m_gl.dispatchCompute(1, 1, 1); 876 else 877 { 878 const glw::GLushort indices[] = { 0, 1, 2, 2, 3, 0 }; 879 m_gl.drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices); 880 } 881 } 882 883 void InfiniteLoop::teardown (void) 884 { 885 if (m_shaderType != SHADERTYPE_COMPUTE) 886 { 887 if (m_coordLocation) 888 { 889 GLU_CHECK_GLW_CALL(m_gl, disableVertexAttribArray(m_coordLocation)); 890 m_coordLocation = 0; 891 } 892 } 893 894 if (m_outputBuffer) 895 { 896 GLU_CHECK_GLW_CALL(m_gl, deleteBuffers(1, &m_outputBuffer)); 897 m_outputBuffer = 0; 898 } 899 900 if (m_coordinatesBuffer) 901 { 902 GLU_CHECK_GLW_CALL(m_gl, deleteBuffers(1, &m_coordinatesBuffer)); 903 m_coordinatesBuffer = 0; 904 } 905 906 GLU_CHECK_GLW_CALL(m_gl, useProgram(0)); 907 } 908 909 class FixedFunctionOOB : public ContextReset 910 { 911 public: 912 FixedFunctionOOB (glw::Functions& gl, tcu::TestLog& log, FixedFunctionType fixedFunctionType); 913 ~FixedFunctionOOB (void); 914 915 struct TestConfig 916 { 917 int textureWidth; 918 int textureHeight; 919 }; 920 921 virtual void setup (void); 922 virtual void draw (void); 923 virtual void teardown (void); 924 925 private: 926 glu::ProgramSources genSources (void); 927 glw::GLuint m_coordinatesBuffer; 928 glw::GLint m_coordLocation; 929 }; 930 931 FixedFunctionOOB::FixedFunctionOOB (glw::Functions& gl, tcu::TestLog& log, FixedFunctionType fixedFunctionType) 932 : ContextReset(gl, log, fixedFunctionType) 933 , m_coordinatesBuffer (0) 934 , m_coordLocation (0) 935 { 936 } 937 938 FixedFunctionOOB::~FixedFunctionOOB (void) 939 { 940 try 941 { 942 // Reset GL_CONTEXT_LOST error before destroying resources 943 m_gl.getGraphicsResetStatus(); 944 teardown(); 945 } 946 catch (...) 947 { 948 // Ignore GL errors from teardown() 949 } 950 } 951 952 glu::ProgramSources FixedFunctionOOB::genSources (void) 953 { 954 const char* const vert = 955 "#version 300 es\n" 956 "in highp vec4 a_position;\n" 957 "void main (void)\n" 958 "{\n" 959 " gl_Position = a_position;\n" 960 "}\n"; 961 962 const char* const frag = 963 "#version 300 es\n" 964 "layout(location = 0) out highp vec4 fragColor;\n" 965 "void main (void)\n" 966 "{\n" 967 " fragColor = vec4(1.0f);\n" 968 "}\n"; 969 970 return glu::ProgramSources() << glu::VertexSource(vert) << glu::FragmentSource(frag); 971 } 972 973 void FixedFunctionOOB::setup (void) 974 { 975 glu::ShaderProgram program(m_gl, genSources()); 976 977 m_log << program; 978 979 if (!program.isOk()) 980 TCU_FAIL("Failed to compile shader program"); 981 982 GLU_CHECK_GLW_CALL(m_gl, useProgram(program.getProgram())); 983 984 const glw::GLfloat coords[] = 985 { 986 -1.0f, -1.0f, 987 1.0f, -1.0f, 988 1.0f, 1.0f, 989 -1.0f, 1.0f 990 }; 991 992 m_coordLocation = m_gl.getAttribLocation(program.getProgram(), "a_position"); 993 GLU_CHECK_GLW_MSG(m_gl, "glGetAttribLocation()"); 994 TCU_CHECK(m_coordLocation != (glw::GLint)-1); 995 996 // Load the vertex data 997 m_coordinatesBuffer = 0; 998 GLU_CHECK_GLW_CALL(m_gl, genBuffers(1, &m_coordinatesBuffer)); 999 GLU_CHECK_GLW_CALL(m_gl, bindBuffer(GL_ARRAY_BUFFER, m_coordinatesBuffer)); 1000 GLU_CHECK_GLW_CALL(m_gl, bufferData(GL_ARRAY_BUFFER, (glw::GLsizeiptr)sizeof(coords), coords, GL_STATIC_DRAW)); 1001 GLU_CHECK_GLW_CALL(m_gl, enableVertexAttribArray(m_coordLocation)); 1002 GLU_CHECK_GLW_CALL(m_gl, vertexAttribPointer(m_coordLocation, 2, GL_FLOAT, GL_FALSE, 0, DE_NULL)); 1003 } 1004 1005 void FixedFunctionOOB::draw (void) 1006 { 1007 const glw::GLint bad_indices[] = {0, 10, 100, 1000, 10000, 100000}; 1008 1009 if (m_fixedFunctionType == FIXEDFUNCTIONTYPE_INDICES) 1010 m_gl.drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, bad_indices); 1011 else if (m_fixedFunctionType == FIXEDFUNCTIONTYPE_VERTICES) 1012 m_gl.drawArrays(GL_TRIANGLES, 0, 1000); 1013 else 1014 DE_FATAL("Unknown fixed function type"); 1015 } 1016 1017 void FixedFunctionOOB::teardown (void) 1018 { 1019 if (m_coordLocation) 1020 { 1021 GLU_CHECK_GLW_CALL(m_gl, disableVertexAttribArray(m_coordLocation)); 1022 m_coordLocation = 0; 1023 } 1024 1025 if (m_coordinatesBuffer) 1026 { 1027 GLU_CHECK_GLW_CALL(m_gl, deleteBuffers(1, &m_coordinatesBuffer)); 1028 m_coordinatesBuffer = 0; 1029 } 1030 1031 GLU_CHECK_GLW_CALL(m_gl, useProgram(0)); 1032 } 1033 1034 class ShadersOOB : public ContextReset 1035 { 1036 public: 1037 ShadersOOB (glw::Functions& gl, tcu::TestLog& log, ShaderType shaderType, ResourceType resourceType, ReadWriteType readWriteType); 1038 ~ShadersOOB (void); 1039 1040 virtual void setup (void); 1041 virtual void draw (void); 1042 virtual void teardown (void); 1043 1044 private: 1045 static const int s_numBindings = 3; 1046 1047 glw::GLuint m_coordinatesBuffer; 1048 glw::GLint m_coordLocation; 1049 1050 bool m_isUBO; 1051 bool m_isRead; 1052 bool m_isLocalArray; 1053 std::vector<glw::GLuint> m_buffers; 1054 1055 std::string genVertexShader (const std::string& shaderDecl, const std::string& shaderBody); 1056 std::string genFragmentShader (const std::string& shaderDecl, const std::string& shaderBody); 1057 std::string genComputeShader (const std::string& shaderDecl, const std::string& shaderBody); 1058 1059 glu::ProgramSources genNonComputeSource (void); 1060 glu::ProgramSources genComputeSource (void); 1061 glu::ProgramSources genSources (void); 1062 }; 1063 1064 ShadersOOB::ShadersOOB (glw::Functions& gl, tcu::TestLog& log, ShaderType shaderType, ResourceType resourceType, ReadWriteType readWriteType) 1065 : ContextReset(gl, log, shaderType, resourceType, readWriteType) 1066 , m_coordinatesBuffer (0) 1067 , m_coordLocation (0) 1068 , m_buffers (s_numBindings, 0) 1069 { 1070 m_isUBO = (m_resourceType == RESOURCETYPE_UBO); 1071 m_isLocalArray = (m_resourceType == RESOURCETYPE_LOCAL_ARRAY); 1072 m_isRead = (m_readWriteType == READWRITETYPE_READ); 1073 } 1074 1075 ShadersOOB::~ShadersOOB (void) 1076 { 1077 try 1078 { 1079 // Reset GL_CONTEXT_LOST error before destroying resources 1080 m_gl.getGraphicsResetStatus(); 1081 teardown(); 1082 } 1083 catch (...) 1084 { 1085 // Ignore GL errors from teardown() 1086 } 1087 } 1088 1089 std::string ShadersOOB::genVertexShader (const std::string& shaderDecl, const std::string& shaderBody) 1090 { 1091 static const char* const s_simpleVertexShaderSource = 1092 "#version 310 es\n" 1093 "in highp vec4 a_position;\n" 1094 "void main (void)\n" 1095 "{\n" 1096 " gl_Position = a_position;\n" 1097 "}\n"; 1098 1099 switch (m_shaderType) 1100 { 1101 case SHADERTYPE_VERT: 1102 case SHADERTYPE_VERT_AND_FRAG: 1103 { 1104 std::ostringstream vertexShaderSource; 1105 vertexShaderSource << "#version 310 es\n" 1106 << "in highp vec4 a_position;\n" 1107 << "out highp vec4 v_color;\n" 1108 << shaderDecl << "\n" 1109 << "void main (void)\n" 1110 << "{\n" 1111 << " highp vec4 color;\n" 1112 << shaderBody << "\n" 1113 << " v_color = color;\n" 1114 << " gl_Position = a_position;\n" 1115 << "}\n"; 1116 1117 return vertexShaderSource.str(); 1118 } 1119 1120 case SHADERTYPE_FRAG: 1121 return s_simpleVertexShaderSource; 1122 1123 default: 1124 DE_FATAL("Unknown shader type"); 1125 return ""; 1126 } 1127 } 1128 1129 std::string ShadersOOB::genFragmentShader (const std::string& shaderDecl, const std::string& shaderBody) 1130 { 1131 static const char* const s_simpleFragmentShaderSource = 1132 "#version 310 es\n" 1133 "in highp vec4 v_color;\n" 1134 "layout(location = 0) out highp vec4 fragColor;\n" 1135 "void main (void)\n" 1136 "{\n" 1137 " fragColor = v_color;\n" 1138 "}\n"; 1139 1140 switch (m_shaderType) 1141 { 1142 case SHADERTYPE_VERT: 1143 return s_simpleFragmentShaderSource; 1144 1145 case SHADERTYPE_FRAG: 1146 { 1147 std::ostringstream fragmentShaderSource; 1148 fragmentShaderSource << "#version 310 es\n" 1149 << "layout(location = 0) out highp vec4 fragColor;\n" 1150 << shaderDecl << "\n" 1151 << "void main (void)\n" 1152 << "{\n" 1153 << " highp vec4 color = vec4(0.0f);\n" 1154 << shaderBody << "\n" 1155 << " fragColor = color;\n" 1156 << "}\n"; 1157 1158 return fragmentShaderSource.str(); 1159 } 1160 case SHADERTYPE_VERT_AND_FRAG: 1161 { 1162 std::ostringstream fragmentShaderSource; 1163 fragmentShaderSource << "#version 310 es\n" 1164 << "in highp vec4 v_color;\n" 1165 << "layout(location = 0) out highp vec4 fragColor;\n" 1166 << shaderDecl << "\n" 1167 << "void main (void)\n" 1168 << "{\n" 1169 << " highp vec4 color = vec4(0.0f);\n" 1170 << shaderBody << "\n" 1171 << " fragColor = color;\n" 1172 << "}\n"; 1173 1174 return fragmentShaderSource.str(); 1175 } 1176 1177 default: 1178 DE_FATAL("Unknown shader type"); 1179 return ""; 1180 } 1181 } 1182 1183 std::string ShadersOOB::genComputeShader (const std::string& shaderDecl, const std::string& shaderBody) 1184 { 1185 std::ostringstream computeShaderSource; 1186 1187 computeShaderSource << "#version 310 es\n" 1188 << "layout(local_size_x = 1, local_size_y = 1) in;\n" 1189 << "\n" 1190 << "layout(binding = 0) buffer Output {\n" 1191 << " highp vec4 values;\n" 1192 << "} sb_out;\n" 1193 << "\n" 1194 << shaderDecl 1195 << "void main ()\n" 1196 << "{\n" 1197 << shaderBody 1198 << "}\n"; 1199 1200 return computeShaderSource.str(); 1201 } 1202 1203 glu::ProgramSources ShadersOOB::genNonComputeSource (void) 1204 { 1205 std::ostringstream shaderDecl; 1206 std::ostringstream shaderBody; 1207 1208 shaderDecl << "uniform highp int u_index;\n"; 1209 1210 if (m_isLocalArray) 1211 { 1212 const char* const readWriteStatement = (m_isRead) 1213 ? " color.x = color_out[u_index];\n" 1214 : " color[u_index] = color_out[0];\n"; 1215 1216 shaderBody << " highp float color_out[4] = float[4](0.25f, 0.5f, 0.75f, 1.0f);\n" 1217 << readWriteStatement; 1218 } 1219 else 1220 { 1221 const std::string resName = (m_isUBO) ? "ub_in" : "sb_in"; 1222 1223 shaderDecl << "layout(std140, binding = 0) " << ((m_isUBO) ? "uniform" : "buffer") << " Block\n" 1224 << "{\n" 1225 << " highp float color_out[4];\n" 1226 << "} " << resName << "[" << s_numBindings << "];\n"; 1227 1228 const std::string readWriteStatement = (m_isRead) 1229 ? " color.x = " + resName + "[0].color_out[u_index];\n" 1230 : " color[u_index] = " + resName + "[0].color_out[0];\n"; 1231 1232 shaderBody << readWriteStatement; 1233 } 1234 1235 return glu::ProgramSources() << glu::VertexSource(genVertexShader(shaderDecl.str(), shaderBody.str())) 1236 << glu::FragmentSource(genFragmentShader(shaderDecl.str(), shaderBody.str())); 1237 } 1238 1239 glu::ProgramSources ShadersOOB::genComputeSource (void) 1240 { 1241 std::ostringstream shaderDecl; 1242 std::ostringstream shaderBody; 1243 1244 shaderDecl << "uniform highp int u_index;\n"; 1245 1246 shaderBody << " uvec3 size = gl_NumWorkGroups * gl_WorkGroupSize;\n" 1247 << " uint groupNdx = size.x*gl_GlobalInvocationID.y + gl_GlobalInvocationID.x;\n"; 1248 1249 if (m_isLocalArray) 1250 { 1251 const char* const readWriteStatement = (m_isRead) 1252 ? " sb_out.values.x = values[u_index];\n" 1253 : " sb_out.values[u_index] = values.x;\n"; 1254 1255 shaderBody << " highp vec4 values = vec4(1.0f, 0.0f, 3.0f, 2.0f) * float(groupNdx);\n" 1256 << readWriteStatement; 1257 } 1258 else 1259 { 1260 const std::string resName = (m_isUBO) ? "ub_in" : "sb_in"; 1261 1262 shaderDecl << "layout(std140, binding = 1) " << ((m_isUBO) ? "uniform" : "buffer") << " Input\n" 1263 << "{\n" 1264 << " highp vec4 values;\n" 1265 << "} " << resName << "[" << s_numBindings << "];\n"; 1266 1267 std::string readWriteStatement = (m_isRead) 1268 ? " sb_out.values.x = " + resName + "[0].values[u_index] * float(groupNdx);\n" 1269 : " sb_out.values[u_index] = " + resName + "[0].values.x * float(groupNdx);\n"; 1270 1271 shaderBody << readWriteStatement; 1272 } 1273 1274 return glu::ProgramSources() << glu::ComputeSource(genComputeShader(shaderDecl.str(), shaderBody.str())); 1275 } 1276 1277 glu::ProgramSources ShadersOOB::genSources (void) 1278 { 1279 if (m_shaderType == SHADERTYPE_COMPUTE) 1280 return genComputeSource(); 1281 else 1282 return genNonComputeSource(); 1283 } 1284 1285 void ShadersOOB::setup (void) 1286 { 1287 if (!m_isUBO && !m_isLocalArray && (m_shaderType != SHADERTYPE_COMPUTE)) 1288 { 1289 // Check implementation limits for shader SSBO 1290 int shaderStorageBlockSupported = -1; 1291 const bool isVertex = (m_shaderType == SHADERTYPE_VERT || m_shaderType == SHADERTYPE_VERT_AND_FRAG) ? true : false; 1292 string shaderTypeStr = isVertex ? "GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS" : "GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS"; 1293 1294 GLU_CHECK_GLW_CALL(m_gl, getIntegerv(isVertex ? GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS : GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS, &shaderStorageBlockSupported)); 1295 1296 if (shaderStorageBlockSupported < (int)m_buffers.size()) 1297 TCU_THROW(NotSupportedError, ("Test requires " + shaderTypeStr + " >= " + de::toString((int)m_buffers.size()) + ", got " + de::toString(shaderStorageBlockSupported)).c_str()); 1298 } 1299 1300 glu::ShaderProgram program(m_gl, genSources()); 1301 1302 m_log << program; 1303 1304 if (!program.isOk()) 1305 TCU_FAIL("Failed to compile shader program"); 1306 1307 GLU_CHECK_GLW_CALL(m_gl, useProgram(program.getProgram())); 1308 1309 const glw::GLint indexLocation = m_gl.getUniformLocation(program.getProgram(), "u_index"); 1310 GLU_CHECK_GLW_MSG(m_gl, "glGetUniformLocation()"); 1311 TCU_CHECK(indexLocation != (glw::GLint)-1); 1312 1313 const glw::GLint index = -1; 1314 GLU_CHECK_GLW_CALL(m_gl, uniform1i(indexLocation, index)); 1315 1316 if (m_shaderType != SHADERTYPE_COMPUTE) 1317 { 1318 const glw::GLfloat coords[] = 1319 { 1320 -1.0f, -1.0f, 1321 +1.0f, -1.0f, 1322 +1.0f, +1.0f, 1323 -1.0f, +1.0f 1324 }; 1325 1326 // Setup vertices position 1327 m_coordLocation = m_gl.getAttribLocation(program.getProgram(), "a_position"); 1328 GLU_CHECK_GLW_MSG(m_gl, "glGetAttribLocation()"); 1329 TCU_CHECK(m_coordLocation != (glw::GLint)-1); 1330 1331 // Load the vertex data 1332 m_coordinatesBuffer = 0; 1333 GLU_CHECK_GLW_CALL(m_gl, genBuffers(1, &m_coordinatesBuffer)); 1334 GLU_CHECK_GLW_CALL(m_gl, bindBuffer(GL_ARRAY_BUFFER, m_coordinatesBuffer)); 1335 GLU_CHECK_GLW_CALL(m_gl, bufferData(GL_ARRAY_BUFFER, (glw::GLsizeiptr)sizeof(coords), coords, GL_STATIC_DRAW)); 1336 GLU_CHECK_GLW_CALL(m_gl, enableVertexAttribArray(m_coordLocation)); 1337 GLU_CHECK_GLW_CALL(m_gl, vertexAttribPointer(m_coordLocation, 2, GL_FLOAT, GL_FALSE, 0, DE_NULL)); 1338 } 1339 1340 // Create dummy data for filling buffer objects 1341 const std::vector<tcu::Vec4> refValues(s_numBindings, tcu::Vec4(0.0f, 1.0f, 1.0f, 1.0f)); 1342 1343 if (m_isLocalArray && m_shaderType == SHADERTYPE_COMPUTE) 1344 { 1345 // Setup output buffer 1346 GLU_CHECK_GLW_CALL(m_gl, genBuffers((glw::GLsizei)1u, &m_buffers[0])); 1347 1348 GLU_CHECK_GLW_CALL(m_gl, bindBuffer(GL_SHADER_STORAGE_BUFFER, m_buffers[0])); 1349 GLU_CHECK_GLW_CALL(m_gl, bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(tcu::Vec4), &(refValues[0]), GL_STATIC_DRAW)); 1350 GLU_CHECK_GLW_CALL(m_gl, bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_buffers[0])); 1351 } 1352 else if (!m_isLocalArray) 1353 { 1354 // Set up interface block of buffer bindings 1355 GLU_CHECK_GLW_CALL(m_gl, genBuffers((glw::GLsizei)m_buffers.size(), &m_buffers[0])); 1356 1357 for (int bufNdx = 0; bufNdx < (int)m_buffers.size(); ++bufNdx) 1358 { 1359 const glw::GLenum resType = m_isUBO && (m_shaderType != SHADERTYPE_COMPUTE || bufNdx != 0) 1360 ? GL_UNIFORM_BUFFER 1361 : GL_SHADER_STORAGE_BUFFER; 1362 1363 GLU_CHECK_GLW_CALL(m_gl, bindBuffer(resType, m_buffers[bufNdx])); 1364 GLU_CHECK_GLW_CALL(m_gl, bufferData(resType, sizeof(tcu::Vec4), &(refValues[bufNdx]), GL_STATIC_DRAW)); 1365 GLU_CHECK_GLW_CALL(m_gl, bindBufferBase(resType, bufNdx, m_buffers[bufNdx])); 1366 } 1367 } 1368 } 1369 1370 void ShadersOOB::draw (void) 1371 { 1372 if (m_shaderType == SHADERTYPE_COMPUTE) 1373 m_gl.dispatchCompute(1, 1, 1); 1374 else 1375 { 1376 const glw::GLuint indices[] = {0, 1, 2, 2, 3, 0}; 1377 m_gl.drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, indices); 1378 } 1379 } 1380 1381 void ShadersOOB::teardown (void) 1382 { 1383 if (m_shaderType != SHADERTYPE_COMPUTE) 1384 { 1385 if (m_coordLocation) 1386 { 1387 GLU_CHECK_GLW_CALL(m_gl, disableVertexAttribArray(m_coordLocation)); 1388 m_coordLocation = 0; 1389 } 1390 } 1391 1392 if (m_coordinatesBuffer) 1393 { 1394 GLU_CHECK_GLW_CALL(m_gl, deleteBuffers(1, &m_coordinatesBuffer)); 1395 m_coordinatesBuffer = 0; 1396 } 1397 1398 if (!m_isLocalArray) 1399 { 1400 if (!m_buffers.empty()) 1401 { 1402 GLU_CHECK_GLW_CALL(m_gl, deleteBuffers((glw::GLsizei)m_buffers.size(), &m_buffers[0])); 1403 m_buffers.clear(); 1404 } 1405 } 1406 1407 GLU_CHECK_GLW_CALL(m_gl, useProgram(0)); 1408 } 1409 1410 class QueryRobustAccessCase : public RobustnessTestCase 1411 { 1412 public: 1413 QueryRobustAccessCase (EglTestContext& eglTestCtx, const char* name, const char* description) 1414 : RobustnessTestCase (eglTestCtx, name, description) {} 1415 1416 TestCase::IterateResult iterate (void) 1417 { 1418 TestLog& log = m_testCtx.getLog(); 1419 1420 log << tcu::TestLog::Message 1421 << "Check that after successfully creating a robust context the robust access query returned by glBooleanv() equals GL_TRUE\n\n" 1422 << tcu::TestLog::EndMessage; 1423 1424 const EGLint attribList[] = 1425 { 1426 EGL_CONTEXT_CLIENT_VERSION, 3, 1427 EGL_CONTEXT_MINOR_VERSION_KHR, 0, 1428 EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_TRUE, 1429 EGL_NONE 1430 }; 1431 1432 checkRequiredEGLExtensions(attribList); 1433 1434 RenderingContext context(m_eglTestCtx, attribList, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT); 1435 context.makeCurrent(m_eglSurface); 1436 1437 glw::Functions gl; 1438 { 1439 const glu::ApiType apiType(3, 0, glu::PROFILE_ES); 1440 context.initGLFunctions(&gl, apiType); 1441 checkRequiredGLSupport(gl, apiType); 1442 } 1443 1444 deUint8 robustAccessGL; 1445 gl.getBooleanv(GL_CONTEXT_ROBUST_ACCESS_EXT, &robustAccessGL); 1446 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv()"); 1447 1448 if (robustAccessGL != GL_TRUE) 1449 { 1450 log << TestLog::Message 1451 << "Invalid GL_CONTEXT_ROBUST_ACCESS returned by glGetBooleanv(). Got '" << robustAccessGL << "' expected GL_TRUE." 1452 << TestLog::EndMessage; 1453 1454 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1455 return STOP; 1456 } 1457 1458 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1459 return STOP; 1460 } 1461 }; 1462 1463 class NoResetNotificationCase : public RobustnessTestCase 1464 { 1465 public: 1466 NoResetNotificationCase (EglTestContext& eglTestCtx, const char* name, const char* description) 1467 : RobustnessTestCase (eglTestCtx, name, description) {} 1468 1469 TestCase::IterateResult iterate (void) 1470 { 1471 TestLog& log = m_testCtx.getLog(); 1472 1473 log << tcu::TestLog::Message 1474 << "Check the reset notification strategy returned by glGetIntegerv() equals GL_NO_RESET_NOTIFICATION\n\n" 1475 << tcu::TestLog::EndMessage; 1476 1477 const EGLint attribList[] = 1478 { 1479 EGL_CONTEXT_CLIENT_VERSION, 3, 1480 EGL_CONTEXT_MINOR_VERSION_KHR, 0, 1481 EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_TRUE, 1482 EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_NO_RESET_NOTIFICATION, 1483 EGL_NONE 1484 }; 1485 1486 checkRequiredEGLExtensions(attribList); 1487 1488 RenderingContext context(m_eglTestCtx, attribList, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT); 1489 context.makeCurrent(m_eglSurface); 1490 1491 glw::Functions gl; 1492 { 1493 const glu::ApiType apiType(3, 0, glu::PROFILE_ES); 1494 context.initGLFunctions(&gl, apiType); 1495 checkRequiredGLSupport(gl, apiType); 1496 } 1497 1498 deUint8 robustAccessGL; 1499 gl.getBooleanv(GL_CONTEXT_ROBUST_ACCESS_EXT, &robustAccessGL); 1500 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv()"); 1501 1502 glw::GLint reset = 0; 1503 gl.getIntegerv(GL_RESET_NOTIFICATION_STRATEGY, &reset); 1504 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()"); 1505 1506 if (reset != GL_NO_RESET_NOTIFICATION) 1507 { 1508 log << tcu::TestLog::Message 1509 << "Test failed! glGetIntegerv() returned wrong value. [" << glu::getErrorStr(reset) << ", expected " << glu::getErrorStr(GL_NO_RESET_NOTIFICATION) << "]" 1510 << tcu::TestLog::EndMessage; 1511 1512 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1513 return STOP; 1514 } 1515 1516 GLU_CHECK_GLW_CALL(gl, getGraphicsResetStatus()); 1517 1518 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1519 return STOP; 1520 } 1521 }; 1522 1523 class LoseContextOnResetCase : public RobustnessTestCase 1524 { 1525 public: 1526 LoseContextOnResetCase (EglTestContext& eglTestCtx, const char* name, const char* description) 1527 : RobustnessTestCase(eglTestCtx, name, description) {} 1528 1529 TestCase::IterateResult iterate (void) 1530 { 1531 TestLog& log = m_testCtx.getLog(); 1532 1533 log << tcu::TestLog::Message 1534 << "Check the reset notification strategy returned by glGetIntegerv() equals GL_LOSE_CONTEXT_ON_RESET\n\n" 1535 << tcu::TestLog::EndMessage; 1536 1537 const EGLint attribList[] = 1538 { 1539 EGL_CONTEXT_CLIENT_VERSION, 3, 1540 EGL_CONTEXT_MINOR_VERSION_KHR, 0, 1541 EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_TRUE, 1542 EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_LOSE_CONTEXT_ON_RESET, 1543 EGL_NONE 1544 }; 1545 1546 checkRequiredEGLExtensions(attribList); 1547 1548 RenderingContext context(m_eglTestCtx, attribList, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT); 1549 context.makeCurrent(m_eglSurface); 1550 1551 glw::Functions gl; 1552 { 1553 const glu::ApiType apiType(3, 0, glu::PROFILE_ES); 1554 context.initGLFunctions(&gl, apiType); 1555 checkRequiredGLSupport(gl, apiType); 1556 } 1557 glw::GLint reset = 0; 1558 gl.getIntegerv(GL_RESET_NOTIFICATION_STRATEGY, &reset); 1559 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()"); 1560 1561 if (reset != GL_LOSE_CONTEXT_ON_RESET) 1562 { 1563 log << tcu::TestLog::Message 1564 << "Test failed! glGetIntegerv() returned wrong value. [" << reset << ", expected " << glu::getErrorStr(GL_LOSE_CONTEXT_ON_RESET) << "]" 1565 << tcu::TestLog::EndMessage; 1566 1567 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1568 return STOP; 1569 } 1570 1571 log << tcu::TestLog::Message 1572 << "Check the graphics reset status returned by glGetGraphicsResetStatus() " 1573 << "equals GL_NO_ERROR\n" 1574 << tcu::TestLog::EndMessage; 1575 1576 GLU_CHECK_GLW_CALL(gl, getGraphicsResetStatus()); 1577 1578 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1579 return STOP; 1580 } 1581 }; 1582 1583 de::SharedPtr<ContextReset> contextResetFactory (const RobustnessTestCase::Params params, glw::Functions& gl, tcu::TestLog& log) 1584 { 1585 if (params.getContextResetType() == CONTEXTRESETTYPE_INFINITE_LOOP) 1586 return de::SharedPtr<ContextReset>(new InfiniteLoop(gl, log, params.getShaderType())); 1587 1588 if (params.getContextResetType() == CONTEXTRESETTYPE_FIXED_FUNC_OOB) 1589 return de::SharedPtr<ContextReset>(new FixedFunctionOOB(gl, log, params.getFixedFunctionType())); 1590 1591 if (params.getContextResetType() == CONTEXTRESETTYPE_SHADER_OOB) 1592 return de::SharedPtr<ContextReset>(new ShadersOOB(gl, log, params.getShaderType(), params.getResourceType(), params.getReadWriteType())); 1593 else 1594 { 1595 DE_FATAL("Unknown context reset type"); 1596 return de::SharedPtr<ContextReset>(DE_NULL); 1597 } 1598 } 1599 1600 class ContextResetCase : public RobustnessTestCase 1601 { 1602 1603 public: 1604 ContextResetCase (EglTestContext& eglTestCtx, const char* name, const char* description, Params params); 1605 virtual ~ContextResetCase (void) {}; 1606 1607 virtual void provokeReset (de::SharedPtr<ContextReset>& contextReset) = 0; 1608 virtual void waitForReset (de::SharedPtr<ContextReset>& contextReset) = 0; 1609 virtual void passAndLog (de::SharedPtr<ContextReset>& contextReset) = 0; 1610 1611 TestCase::IterateResult iterate (void); 1612 void execute (glw::Functions& gl); 1613 1614 private: 1615 ContextResetCase (const ContextResetCase&); 1616 ContextResetCase& operator= (const ContextResetCase&); 1617 }; 1618 1619 ContextResetCase::ContextResetCase (EglTestContext& eglTestCtx, const char* name, const char* description, Params params) 1620 : RobustnessTestCase (eglTestCtx, name, description, params) {} 1621 1622 TestCase::IterateResult ContextResetCase::iterate (void) 1623 { 1624 glw::Functions gl; 1625 1626 const EGLint attribList[] = 1627 { 1628 EGL_CONTEXT_CLIENT_VERSION, 3, 1629 EGL_CONTEXT_MINOR_VERSION_KHR, 0, 1630 EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, (m_params.getRobustAccessType() == ROBUSTACCESS_TRUE) ? EGL_TRUE : EGL_FALSE, 1631 EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_LOSE_CONTEXT_ON_RESET, 1632 EGL_NONE 1633 }; 1634 1635 checkRequiredEGLExtensions(attribList); 1636 1637 RenderingContext context(m_eglTestCtx, attribList, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT); 1638 context.makeCurrent(m_eglSurface); 1639 1640 { 1641 const glu::ApiType apiType = paramsToApiType(m_params); 1642 context.initGLFunctions(&gl, apiType); 1643 checkGLSupportForParams(gl, m_params); 1644 } 1645 1646 execute(gl); 1647 1648 return STOP; 1649 } 1650 1651 void ContextResetCase::execute (glw::Functions& gl) 1652 { 1653 de::SharedPtr<ContextReset> contextReset = contextResetFactory(m_params, gl, m_testCtx.getLog()); 1654 glw::GLboolean isContextRobust = GL_FALSE; 1655 1656 GLU_CHECK_GLW_CALL(gl, getBooleanv(GL_CONTEXT_ROBUST_ACCESS_EXT, &isContextRobust)); 1657 provokeReset(contextReset); 1658 1659 if (m_params.getContextResetType() == CONTEXTRESETTYPE_INFINITE_LOOP) 1660 { 1661 try 1662 { 1663 waitForReset(contextReset); 1664 1665 const glw::GLenum status = gl.getGraphicsResetStatus(); 1666 1667 if (status == GL_NO_ERROR) 1668 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Context was NOT lost"); 1669 else 1670 { 1671 m_testCtx.getLog() << tcu::TestLog::Message << "glGetGraphicsResetStatus() returned " << glu::getGraphicsResetStatusStr(status) << tcu::TestLog::EndMessage; 1672 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Context was lost"); 1673 } 1674 } 1675 catch (const glu::Error& error) 1676 { 1677 if (error.getError() == GL_CONTEXT_LOST) 1678 passAndLog(contextReset); 1679 else 1680 { 1681 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1682 1683 m_testCtx.getLog() << tcu::TestLog::Message 1684 << "Warning: glGetError() returned wrong value [" << error.what() << ", expected " << glu::getErrorStr(GL_CONTEXT_LOST) << "]" 1685 << tcu::TestLog::EndMessage; 1686 } 1687 } 1688 } 1689 else if (m_params.getContextResetType() == CONTEXTRESETTYPE_SHADER_OOB || m_params.getContextResetType() == CONTEXTRESETTYPE_FIXED_FUNC_OOB) 1690 { 1691 try 1692 { 1693 waitForReset(contextReset); 1694 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Context was NOT lost. Test skipped"); 1695 } 1696 catch (const glu::Error& error) 1697 { 1698 if (error.getError() == GL_CONTEXT_LOST) 1699 { 1700 if (isContextRobust) 1701 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "No context reset should of occurred GL_CONTEXT_ROBUST_ACCESS == TRUE"); 1702 else 1703 passAndLog(contextReset); 1704 } 1705 else if (isContextRobust) 1706 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got unknown error."); 1707 else 1708 { 1709 m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Warning: glGetError() returned wrong value. Expected GL_CONTEXT_LOST"); 1710 1711 m_testCtx.getLog() << tcu::TestLog::Message 1712 << "Warning: glGetError() returned wrong value [" << error.what() << ", expected " << glu::getErrorStr(GL_CONTEXT_LOST) << "]" 1713 << tcu::TestLog::EndMessage; 1714 } 1715 } 1716 } 1717 else 1718 DE_FATAL("Unknown context reset type"); 1719 } 1720 1721 class BasicResetCase : public ContextResetCase 1722 { 1723 public: 1724 1725 BasicResetCase (EglTestContext& eglTestCtx, const char* name, const char* description, Params params) 1726 : ContextResetCase (eglTestCtx, name, description, params) {} 1727 1728 virtual void provokeReset (de::SharedPtr<ContextReset>& contextReset) 1729 { 1730 m_testCtx.getLog() << tcu::TestLog::Message 1731 << "Check the graphics reset status returned by glGetGraphicsResetStatus() equals " 1732 << "GL_GUILTY_CONTEXT_RESET after a context reset\n\n" 1733 << tcu::TestLog::EndMessage; 1734 1735 contextReset->setup(); 1736 contextReset->draw(); 1737 } 1738 1739 virtual void waitForReset (de::SharedPtr<ContextReset>& contextReset) 1740 { 1741 contextReset->teardown(); 1742 contextReset->finish(); 1743 } 1744 1745 virtual void passAndLog (de::SharedPtr<ContextReset>& contextReset) 1746 { 1747 const glw::GLint status = contextReset->getGraphicsResetStatus(); 1748 1749 if (status == GL_NO_ERROR) 1750 { 1751 m_testCtx.getLog() << tcu::TestLog::Message 1752 << "Test failed! glGetGraphicsResetStatus() returned wrong value [" << glu::getGraphicsResetStatusStr(status) << ", expected " << glu::getGraphicsResetStatusStr(GL_GUILTY_CONTEXT_RESET) << "]" 1753 << tcu::TestLog::EndMessage; 1754 1755 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1756 } 1757 else 1758 { 1759 if (contextReset->getError() != GL_NO_ERROR) 1760 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Error flag not reset after calling getGraphicsResetStatus()"); 1761 else 1762 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1763 } 1764 } 1765 }; 1766 1767 class SyncObjectResetCase : public ContextResetCase 1768 { 1769 public: 1770 SyncObjectResetCase (EglTestContext& eglTestCtx, const char* name, const char* description, Params params) 1771 : ContextResetCase (eglTestCtx, name, description, params) {} 1772 1773 virtual void provokeReset (de::SharedPtr<ContextReset>& contextReset) 1774 { 1775 m_testCtx.getLog() << tcu::TestLog::Message 1776 << "Check the status of a sync object after a context reset returned by glGetSynciv() equals GL_SIGNALED\n\n" 1777 << tcu::TestLog::EndMessage; 1778 1779 contextReset->setup(); 1780 contextReset->draw(); 1781 } 1782 1783 virtual void waitForReset (de::SharedPtr<ContextReset>& contextReset) 1784 { 1785 contextReset->createSyncObject(); 1786 contextReset->teardown(); 1787 contextReset->finish(); 1788 } 1789 1790 virtual void passAndLog (de::SharedPtr<ContextReset>& contextReset) 1791 { 1792 const glw::GLint status = contextReset->getSyncStatus(); 1793 if (status != GL_SIGNALED) 1794 { 1795 m_testCtx.getLog() << tcu::TestLog::Message 1796 << "Test failed! glGetSynciv() returned wrong value [" << glu::getErrorStr(status) << ", expected " << glu::getErrorStr(GL_SIGNALED) << "]" 1797 << tcu::TestLog::EndMessage; 1798 1799 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1800 } 1801 else 1802 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1803 } 1804 }; 1805 1806 class QueryObjectResetCase : public ContextResetCase 1807 { 1808 public: 1809 QueryObjectResetCase (EglTestContext& eglTestCtx, const char* name, const char* description, Params params) 1810 : ContextResetCase (eglTestCtx, name, description, params) {} 1811 1812 virtual void provokeReset (de::SharedPtr<ContextReset>& contextReset) 1813 { 1814 m_testCtx.getLog() << tcu::TestLog::Message 1815 << "Check the status of a query object after a context reset returned by glGetQueryObjectuiv() equals GL_TRUE\n\n" 1816 << tcu::TestLog::EndMessage; 1817 1818 contextReset->setup(); 1819 contextReset->beginQuery(); 1820 contextReset->draw(); 1821 } 1822 1823 virtual void waitForReset (de::SharedPtr<ContextReset>& contextReset) 1824 { 1825 contextReset->endQuery(); 1826 contextReset->teardown(); 1827 contextReset->finish(); 1828 } 1829 1830 virtual void passAndLog (de::SharedPtr<ContextReset>& contextReset) 1831 { 1832 const glw::GLuint queryReady = contextReset->getQueryAvailability(); 1833 if (queryReady != GL_TRUE) 1834 { 1835 m_testCtx.getLog() << tcu::TestLog::Message 1836 << "Test failed! glGetQueryObjectuiv() returned wrong value [" << glu::getErrorStr(queryReady) << ", expected " << glu::getErrorStr(GL_TRUE) << "]" 1837 << tcu::TestLog::EndMessage; 1838 1839 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1840 } 1841 else 1842 { 1843 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1844 } 1845 } 1846 }; 1847 1848 class InvalidShareContextCase : public RobustnessTestCase 1849 { 1850 public: 1851 InvalidShareContextCase (EglTestContext& eglTestCtx, const char* name, const char* description) 1852 : RobustnessTestCase (eglTestCtx, name, description) {} 1853 1854 TestCase::IterateResult iterate (void) 1855 { 1856 TestLog& log = m_testCtx.getLog(); 1857 const Library& egl = m_eglTestCtx.getLibrary(); 1858 bool isOk = true; 1859 1860 log << tcu::TestLog::Message 1861 << "EGL_BAD_MATCH is generated if reset notification strategies do not match when creating shared contexts\n\n" 1862 << tcu::TestLog::EndMessage; 1863 1864 const EGLint attribListA[] = 1865 { 1866 EGL_CONTEXT_CLIENT_VERSION, 3, 1867 EGL_CONTEXT_MINOR_VERSION_KHR, 0, 1868 EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_TRUE, 1869 EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_NO_RESET_NOTIFICATION, 1870 EGL_NONE 1871 }; 1872 1873 const EGLint attribListB[] = 1874 { 1875 EGL_CONTEXT_CLIENT_VERSION, 3, 1876 EGL_CONTEXT_MINOR_VERSION_KHR, 0, 1877 EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_TRUE, 1878 EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_LOSE_CONTEXT_ON_RESET, 1879 EGL_NONE 1880 }; 1881 1882 checkRequiredEGLExtensions(attribListA); 1883 1884 log << tcu::TestLog::Message << "Create context A (share_context = EGL_NO_CONTEXT)" << tcu::TestLog::EndMessage; 1885 RenderingContext contextA(m_eglTestCtx, attribListA, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT); 1886 1887 log << tcu::TestLog::Message << "Create context B (share_context = context A)" << tcu::TestLog::EndMessage; 1888 logAttribList(m_eglTestCtx, attribListB); 1889 1890 EGLContext contextB = egl.createContext(m_eglDisplay, m_eglConfig, contextA.getContext(), attribListB); 1891 1892 const EGLenum error = egl.getError(); 1893 if (error != EGL_BAD_MATCH) 1894 { 1895 log << TestLog::Message 1896 << "Test failed! eglCreateContext() returned with error [" << eglu::getErrorStr(error) << ", expected " << eglu::getErrorStr(EGL_BAD_MATCH) << "]" 1897 << TestLog::EndMessage; 1898 1899 isOk = false; 1900 } 1901 1902 if (contextB != EGL_NO_CONTEXT) 1903 egl.destroyContext(m_eglDisplay, contextB); 1904 1905 if (isOk) 1906 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1907 else 1908 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1909 1910 return STOP; 1911 } 1912 }; 1913 1914 class InvalidNotificationEnumCase : public RobustnessTestCase 1915 { 1916 public: 1917 InvalidNotificationEnumCase (EglTestContext& eglTestCtx, const char* name, const char* description) 1918 : RobustnessTestCase (eglTestCtx, name, description) {} 1919 1920 TestCase::IterateResult iterate (void) 1921 { 1922 TestLog& log = m_testCtx.getLog(); 1923 const Library& egl = m_eglTestCtx.getLibrary(); 1924 bool isOk = true; 1925 1926 log << tcu::TestLog::Message 1927 << "EGL_BAD_ATTRIBUTE is generated if EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR is used with EGL versions <= 1.4\n\n" 1928 << tcu::TestLog::EndMessage; 1929 1930 const EGLint attribList[] = 1931 { 1932 EGL_CONTEXT_CLIENT_VERSION, 3, 1933 EGL_CONTEXT_MINOR_VERSION_KHR, 1, 1934 EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR, EGL_NO_RESET_NOTIFICATION, 1935 EGL_NONE 1936 }; 1937 1938 if (eglu::getVersion(egl, m_eglDisplay) >= eglu::Version(1, 5)) 1939 { 1940 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Test requires EGL version to be under 1.5"); 1941 return STOP; 1942 } 1943 1944 logAttribList(m_eglTestCtx, attribList); 1945 EGLContext context = egl.createContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, attribList); 1946 1947 const EGLenum error = egl.getError(); 1948 if (error != EGL_BAD_ATTRIBUTE) 1949 { 1950 log << TestLog::Message 1951 << "Test failed! eglCreateContext() returned with error [" << eglu::getErrorStr(error) << ", expected " << eglu::getErrorStr(EGL_BAD_ATTRIBUTE) << "]" 1952 << TestLog::EndMessage; 1953 1954 isOk = false; 1955 } 1956 1957 if (context != EGL_NO_CONTEXT) 1958 egl.destroyContext(m_eglDisplay, context); 1959 1960 if (isOk) 1961 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1962 else 1963 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1964 1965 return STOP; 1966 } 1967 }; 1968 1969 class SharedContextResetCase : public RobustnessTestCase 1970 { 1971 public: 1972 SharedContextResetCase (EglTestContext& eglTestCtx, const char* name, const char* description, Params params) 1973 : RobustnessTestCase (eglTestCtx, name, description, params) {} 1974 1975 TestCase::IterateResult iterate (void) 1976 { 1977 TestLog& log = m_testCtx.getLog(); 1978 1979 log << tcu::TestLog::Message 1980 << "A reset in one context will result in a reset in all other contexts in its share group\n\n" 1981 << tcu::TestLog::EndMessage; 1982 1983 // Create two share contexts with the same reset notification strategies 1984 const EGLint attribListShared[] = 1985 { 1986 EGL_CONTEXT_CLIENT_VERSION, 3, 1987 EGL_CONTEXT_MINOR_VERSION_KHR, 0, 1988 EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_TRUE, 1989 EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_LOSE_CONTEXT_ON_RESET, 1990 EGL_NONE 1991 }; 1992 1993 checkRequiredEGLExtensions(attribListShared); 1994 1995 log << tcu::TestLog::Message << "Create context A (share_context = EGL_NO_CONTEXT)" << tcu::TestLog::EndMessage; 1996 RenderingContext contextA(m_eglTestCtx, attribListShared, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT); 1997 1998 log << tcu::TestLog::Message << "Create context B (share_context = context A)" << tcu::TestLog::EndMessage; 1999 RenderingContext contextB(m_eglTestCtx, attribListShared, m_eglConfig, m_eglDisplay, contextA.getContext()); 2000 2001 contextA.makeCurrent(m_eglSurface); 2002 2003 glw::Functions gl; 2004 contextA.initGLFunctions(&gl, paramsToApiType(m_params)); 2005 checkGLSupportForParams(gl, m_params); 2006 2007 DE_ASSERT(m_params.getContextResetType() == CONTEXTRESETTYPE_INFINITE_LOOP); 2008 de::UniquePtr<ContextReset> contextReset(new InfiniteLoop(gl, log, m_params.getShaderType())); 2009 2010 contextReset->setup(); 2011 contextReset->draw(); 2012 2013 try 2014 { 2015 contextReset->teardown(); 2016 contextReset->finish(); 2017 } 2018 catch (const glu::Error& error) 2019 { 2020 if (error.getError() == GL_CONTEXT_LOST) 2021 { 2022 contextB.makeCurrent(m_eglSurface); 2023 2024 gl.getString(GL_VERSION); // arbitrary gl call 2025 2026 if (gl.getError() != GL_CONTEXT_LOST) 2027 { 2028 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Test failed! glGetError() returned wrong value. Expected GL_CONTEXT_LOST in context B"); 2029 return STOP; 2030 } 2031 } 2032 else 2033 { 2034 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Test failed! glGetError() returned wrong value. Expected GL_CONTEXT_LOST in context A"); 2035 return STOP; 2036 } 2037 } 2038 2039 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 2040 return STOP; 2041 } 2042 }; 2043 2044 class InvalidContextCase : public RobustnessTestCase 2045 { 2046 public: 2047 InvalidContextCase (EglTestContext& eglTestCtx, const char* name, const char* description) 2048 : RobustnessTestCase (eglTestCtx, name, description) {} 2049 2050 TestCase::IterateResult iterate (void) 2051 { 2052 const Library& egl = m_eglTestCtx.getLibrary(); 2053 TestLog& log = m_testCtx.getLog(); 2054 bool isOk = true; 2055 2056 log << tcu::TestLog::Message 2057 << "EGL_BAD_ATTRIBUTE is generated if EXT_create_context_robustness is NOT supported but EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT is specified\n\n" 2058 << tcu::TestLog::EndMessage; 2059 2060 const EGLint attribList[] = 2061 { 2062 EGL_CONTEXT_CLIENT_VERSION, 3, 2063 EGL_CONTEXT_MINOR_VERSION_KHR, 0, 2064 EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_LOSE_CONTEXT_ON_RESET, 2065 EGL_NONE 2066 }; 2067 2068 if (eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_create_context_robustness")) 2069 { 2070 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Test requires EGL_EXT_create_context_robustness to be unsupported"); 2071 return STOP; 2072 } 2073 2074 logAttribList(m_eglTestCtx, attribList); 2075 EGLContext context = egl.createContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, attribList); 2076 2077 const EGLenum error = egl.getError(); 2078 if (error != EGL_BAD_ATTRIBUTE) 2079 { 2080 log << TestLog::Message 2081 << "Test failed! eglCreateContext() returned with error [" << eglu::getErrorStr(error) << ", expected " << eglu::getErrorStr(EGL_BAD_ATTRIBUTE) << "]" 2082 << TestLog::EndMessage; 2083 2084 isOk = false; 2085 } 2086 2087 if (context != EGL_NO_CONTEXT) 2088 egl.destroyContext(m_eglDisplay, context); 2089 2090 if (isOk) 2091 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 2092 else 2093 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 2094 2095 return STOP; 2096 } 2097 }; 2098 2099 class RecoverFromResetCase : public RobustnessTestCase 2100 { 2101 public: 2102 RecoverFromResetCase (EglTestContext& eglTestCtx, const char* name, const char* description, Params params) 2103 : RobustnessTestCase (eglTestCtx, name, description, params) {} 2104 2105 TestCase::IterateResult iterate (void) 2106 { 2107 TestLog& log = m_testCtx.getLog(); 2108 2109 log << tcu::TestLog::Message 2110 << "Provoke a context reset and wait for glGetGraphicsResetStatus() to return NO_ERROR_KHR.\n" 2111 << "Destroy the old context and successfully create a new context.\n\n" 2112 << tcu::TestLog::EndMessage; 2113 2114 const EGLint attribList[] = 2115 { 2116 EGL_CONTEXT_CLIENT_VERSION, 3, 2117 EGL_CONTEXT_MINOR_VERSION_KHR, 0, 2118 EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_TRUE, 2119 EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_LOSE_CONTEXT_ON_RESET, 2120 EGL_NONE 2121 }; 2122 2123 checkRequiredEGLExtensions(attribList); 2124 2125 log << tcu::TestLog::Message << "Create context A" << tcu::TestLog::EndMessage; 2126 RenderingContext contextA(m_eglTestCtx, attribList, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT); 2127 contextA.makeCurrent(m_eglSurface); 2128 2129 glw::Functions gl; 2130 contextA.initGLFunctions(&gl, paramsToApiType(m_params)); 2131 checkGLSupportForParams(gl, m_params); 2132 2133 DE_ASSERT(m_params.getContextResetType() == CONTEXTRESETTYPE_INFINITE_LOOP); 2134 de::UniquePtr<ContextReset> contextReset(new InfiniteLoop(gl, log, m_params.getShaderType())); 2135 2136 contextReset->setup(); 2137 contextReset->draw(); 2138 2139 try 2140 { 2141 contextReset->teardown(); 2142 contextReset->finish(); 2143 } 2144 catch (const glu::Error& error) 2145 { 2146 if (error.getError() == GL_CONTEXT_LOST) 2147 { 2148 const glw::GLint status = gl.getGraphicsResetStatus(); 2149 if (status == GL_NO_ERROR) 2150 { 2151 log << tcu::TestLog::Message 2152 << "Test failed! glGetGraphicsResetStatus() returned wrong value [" << glu::getErrorStr(status) << ", expected " << glu::getErrorStr(GL_GUILTY_CONTEXT_RESET) << "]" 2153 << tcu::TestLog::EndMessage; 2154 2155 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 2156 return STOP; 2157 } 2158 2159 const int sleepTimeMs = 1000; // (1 second) 2160 int timeout = sleepTimeMs * 10; // (10 seconds) 2161 int reset_status = -1; 2162 2163 // wait for context to reset 2164 while ((reset_status = gl.getGraphicsResetStatus() != GL_NO_ERROR) && timeout > 0) 2165 { 2166 deSleep(sleepTimeMs); 2167 timeout -= sleepTimeMs; 2168 } 2169 2170 if (reset_status != GL_NO_ERROR) 2171 { 2172 log << tcu::TestLog::Message 2173 << "Test failed! Context did not reset. glGetGraphicsResetStatus() returned wrong value [" << glu::getErrorStr(reset_status) << ", expected " << glu::getErrorStr(GL_NO_ERROR) << "]" 2174 << tcu::TestLog::EndMessage; 2175 2176 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 2177 return STOP; 2178 } 2179 } 2180 else 2181 { 2182 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Test failed! glGetError() returned wrong value. Expected GL_CONTEXT_LOST in context A"); 2183 return STOP; 2184 } 2185 } 2186 2187 try 2188 { 2189 log << tcu::TestLog::Message << "Create context B" << tcu::TestLog::EndMessage; 2190 RenderingContext contextB(m_eglTestCtx, attribList, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT); 2191 } 2192 catch (const glu::Error&) 2193 { 2194 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Test failed! Could not create new context. glGetError() returned wrong value. Expected GL_NO_ERROR"); 2195 return STOP; 2196 } 2197 2198 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 2199 return STOP; 2200 } 2201 }; 2202 2203 } // anonymous 2204 2205 // Note: Tests limited to openGLES 3.1 contexts only 2206 TestCaseGroup* createRobustnessTests (EglTestContext& eglTestCtx) 2207 { 2208 de::MovePtr<TestCaseGroup> group (new TestCaseGroup(eglTestCtx, "robustness", "KHR_robustness tests")); 2209 2210 tcu::TestCaseGroup* const contextCreationTestGroup = new TestCaseGroup(eglTestCtx, "create_context", "Test valid context_creation attributes"); 2211 tcu::TestCaseGroup* const contextResetTestGroup = new TestCaseGroup(eglTestCtx, "reset_context", "Test context resets scenarios"); 2212 tcu::TestCaseGroup* const negativeContextTestGroup = new TestCaseGroup(eglTestCtx, "negative_context", "Test invalid context creation attributes"); 2213 2214 tcu::TestCaseGroup* const shadersTestGroup = new TestCaseGroup(eglTestCtx, "shaders", "Shader specific context reset tests"); 2215 tcu::TestCaseGroup* const fixedFunctionTestGroup = new TestCaseGroup(eglTestCtx, "fixed_function_pipeline", "Fixed function pipeline context reset tests with robust context"); 2216 tcu::TestCaseGroup* const fixedFunctionNonRobustTestGroup = new TestCaseGroup(eglTestCtx, "fixed_function_pipeline_non_robust", "Fixed function pipeline context reset tests with non-robust context"); 2217 2218 tcu::TestCaseGroup* const infiniteLoopTestGroup = new TestCaseGroup(eglTestCtx, "infinite_loop", "Infinite loop scenarios"); 2219 tcu::TestCaseGroup* const outOfBoundsTestGroup = new TestCaseGroup(eglTestCtx, "out_of_bounds", "Out of bounds access scenarios with robust context"); 2220 2221 tcu::TestCaseGroup* const outOfBoundsNonRobustTestGroup = new TestCaseGroup(eglTestCtx, "out_of_bounds_non_robust", "Out of bounds access scenarios with non-robust context"); 2222 2223 const string resetScenarioDescription = "query error states and reset notifications"; 2224 const string syncScenarioDescription = "query sync status with getSynciv()"; 2225 const string queryScenarioDescription = "check availability of query result with getQueryObjectiv()"; 2226 const string sharedScenarioDescription = "check reset notification is propagated to shared context"; 2227 const string recoverScenarioDescription = "delete the old context and create a new one"; 2228 2229 // infinite loop test cases 2230 { 2231 tcu::TestCaseGroup* const infiniteLoopResetTestGroup = new TestCaseGroup(eglTestCtx, "reset_status", "Tests that query the reset status after a context reset has occurred"); 2232 tcu::TestCaseGroup* const infiniteLoopSyncTestGroup = new TestCaseGroup(eglTestCtx, "sync_status", "Tests that query the sync status after a context reset has occurred"); 2233 tcu::TestCaseGroup* const infiniteLoopQueryTestGroup = new TestCaseGroup(eglTestCtx, "query_status", "Tests that query the state of a query object after a context reset has occurred"); 2234 tcu::TestCaseGroup* const infiniteLoopSharedTestGroup = new TestCaseGroup(eglTestCtx, "shared_context_status", "Tests that query the state of a shared context after a reset has occurred"); 2235 tcu::TestCaseGroup* const infiniteLoopRecoverTestGroup = new TestCaseGroup(eglTestCtx, "recover_from_reset", "Tests that attempt to create a new context after a context has occurred"); 2236 2237 static const RobustnessTestCase::Params s_infiniteLoopCases[] = 2238 { 2239 RobustnessTestCase::Params("vertex", "Provoke a context reset in vertex shader and ", CONTEXTRESETTYPE_INFINITE_LOOP, SHADERTYPE_VERT), 2240 RobustnessTestCase::Params("fragment", "Provoke a context reset in fragment shader and ", CONTEXTRESETTYPE_INFINITE_LOOP, SHADERTYPE_FRAG), 2241 RobustnessTestCase::Params("vertex_and_fragment", "Provoke a context reset in vertex and fragment shader and ", CONTEXTRESETTYPE_INFINITE_LOOP, SHADERTYPE_VERT_AND_FRAG), 2242 RobustnessTestCase::Params("compute", "Provoke a context reset in compute shader and ", CONTEXTRESETTYPE_INFINITE_LOOP, SHADERTYPE_COMPUTE), 2243 }; 2244 2245 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(s_infiniteLoopCases); ++testNdx) 2246 { 2247 const RobustnessTestCase::Params& test = s_infiniteLoopCases[testNdx]; 2248 infiniteLoopResetTestGroup->addChild (new BasicResetCase (eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test)); 2249 infiniteLoopSyncTestGroup->addChild (new SyncObjectResetCase (eglTestCtx, test.getName().c_str(), (test.getDescription() + syncScenarioDescription).c_str(), test)); 2250 infiniteLoopQueryTestGroup->addChild (new QueryObjectResetCase (eglTestCtx, test.getName().c_str(), (test.getDescription() + queryScenarioDescription).c_str(), test)); 2251 infiniteLoopSharedTestGroup->addChild (new SharedContextResetCase (eglTestCtx, test.getName().c_str(), (test.getDescription() + sharedScenarioDescription).c_str(), test)); 2252 infiniteLoopRecoverTestGroup->addChild (new RecoverFromResetCase (eglTestCtx, test.getName().c_str(), (test.getDescription() + recoverScenarioDescription).c_str(), test)); 2253 } 2254 2255 infiniteLoopTestGroup->addChild(infiniteLoopResetTestGroup); 2256 infiniteLoopTestGroup->addChild(infiniteLoopSyncTestGroup); 2257 infiniteLoopTestGroup->addChild(infiniteLoopQueryTestGroup); 2258 infiniteLoopTestGroup->addChild(infiniteLoopSharedTestGroup); 2259 infiniteLoopTestGroup->addChild(infiniteLoopRecoverTestGroup); 2260 } 2261 2262 // out-of-bounds test cases 2263 { 2264 // robust context 2265 tcu::TestCaseGroup* const uboReadArrayResetTestGroup = new TestCaseGroup(eglTestCtx, "uniform_block", "Uniform Block Accesses"); 2266 tcu::TestCaseGroup* const uboWriteArrayResetTestGroup = new TestCaseGroup(eglTestCtx, "uniform_block", "Uniform Block Accesses"); 2267 tcu::TestCaseGroup* const ssboWriteArrayResetTestGroup = new TestCaseGroup(eglTestCtx, "shader_storage_block", "Shader Storage Block accesses"); 2268 tcu::TestCaseGroup* const ssboReadArrayResetTestGroup = new TestCaseGroup(eglTestCtx, "shader_storage_block", "Shader Storage Block accesses"); 2269 tcu::TestCaseGroup* const localWriteArrayResetTestGroup = new TestCaseGroup(eglTestCtx, "local_array", "Local array accesses"); 2270 tcu::TestCaseGroup* const localReadArrayResetTestGroup = new TestCaseGroup(eglTestCtx, "local_array", "Local array accesses"); 2271 2272 // non-robust context (internal use only) 2273 tcu::TestCaseGroup* const uboReadArrayResetNonRobustTestGroup = new TestCaseGroup(eglTestCtx, "uniform_block", "Uniform Block Accesses"); 2274 tcu::TestCaseGroup* const uboWriteArrayResetNonRobustTestGroup = new TestCaseGroup(eglTestCtx, "uniform_block", "Uniform Block Accesses"); 2275 tcu::TestCaseGroup* const ssboWriteArrayResetNonRobustTestGroup = new TestCaseGroup(eglTestCtx, "shader_storage_block", "Shader Storage Block accesses"); 2276 tcu::TestCaseGroup* const ssboReadArrayResetNonRobustTestGroup = new TestCaseGroup(eglTestCtx, "shader_storage_block", "Shader Storage Block accesses"); 2277 tcu::TestCaseGroup* const localWriteArrayResetNonRobustTestGroup = new TestCaseGroup(eglTestCtx, "local_array", "Local array accesses"); 2278 tcu::TestCaseGroup* const localReadArrayResetNonRobustTestGroup = new TestCaseGroup(eglTestCtx, "local_array", "Local array accesses"); 2279 2280 static const RobustnessTestCase::Params s_outOfBoundReadCases[] = 2281 { 2282 // ubo read only 2283 RobustnessTestCase::Params ("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_UBO, READWRITETYPE_READ), 2284 RobustnessTestCase::Params ("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_UBO, READWRITETYPE_READ), 2285 RobustnessTestCase::Params ("vertex_and_fragment", "Provoke a context reset in vertex and fragment shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT_AND_FRAG, RESOURCETYPE_UBO, READWRITETYPE_READ), 2286 RobustnessTestCase::Params ("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_UBO, READWRITETYPE_READ), 2287 2288 // ssbo read only 2289 RobustnessTestCase::Params ("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_SSBO, READWRITETYPE_READ), 2290 RobustnessTestCase::Params ("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_SSBO, READWRITETYPE_READ), 2291 RobustnessTestCase::Params ("vertex_and_fragment", "Provoke a context reset in vertex and fragment shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT_AND_FRAG, RESOURCETYPE_SSBO, READWRITETYPE_READ), 2292 RobustnessTestCase::Params ("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_SSBO, READWRITETYPE_READ), 2293 2294 // local array read only 2295 RobustnessTestCase::Params ("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_READ), 2296 RobustnessTestCase::Params ("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_READ), 2297 RobustnessTestCase::Params ("vertex_and_fragment", "Provoke a context reset in vertex and fragment shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT_AND_FRAG, RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_READ), 2298 RobustnessTestCase::Params ("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_READ), 2299 2300 // ubo read only (non-robust) 2301 RobustnessTestCase::Params ("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_UBO, READWRITETYPE_READ), 2302 RobustnessTestCase::Params ("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_UBO, READWRITETYPE_READ), 2303 RobustnessTestCase::Params ("vertex_and_fragment", "Provoke a context reset in vertex and fragment shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT_AND_FRAG, RESOURCETYPE_UBO, READWRITETYPE_READ), 2304 RobustnessTestCase::Params ("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_UBO, READWRITETYPE_READ), 2305 2306 // ssbo read only (non-robust) 2307 RobustnessTestCase::Params ("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_SSBO, READWRITETYPE_READ), 2308 RobustnessTestCase::Params ("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_SSBO, READWRITETYPE_READ), 2309 RobustnessTestCase::Params ("vertex_and_fragment", "Provoke a context reset in vertex and fragment shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT_AND_FRAG, RESOURCETYPE_SSBO, READWRITETYPE_READ), 2310 RobustnessTestCase::Params ("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_SSBO, READWRITETYPE_READ), 2311 2312 // local array read only (non-robust) 2313 RobustnessTestCase::Params ("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_READ), 2314 RobustnessTestCase::Params ("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_READ), 2315 RobustnessTestCase::Params ("vertex_and_fragment", "Provoke a context reset in vertex and fragment shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT_AND_FRAG, RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_READ), 2316 RobustnessTestCase::Params ("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_READ), 2317 }; 2318 2319 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(s_outOfBoundReadCases); ++testNdx) 2320 { 2321 const RobustnessTestCase::Params& test = s_outOfBoundReadCases[testNdx]; 2322 2323 if (test.getResourceType() == RESOURCETYPE_UBO && test.getRobustAccessType() == ROBUSTACCESS_TRUE) 2324 uboReadArrayResetTestGroup->addChild (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test)); 2325 2326 if (test.getResourceType() == RESOURCETYPE_UBO && test.getRobustAccessType() == ROBUSTACCESS_FALSE) 2327 uboReadArrayResetNonRobustTestGroup->addChild (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test)); 2328 2329 if (test.getResourceType() == RESOURCETYPE_SSBO && test.getRobustAccessType() == ROBUSTACCESS_TRUE) 2330 ssboReadArrayResetTestGroup->addChild (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test)); 2331 2332 if (test.getResourceType() == RESOURCETYPE_SSBO && test.getRobustAccessType() == ROBUSTACCESS_FALSE) 2333 ssboReadArrayResetNonRobustTestGroup->addChild (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test)); 2334 2335 if (test.getResourceType() == RESOURCETYPE_LOCAL_ARRAY && test.getRobustAccessType() == ROBUSTACCESS_TRUE) 2336 localReadArrayResetTestGroup->addChild (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test)); 2337 2338 if (test.getResourceType() == RESOURCETYPE_LOCAL_ARRAY && test.getRobustAccessType() == ROBUSTACCESS_FALSE) 2339 localReadArrayResetNonRobustTestGroup->addChild (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test)); 2340 } 2341 2342 static const RobustnessTestCase::Params s_outOfBoundWriteCases[] = 2343 { 2344 // ubo write only 2345 RobustnessTestCase::Params ("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_UBO, READWRITETYPE_WRITE), 2346 RobustnessTestCase::Params ("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_UBO, READWRITETYPE_WRITE), 2347 RobustnessTestCase::Params ("vertex_and_fragment", "Provoke a context reset in vertex and fragment shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT_AND_FRAG, RESOURCETYPE_UBO, READWRITETYPE_WRITE), 2348 RobustnessTestCase::Params ("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_UBO, READWRITETYPE_WRITE), 2349 2350 // ssbo write only 2351 RobustnessTestCase::Params ("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_SSBO, READWRITETYPE_WRITE), 2352 RobustnessTestCase::Params ("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_SSBO, READWRITETYPE_WRITE), 2353 RobustnessTestCase::Params ("vertex_and_fragment", "Provoke a context reset in vertex and fragment shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT_AND_FRAG, RESOURCETYPE_SSBO, READWRITETYPE_WRITE), 2354 RobustnessTestCase::Params ("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_SSBO, READWRITETYPE_WRITE), 2355 2356 // local array write only 2357 RobustnessTestCase::Params ("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_WRITE), 2358 RobustnessTestCase::Params ("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_WRITE), 2359 RobustnessTestCase::Params ("vertex_and_fragment", "Provoke a context reset in vertex and fragment shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT_AND_FRAG, RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_WRITE), 2360 RobustnessTestCase::Params ("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_WRITE), 2361 2362 // ubo write only (non-robust) 2363 RobustnessTestCase::Params ("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_UBO, READWRITETYPE_WRITE), 2364 RobustnessTestCase::Params ("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_UBO, READWRITETYPE_WRITE), 2365 RobustnessTestCase::Params ("vertex_and_fragment", "Provoke a context reset in vertex and fragment shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT_AND_FRAG, RESOURCETYPE_UBO, READWRITETYPE_WRITE), 2366 RobustnessTestCase::Params ("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_UBO, READWRITETYPE_WRITE), 2367 2368 // ssbo write only (non-robust) 2369 RobustnessTestCase::Params ("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_SSBO, READWRITETYPE_WRITE), 2370 RobustnessTestCase::Params ("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_SSBO, READWRITETYPE_WRITE), 2371 RobustnessTestCase::Params ("vertex_and_fragment", "Provoke a context reset in vertex and fragment shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT_AND_FRAG, RESOURCETYPE_SSBO, READWRITETYPE_WRITE), 2372 RobustnessTestCase::Params ("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_SSBO, READWRITETYPE_WRITE), 2373 2374 // local array write only (non-robust) 2375 RobustnessTestCase::Params ("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_WRITE), 2376 RobustnessTestCase::Params ("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_WRITE), 2377 RobustnessTestCase::Params ("vertex_and_fragment", "Provoke a context reset in vertex and fragment shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT_AND_FRAG, RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_WRITE), 2378 RobustnessTestCase::Params ("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_WRITE), 2379 }; 2380 2381 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(s_outOfBoundWriteCases); ++testNdx) 2382 { 2383 const RobustnessTestCase::Params& test = s_outOfBoundWriteCases[testNdx]; 2384 2385 if (test.getResourceType() == RESOURCETYPE_UBO && test.getRobustAccessType() == ROBUSTACCESS_TRUE) 2386 uboWriteArrayResetTestGroup->addChild (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test)); 2387 2388 if (test.getResourceType() == RESOURCETYPE_UBO && test.getRobustAccessType() == ROBUSTACCESS_FALSE) 2389 uboWriteArrayResetNonRobustTestGroup->addChild (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test)); 2390 2391 if (test.getResourceType() == RESOURCETYPE_SSBO && test.getRobustAccessType() == ROBUSTACCESS_TRUE) 2392 ssboWriteArrayResetTestGroup->addChild (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test)); 2393 2394 if (test.getResourceType() == RESOURCETYPE_SSBO && test.getRobustAccessType() == ROBUSTACCESS_FALSE) 2395 ssboWriteArrayResetNonRobustTestGroup->addChild (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test)); 2396 2397 if (test.getResourceType() == RESOURCETYPE_LOCAL_ARRAY && test.getRobustAccessType() == ROBUSTACCESS_TRUE) 2398 localWriteArrayResetTestGroup->addChild (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test)); 2399 2400 if (test.getResourceType() == RESOURCETYPE_LOCAL_ARRAY && test.getRobustAccessType() == ROBUSTACCESS_FALSE) 2401 localWriteArrayResetNonRobustTestGroup->addChild (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test)); 2402 } 2403 2404 // robust Context 2405 tcu::TestCaseGroup* const outOfBoundsResetReadAccessTestGroup = new TestCaseGroup(eglTestCtx, "reads", "Out of bounds read accesses"); 2406 tcu::TestCaseGroup* const outOfBoundsResetWriteAccessTestGroup = new TestCaseGroup(eglTestCtx, "writes", "Out of bounds write accesses"); 2407 2408 outOfBoundsResetReadAccessTestGroup->addChild(uboReadArrayResetTestGroup); 2409 outOfBoundsResetReadAccessTestGroup->addChild(ssboReadArrayResetTestGroup); 2410 outOfBoundsResetReadAccessTestGroup->addChild(localReadArrayResetTestGroup); 2411 2412 outOfBoundsResetWriteAccessTestGroup->addChild(uboWriteArrayResetTestGroup); 2413 outOfBoundsResetWriteAccessTestGroup->addChild(ssboWriteArrayResetTestGroup); 2414 outOfBoundsResetWriteAccessTestGroup->addChild(localWriteArrayResetTestGroup); 2415 2416 tcu::TestCaseGroup* const outOfBoundsResetTestGroup = new TestCaseGroup(eglTestCtx, "reset_status", "Tests that query the reset status after a context reset has occurred"); 2417 2418 outOfBoundsResetTestGroup->addChild(outOfBoundsResetReadAccessTestGroup); 2419 outOfBoundsResetTestGroup->addChild(outOfBoundsResetWriteAccessTestGroup); 2420 2421 outOfBoundsTestGroup->addChild(outOfBoundsResetTestGroup); 2422 2423 // non-robust Context (internal use only) 2424 tcu::TestCaseGroup* const outOfBoundsResetReadAccessNonRobustTestGroup = new TestCaseGroup(eglTestCtx, "reads", "Out of bounds read accesses"); 2425 tcu::TestCaseGroup* const outOfBoundsResetWriteAccessNonRobustTestGroup = new TestCaseGroup(eglTestCtx, "writes", "Out of bounds write accesses"); 2426 2427 outOfBoundsResetReadAccessNonRobustTestGroup->addChild(uboReadArrayResetNonRobustTestGroup); 2428 outOfBoundsResetReadAccessNonRobustTestGroup->addChild(ssboReadArrayResetNonRobustTestGroup); 2429 outOfBoundsResetReadAccessNonRobustTestGroup->addChild(localReadArrayResetNonRobustTestGroup); 2430 2431 outOfBoundsResetWriteAccessNonRobustTestGroup->addChild(uboWriteArrayResetNonRobustTestGroup); 2432 outOfBoundsResetWriteAccessNonRobustTestGroup->addChild(ssboWriteArrayResetNonRobustTestGroup); 2433 outOfBoundsResetWriteAccessNonRobustTestGroup->addChild(localWriteArrayResetNonRobustTestGroup); 2434 2435 tcu::TestCaseGroup* const outOfBoundsResetNonRobustTestGroup = new TestCaseGroup(eglTestCtx, "reset_status", "Tests that query the reset status after a context reset has occurred"); 2436 2437 outOfBoundsResetNonRobustTestGroup->addChild(outOfBoundsResetReadAccessNonRobustTestGroup); 2438 outOfBoundsResetNonRobustTestGroup->addChild(outOfBoundsResetWriteAccessNonRobustTestGroup); 2439 2440 outOfBoundsNonRobustTestGroup->addChild(outOfBoundsResetNonRobustTestGroup); 2441 } 2442 2443 // fixed function test cases 2444 { 2445 // robust context 2446 tcu::TestCaseGroup* const fixedFunctionResetStatusTestGroup = new TestCaseGroup(eglTestCtx, "reset_status", "Tests that query the reset status after a context reset has occurred"); 2447 2448 // non-robust context (internal use only) 2449 tcu::TestCaseGroup* const fixedFunctionResetStatusNonRobustTestGroup = new TestCaseGroup(eglTestCtx, "reset_status", "Tests that query the reset status after a context reset has occurred"); 2450 2451 static const RobustnessTestCase::Params s_fixedFunctionPipelineCases[] = 2452 { 2453 RobustnessTestCase::Params( "index_buffer_out_of_bounds", "Provoke context reset and query error states and reset notifications", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_FIXED_FUNC_OOB, FIXEDFUNCTIONTYPE_INDICES), 2454 RobustnessTestCase::Params( "vertex_buffer_out_of_bounds", "Provoke context reset and query error states and reset notifications", ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_FIXED_FUNC_OOB, FIXEDFUNCTIONTYPE_VERTICES), 2455 2456 RobustnessTestCase::Params( "index_buffer_out_of_bounds", "Provoke context reset and query error states and reset notifications", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_FIXED_FUNC_OOB, FIXEDFUNCTIONTYPE_INDICES), 2457 RobustnessTestCase::Params( "vertex_buffer_out_of_bounds", "Provoke context reset and query error states and reset notifications", ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_FIXED_FUNC_OOB, FIXEDFUNCTIONTYPE_VERTICES), 2458 }; 2459 2460 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(s_fixedFunctionPipelineCases); ++testNdx) 2461 { 2462 const RobustnessTestCase::Params& test = s_fixedFunctionPipelineCases[testNdx]; 2463 if (test.getRobustAccessType() == ROBUSTACCESS_TRUE) 2464 fixedFunctionResetStatusTestGroup->addChild(new BasicResetCase(eglTestCtx, test.getName().c_str(), test.getDescription().c_str(), test)); 2465 else 2466 fixedFunctionResetStatusNonRobustTestGroup->addChild(new BasicResetCase(eglTestCtx, test.getName().c_str(), test.getDescription().c_str(), test)); 2467 } 2468 2469 fixedFunctionTestGroup->addChild(fixedFunctionResetStatusTestGroup); 2470 fixedFunctionNonRobustTestGroup->addChild(fixedFunctionResetStatusNonRobustTestGroup); 2471 } 2472 2473 // context creation query cases 2474 { 2475 contextCreationTestGroup->addChild(new QueryRobustAccessCase (eglTestCtx, "query_robust_access", "Query robust access after successfully creating a robust context")); 2476 contextCreationTestGroup->addChild(new NoResetNotificationCase (eglTestCtx, "no_reset_notification", "Query reset notification strategy after specifying GL_NO_RESET_NOTIFICATION")); 2477 contextCreationTestGroup->addChild(new LoseContextOnResetCase (eglTestCtx, "lose_context_on_reset", "Query reset notification strategy after specifying GL_LOSE_CONTEXT_ON_RESET")); 2478 } 2479 2480 // invalid context creation cases 2481 { 2482 negativeContextTestGroup->addChild(new InvalidContextCase (eglTestCtx, "invalid_robust_context_creation", "Create a non-robust context but specify a reset notification strategy")); 2483 negativeContextTestGroup->addChild(new InvalidShareContextCase (eglTestCtx, "invalid_robust_shared_context_creation", "Create a context share group with conflicting reset notification strategies")); 2484 negativeContextTestGroup->addChild(new InvalidNotificationEnumCase (eglTestCtx, "invalid_notification_strategy_enum", "Create a robust context using EGL 1.5 only enum with EGL versions <= 1.4" )); 2485 } 2486 2487 shadersTestGroup->addChild(infiniteLoopTestGroup); 2488 shadersTestGroup->addChild(outOfBoundsTestGroup); 2489 shadersTestGroup->addChild(outOfBoundsNonRobustTestGroup); 2490 2491 contextResetTestGroup->addChild(shadersTestGroup); 2492 contextResetTestGroup->addChild(fixedFunctionTestGroup); 2493 contextResetTestGroup->addChild(fixedFunctionNonRobustTestGroup); 2494 2495 group->addChild(contextCreationTestGroup); 2496 group->addChild(contextResetTestGroup); 2497 group->addChild(negativeContextTestGroup); 2498 2499 return group.release(); 2500 } 2501 2502 } // egl 2503 } // deqp 2504
