modules/egl/teglRobustnessTests.cpp

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