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_VERT || m_shaderType == SHADERTYPE_VERT_AND_FRAG))
1281         {
1282                 // Check implementation limits for vertex shader SSBO
1283                 int vertexShaderStorageBlockSupported = -1;
1284
1285                 GLU_CHECK_GLW_CALL(m_gl, getIntegerv(GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS, &vertexShaderStorageBlockSupported));
1286
1287                 if (vertexShaderStorageBlockSupported < (int)m_buffers.size())
1288                         TCU_THROW(NotSupportedError, ("Test requires GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS >= " + de::toString((int)m_buffers.size()) + ", got " + de::toString(vertexShaderStorageBlockSupported)).c_str());
1289         }
1290
1291         glu::ShaderProgram program(m_gl, genSources());
1292
1293         m_log << program;
1294
1295         if (!program.isOk())
1296                 TCU_FAIL("Failed to compile shader program");
1297
1298         GLU_CHECK_GLW_CALL(m_gl, useProgram(program.getProgram()));
1299
1300         const glw::GLint indexLocation = m_gl.getUniformLocation(program.getProgram(), "u_index");
1301         GLU_CHECK_GLW_MSG(m_gl, "glGetUniformLocation()");
1302         TCU_CHECK(indexLocation != (glw::GLint)-1);
1303
1304         const glw::GLint index = -1;
1305         GLU_CHECK_GLW_CALL(m_gl, uniform1i(indexLocation, index));
1306
1307         if (m_shaderType != SHADERTYPE_COMPUTE)
1308         {
1309                 const glw::GLfloat coords[] =
1310                 {
1311                         -1.0f, -1.0f,
1312                         +1.0f, -1.0f,
1313                         +1.0f, +1.0f,
1314                         -1.0f, +1.0f
1315                 };
1316
1317                 // Setup vertices position
1318                 m_coordLocation = m_gl.getAttribLocation(program.getProgram(), "a_position");
1319                 GLU_CHECK_GLW_MSG(m_gl, "glGetAttribLocation()");
1320                 TCU_CHECK(m_coordLocation != (glw::GLint)-1);
1321
1322                 // Load the vertex data
1323                 m_coordinatesBuffer = 0;
1324                 GLU_CHECK_GLW_CALL(m_gl, genBuffers(1, &m_coordinatesBuffer));
1325                 GLU_CHECK_GLW_CALL(m_gl, bindBuffer(GL_ARRAY_BUFFER, m_coordinatesBuffer));
1326                 GLU_CHECK_GLW_CALL(m_gl, bufferData(GL_ARRAY_BUFFER, (glw::GLsizeiptr)sizeof(coords), coords, GL_STATIC_DRAW));
1327                 GLU_CHECK_GLW_CALL(m_gl, enableVertexAttribArray(m_coordLocation));
1328                 GLU_CHECK_GLW_CALL(m_gl, vertexAttribPointer(m_coordLocation, 2, GL_FLOAT, GL_FALSE, 0, DE_NULL));
1329         }
1330
1331         // Create dummy data for filling buffer objects
1332         const std::vector<tcu::Vec4> refValues(s_numBindings, tcu::Vec4(0.0f, 1.0f, 1.0f, 1.0f));
1333         glw::GLenum resType = (m_isUBO) ? GL_UNIFORM_BUFFER : GL_SHADER_STORAGE_BUFFER;
1334
1335         if (!m_isLocalArray)
1336         {
1337                 // Set up interface block of buffer bindings
1338                 GLU_CHECK_GLW_CALL(m_gl, genBuffers((glw::GLsizei)m_buffers.size(), &m_buffers[0]));
1339
1340                 for (int bufNdx = 0; bufNdx < (int)m_buffers.size(); ++bufNdx)
1341                 {
1342                         GLU_CHECK_GLW_CALL(m_gl, bindBuffer(resType, m_buffers[bufNdx]));
1343                         GLU_CHECK_GLW_CALL(m_gl, bufferData(resType, sizeof(tcu::Vec4), &(refValues[bufNdx]), GL_STATIC_DRAW));
1344                         GLU_CHECK_GLW_CALL(m_gl, bindBufferBase(resType, bufNdx, m_buffers[bufNdx]));
1345                 }
1346         }
1347 }
1348
1349 void ShadersOOB::draw (void)
1350 {
1351         if (m_shaderType == SHADERTYPE_COMPUTE)
1352                 m_gl.dispatchCompute(1, 1, 1);
1353         else
1354         {
1355                 const glw::GLuint indices[] = {0, 1, 2, 2, 3, 0};
1356                 m_gl.drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, indices);
1357         }
1358 }
1359
1360 void ShadersOOB::teardown (void)
1361 {
1362         if (m_shaderType != SHADERTYPE_COMPUTE)
1363         {
1364                 if (m_coordLocation)
1365                 {
1366                         GLU_CHECK_GLW_CALL(m_gl, disableVertexAttribArray(m_coordLocation));
1367                         m_coordLocation = 0;
1368                 }
1369         }
1370
1371         if (m_coordinatesBuffer)
1372         {
1373                 GLU_CHECK_GLW_CALL(m_gl, deleteBuffers(1, &m_coordinatesBuffer));
1374                 m_coordinatesBuffer = 0;
1375         }
1376
1377         if (!m_isLocalArray)
1378         {
1379                 if (!m_buffers.empty())
1380                 {
1381                         GLU_CHECK_GLW_CALL(m_gl, deleteBuffers((glw::GLsizei)m_buffers.size(), &m_buffers[0]));
1382                         m_buffers.clear();
1383                 }
1384         }
1385
1386         GLU_CHECK_GLW_CALL(m_gl, useProgram(0));
1387 }
1388
1389 class QueryRobustAccessCase : public RobustnessTestCase
1390 {
1391 public:
1392         QueryRobustAccessCase (EglTestContext& eglTestCtx, const char* name, const char* description)
1393                 : RobustnessTestCase (eglTestCtx, name, description) {}
1394
1395         TestCase::IterateResult iterate         (void)
1396         {
1397                 TestLog&        log             = m_testCtx.getLog();
1398
1399                 log << tcu::TestLog::Message
1400                         << "Check that after successfully creating a robust context the robust access query returned by glBooleanv() equals GL_TRUE\n\n"
1401                         << tcu::TestLog::EndMessage;
1402
1403                 const EGLint attribList[] =
1404                 {
1405                         EGL_CONTEXT_CLIENT_VERSION, 3,
1406                         EGL_CONTEXT_MINOR_VERSION_KHR, 0,
1407                         EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_TRUE,
1408                         EGL_NONE
1409                 };
1410
1411                 checkRequiredEGLExtensions(attribList);
1412
1413                 RenderingContext context(m_eglTestCtx, attribList, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT);
1414                 context.makeCurrent(m_eglSurface);
1415
1416                 glw::Functions gl;
1417                 {
1418                         const glu::ApiType apiType(3, 0, glu::PROFILE_ES);
1419                         context.initGLFunctions(&gl, apiType);
1420                         checkRequiredGLSupport(gl, apiType);
1421                 }
1422
1423                 deUint8 robustAccessGL;
1424                 gl.getBooleanv(GL_CONTEXT_ROBUST_ACCESS_EXT, &robustAccessGL);
1425                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv()");
1426
1427                 if (robustAccessGL != GL_TRUE)
1428                 {
1429                         log << TestLog::Message
1430                                 << "Invalid GL_CONTEXT_ROBUST_ACCESS returned by glGetBooleanv(). Got '" << robustAccessGL << "' expected GL_TRUE."
1431                                 << TestLog::EndMessage;
1432
1433                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1434                         return STOP;
1435                 }
1436
1437                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1438                 return STOP;
1439         }
1440 };
1441
1442 class NoResetNotificationCase : public RobustnessTestCase
1443 {
1444 public:
1445         NoResetNotificationCase (EglTestContext& eglTestCtx, const char* name, const char* description)
1446                 : RobustnessTestCase (eglTestCtx, name, description) {}
1447
1448         TestCase::IterateResult iterate         (void)
1449         {
1450                 TestLog&        log             = m_testCtx.getLog();
1451
1452                 log << tcu::TestLog::Message
1453                         << "Check the reset notification strategy returned by glGetIntegerv() equals GL_NO_RESET_NOTIFICATION\n\n"
1454                         << tcu::TestLog::EndMessage;
1455
1456                 const EGLint attribList[] =
1457                 {
1458                         EGL_CONTEXT_CLIENT_VERSION, 3,
1459                         EGL_CONTEXT_MINOR_VERSION_KHR, 0,
1460                         EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_TRUE,
1461                         EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_NO_RESET_NOTIFICATION,
1462                         EGL_NONE
1463                 };
1464
1465                 checkRequiredEGLExtensions(attribList);
1466
1467                 RenderingContext context(m_eglTestCtx, attribList, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT);
1468                 context.makeCurrent(m_eglSurface);
1469
1470                 glw::Functions gl;
1471                 {
1472                         const glu::ApiType apiType(3, 0, glu::PROFILE_ES);
1473                         context.initGLFunctions(&gl, apiType);
1474                         checkRequiredGLSupport(gl, apiType);
1475                 }
1476
1477                 deUint8 robustAccessGL;
1478                 gl.getBooleanv(GL_CONTEXT_ROBUST_ACCESS_EXT, &robustAccessGL);
1479                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv()");
1480
1481                 glw::GLint reset = 0;
1482                 gl.getIntegerv(GL_RESET_NOTIFICATION_STRATEGY, &reset);
1483                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()");
1484
1485                 if (reset != GL_NO_RESET_NOTIFICATION)
1486                 {
1487                         log     << tcu::TestLog::Message
1488                                 << "Test failed! glGetIntegerv() returned wrong value. [" << glu::getErrorStr(reset) << ", expected " << glu::getErrorStr(GL_NO_RESET_NOTIFICATION) << "]"
1489                                 << tcu::TestLog::EndMessage;
1490
1491                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1492                         return STOP;
1493                 }
1494
1495                 GLU_CHECK_GLW_CALL(gl, getGraphicsResetStatus());
1496
1497                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1498                 return STOP;
1499         }
1500 };
1501
1502 class LoseContextOnResetCase : public RobustnessTestCase
1503 {
1504 public:
1505         LoseContextOnResetCase (EglTestContext& eglTestCtx, const char* name, const char* description)
1506                 : RobustnessTestCase(eglTestCtx, name, description) {}
1507
1508         TestCase::IterateResult iterate         (void)
1509         {
1510                 TestLog&        log             = m_testCtx.getLog();
1511
1512                 log << tcu::TestLog::Message
1513                         << "Check the reset notification strategy returned by glGetIntegerv() equals GL_LOSE_CONTEXT_ON_RESET\n\n"
1514                         << tcu::TestLog::EndMessage;
1515
1516                 const EGLint attribList[] =
1517                 {
1518                         EGL_CONTEXT_CLIENT_VERSION, 3,
1519                         EGL_CONTEXT_MINOR_VERSION_KHR, 0,
1520                         EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_TRUE,
1521                         EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_LOSE_CONTEXT_ON_RESET,
1522                         EGL_NONE
1523                 };
1524
1525                 checkRequiredEGLExtensions(attribList);
1526
1527                 RenderingContext context(m_eglTestCtx, attribList, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT);
1528                 context.makeCurrent(m_eglSurface);
1529
1530                 glw::Functions gl;
1531                 {
1532                         const glu::ApiType apiType(3, 0, glu::PROFILE_ES);
1533                         context.initGLFunctions(&gl, apiType);
1534                         checkRequiredGLSupport(gl, apiType);
1535                 }
1536                 glw::GLint reset = 0;
1537                 gl.getIntegerv(GL_RESET_NOTIFICATION_STRATEGY, &reset);
1538                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()");
1539
1540                 if (reset != GL_LOSE_CONTEXT_ON_RESET)
1541                 {
1542                         log     << tcu::TestLog::Message
1543                                 << "Test failed! glGetIntegerv() returned wrong value. [" << reset << ", expected " << glu::getErrorStr(GL_LOSE_CONTEXT_ON_RESET) << "]"
1544                                 << tcu::TestLog::EndMessage;
1545
1546                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1547                         return STOP;
1548                 }
1549
1550                 log << tcu::TestLog::Message
1551                         << "Check the graphics reset status returned by glGetGraphicsResetStatus() "
1552                         << "equals GL_NO_ERROR\n"
1553                         << tcu::TestLog::EndMessage;
1554
1555                 GLU_CHECK_GLW_CALL(gl, getGraphicsResetStatus());
1556
1557                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1558                 return STOP;
1559         }
1560 };
1561
1562 de::SharedPtr<ContextReset> contextResetFactory (const RobustnessTestCase::Params params, glw::Functions& gl, tcu::TestLog& log)
1563 {
1564         if (params.getContextResetType() == CONTEXTRESETTYPE_INFINITE_LOOP)
1565                 return de::SharedPtr<ContextReset>(new InfiniteLoop(gl, log, params.getShaderType()));
1566
1567         if (params.getContextResetType() == CONTEXTRESETTYPE_FIXED_FUNC_OOB)
1568                 return de::SharedPtr<ContextReset>(new FixedFunctionOOB(gl, log, params.getFixedFunctionType()));
1569
1570         if (params.getContextResetType() == CONTEXTRESETTYPE_SHADER_OOB)
1571                 return de::SharedPtr<ContextReset>(new ShadersOOB(gl, log, params.getShaderType(), params.getResourceType(), params.getReadWriteType()));
1572         else
1573         {
1574                 DE_FATAL("Unknown context reset type");
1575                 return de::SharedPtr<ContextReset>(DE_NULL);
1576         }
1577 }
1578
1579 class ContextResetCase : public RobustnessTestCase
1580 {
1581
1582 public:
1583                                                         ContextResetCase                (EglTestContext& eglTestCtx, const char* name, const char* description, Params params);
1584         virtual                                 ~ContextResetCase               (void) {};
1585
1586         virtual void                    provokeReset                    (de::SharedPtr<ContextReset>& contextReset) = 0;
1587         virtual void                    waitForReset                    (de::SharedPtr<ContextReset>& contextReset) = 0;
1588         virtual void                    passAndLog                              (de::SharedPtr<ContextReset>& contextReset) = 0;
1589
1590         TestCase::IterateResult iterate                                 (void);
1591         void                                    execute                                 (glw::Functions& gl);
1592
1593 private:
1594                                                 ContextResetCase                        (const ContextResetCase&);
1595         ContextResetCase&       operator=                                       (const ContextResetCase&);
1596 };
1597
1598 ContextResetCase::ContextResetCase (EglTestContext& eglTestCtx, const char* name, const char* description, Params params)
1599         : RobustnessTestCase (eglTestCtx, name, description, params) {}
1600
1601 TestCase::IterateResult ContextResetCase::iterate (void)
1602 {
1603         glw::Functions  gl;
1604
1605         const EGLint attribList[] =
1606         {
1607                 EGL_CONTEXT_CLIENT_VERSION, 3,
1608                 EGL_CONTEXT_MINOR_VERSION_KHR, 0,
1609                 EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, (m_params.getRobustAccessType() == ROBUSTACCESS_TRUE) ? EGL_TRUE : EGL_FALSE,
1610                 EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_LOSE_CONTEXT_ON_RESET,
1611                 EGL_NONE
1612         };
1613
1614         checkRequiredEGLExtensions(attribList);
1615
1616         RenderingContext context(m_eglTestCtx, attribList, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT);
1617         context.makeCurrent(m_eglSurface);
1618
1619         {
1620                 const glu::ApiType apiType = paramsToApiType(m_params);
1621                 context.initGLFunctions(&gl, apiType);
1622                 checkGLSupportForParams(gl, m_params);
1623         }
1624
1625         execute(gl);
1626
1627         return STOP;
1628 }
1629
1630 void ContextResetCase::execute (glw::Functions& gl)
1631 {
1632         de::SharedPtr<ContextReset> contextReset                                        = contextResetFactory(m_params, gl, m_testCtx.getLog());
1633         glw::GLboolean                          isContextRobust                                 = GL_FALSE;
1634
1635         GLU_CHECK_GLW_CALL(gl, getBooleanv(GL_CONTEXT_ROBUST_ACCESS_EXT, &isContextRobust));
1636         provokeReset(contextReset);
1637
1638         if (m_params.getContextResetType() == CONTEXTRESETTYPE_INFINITE_LOOP)
1639         {
1640                 try
1641                 {
1642                         waitForReset(contextReset);
1643
1644                         const glw::GLenum       status  = gl.getGraphicsResetStatus();
1645
1646                         if (status == GL_NO_ERROR)
1647                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Context was NOT lost");
1648                         else
1649                         {
1650                                 m_testCtx.getLog() << tcu::TestLog::Message << "glGetGraphicsResetStatus() returned " << glu::getGraphicsResetStatusStr(status) << tcu::TestLog::EndMessage;
1651                                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Context was lost");
1652                         }
1653                 }
1654                 catch (const glu::Error& error)
1655                 {
1656                         if (error.getError() == GL_CONTEXT_LOST)
1657                                 passAndLog(contextReset);
1658                         else
1659                         {
1660                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1661
1662                                 m_testCtx.getLog()      << tcu::TestLog::Message
1663                                                                         << "Warning: glGetError() returned wrong value [" << error.what() << ", expected " << glu::getErrorStr(GL_CONTEXT_LOST) << "]"
1664                                                                         << tcu::TestLog::EndMessage;
1665                         }
1666                 }
1667         }
1668         else if (m_params.getContextResetType() == CONTEXTRESETTYPE_SHADER_OOB || m_params.getContextResetType() == CONTEXTRESETTYPE_FIXED_FUNC_OOB)
1669         {
1670                 try
1671                 {
1672                         waitForReset(contextReset);
1673                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Context was NOT lost. Test skipped");
1674                 }
1675                 catch (const glu::Error& error)
1676                 {
1677                         if (error.getError() == GL_CONTEXT_LOST)
1678                         {
1679                                 if (isContextRobust)
1680                                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "No context reset should of occurred GL_CONTEXT_ROBUST_ACCESS == TRUE");
1681                                 else
1682                                         passAndLog(contextReset);
1683                         }
1684                         else if (isContextRobust)
1685                                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got unknown error.");
1686                         else
1687                         {
1688                                 m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Warning: glGetError() returned wrong value. Expected GL_CONTEXT_LOST");
1689
1690                                 m_testCtx.getLog()      << tcu::TestLog::Message
1691                                                                         << "Warning: glGetError() returned wrong value [" << error.what() << ", expected " << glu::getErrorStr(GL_CONTEXT_LOST) << "]"
1692                                                                         << tcu::TestLog::EndMessage;
1693                         }
1694                 }
1695         }
1696         else
1697                 DE_FATAL("Unknown context reset type");
1698 }
1699
1700 class BasicResetCase : public ContextResetCase
1701 {
1702 public:
1703
1704         BasicResetCase (EglTestContext& eglTestCtx, const char* name, const char* description, Params params)
1705                 : ContextResetCase (eglTestCtx, name, description, params) {}
1706
1707         virtual void provokeReset (de::SharedPtr<ContextReset>& contextReset)
1708         {
1709                 m_testCtx.getLog()      << tcu::TestLog::Message
1710                                                         << "Check the graphics reset status returned by glGetGraphicsResetStatus() equals "
1711                                                         << "GL_GUILTY_CONTEXT_RESET after a context reset\n\n"
1712                                                         << tcu::TestLog::EndMessage;
1713
1714                 contextReset->setup();
1715                 contextReset->draw();
1716         }
1717
1718         virtual void waitForReset (de::SharedPtr<ContextReset>& contextReset)
1719         {
1720                 contextReset->teardown();
1721                 contextReset->finish();
1722         }
1723
1724         virtual void passAndLog (de::SharedPtr<ContextReset>& contextReset)
1725         {
1726                 const glw::GLint status = contextReset->getGraphicsResetStatus();
1727
1728                 if (status == GL_NO_ERROR)
1729                 {
1730                         m_testCtx.getLog()      << tcu::TestLog::Message
1731                                                                 << "Test failed! glGetGraphicsResetStatus() returned wrong value [" << glu::getGraphicsResetStatusStr(status) << ", expected " << glu::getGraphicsResetStatusStr(GL_GUILTY_CONTEXT_RESET) << "]"
1732                                                                 << tcu::TestLog::EndMessage;
1733
1734                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1735                 }
1736                 else
1737                 {
1738                         if (contextReset->getError() != GL_NO_ERROR)
1739                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Error flag not reset after calling getGraphicsResetStatus()");
1740                         else
1741                                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1742                 }
1743         }
1744 };
1745
1746 class SyncObjectResetCase : public ContextResetCase
1747 {
1748 public:
1749         SyncObjectResetCase (EglTestContext& eglTestCtx, const char* name, const char* description, Params params)
1750                 : ContextResetCase (eglTestCtx, name, description, params) {}
1751
1752         virtual void provokeReset (de::SharedPtr<ContextReset>& contextReset)
1753         {
1754                 m_testCtx.getLog()      << tcu::TestLog::Message
1755                                                         << "Check the status of a sync object after a context reset returned by glGetSynciv() equals GL_SIGNALED\n\n"
1756                                                         << tcu::TestLog::EndMessage;
1757
1758                 contextReset->setup();
1759                 contextReset->draw();
1760         }
1761
1762         virtual void waitForReset (de::SharedPtr<ContextReset>& contextReset)
1763         {
1764                 contextReset->createSyncObject();
1765                 contextReset->teardown();
1766                 contextReset->finish();
1767         }
1768
1769         virtual void passAndLog (de::SharedPtr<ContextReset>& contextReset)
1770         {
1771                 const glw::GLint status = contextReset->getSyncStatus();
1772                 if (status != GL_SIGNALED)
1773                 {
1774                         m_testCtx.getLog()      << tcu::TestLog::Message
1775                                                                 << "Test failed! glGetSynciv() returned wrong value [" << glu::getErrorStr(status) << ", expected " << glu::getErrorStr(GL_SIGNALED) << "]"
1776                                                                 << tcu::TestLog::EndMessage;
1777
1778                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1779                 }
1780                 else
1781                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1782         }
1783 };
1784
1785 class QueryObjectResetCase : public ContextResetCase
1786 {
1787 public:
1788         QueryObjectResetCase (EglTestContext& eglTestCtx, const char* name, const char* description, Params params)
1789                 : ContextResetCase (eglTestCtx, name, description, params) {}
1790
1791         virtual void provokeReset (de::SharedPtr<ContextReset>& contextReset)
1792         {
1793                 m_testCtx.getLog()      << tcu::TestLog::Message
1794                                                         << "Check the status of a query object after a context reset returned by glGetQueryObjectuiv() equals GL_TRUE\n\n"
1795                                                         << tcu::TestLog::EndMessage;
1796
1797                 contextReset->setup();
1798                 contextReset->beginQuery();
1799                 contextReset->draw();
1800         }
1801
1802         virtual void waitForReset (de::SharedPtr<ContextReset>& contextReset)
1803         {
1804                 contextReset->endQuery();
1805                 contextReset->teardown();
1806                 contextReset->finish();
1807         }
1808
1809         virtual void passAndLog (de::SharedPtr<ContextReset>& contextReset)
1810         {
1811                 const glw::GLuint queryReady = contextReset->getQueryAvailability();
1812                 if (queryReady != GL_TRUE)
1813                 {
1814                         m_testCtx.getLog()      << tcu::TestLog::Message
1815                                                                 << "Test failed! glGetQueryObjectuiv() returned wrong value [" << glu::getErrorStr(queryReady) << ", expected " << glu::getErrorStr(GL_TRUE) << "]"
1816                                                                 << tcu::TestLog::EndMessage;
1817
1818                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1819                 }
1820                 else
1821                 {
1822                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1823                 }
1824         }
1825 };
1826
1827 class InvalidShareContextCase : public RobustnessTestCase
1828 {
1829 public:
1830         InvalidShareContextCase (EglTestContext& eglTestCtx, const char* name, const char* description)
1831                 : RobustnessTestCase (eglTestCtx, name, description) {}
1832
1833         TestCase::IterateResult iterate (void)
1834         {
1835                 TestLog&                log             =       m_testCtx.getLog();
1836                 const Library&  egl             =       m_eglTestCtx.getLibrary();
1837                 bool                    isOk    =       true;
1838
1839                 log << tcu::TestLog::Message
1840                         << "EGL_BAD_MATCH is generated if reset notification strategies do not match when creating shared contexts\n\n"
1841                         << tcu::TestLog::EndMessage;
1842
1843                 const EGLint attribListA[] =
1844                 {
1845                         EGL_CONTEXT_CLIENT_VERSION, 3,
1846                         EGL_CONTEXT_MINOR_VERSION_KHR, 0,
1847                         EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_TRUE,
1848                         EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_NO_RESET_NOTIFICATION,
1849                         EGL_NONE
1850                 };
1851
1852                 const EGLint attribListB[] =
1853                 {
1854                         EGL_CONTEXT_CLIENT_VERSION, 3,
1855                         EGL_CONTEXT_MINOR_VERSION_KHR, 0,
1856                         EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_TRUE,
1857                         EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_LOSE_CONTEXT_ON_RESET,
1858                         EGL_NONE
1859                 };
1860
1861                 checkRequiredEGLExtensions(attribListA);
1862
1863                 log << tcu::TestLog::Message << "Create context A (share_context = EGL_NO_CONTEXT)" << tcu::TestLog::EndMessage;
1864                 RenderingContext contextA(m_eglTestCtx, attribListA, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT);
1865
1866                 log << tcu::TestLog::Message << "Create context B (share_context = context A)" << tcu::TestLog::EndMessage;
1867                 logAttribList(m_eglTestCtx, attribListB);
1868
1869                 EGLContext contextB = egl.createContext(m_eglDisplay, m_eglConfig, contextA.getContext(), attribListB);
1870
1871                 const EGLenum error = egl.getError();
1872                 if (error != EGL_BAD_MATCH)
1873                 {
1874                         log << TestLog::Message
1875                                 << "Test failed! eglCreateContext() returned with error [" << eglu::getErrorStr(error) << ", expected " << eglu::getErrorStr(EGL_BAD_MATCH) << "]"
1876                                 << TestLog::EndMessage;
1877
1878                         isOk = false;
1879                 }
1880
1881                 if (contextB != EGL_NO_CONTEXT)
1882                         egl.destroyContext(m_eglDisplay, contextB);
1883
1884                 if (isOk)
1885                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1886                 else
1887                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1888
1889                 return STOP;
1890         }
1891 };
1892
1893 class SharedContextResetCase : public RobustnessTestCase
1894 {
1895 public:
1896         SharedContextResetCase (EglTestContext& eglTestCtx, const char* name, const char* description, Params params)
1897                 : RobustnessTestCase (eglTestCtx, name, description, params) {}
1898
1899         TestCase::IterateResult iterate (void)
1900         {
1901                 TestLog&        log             = m_testCtx.getLog();
1902
1903                 log << tcu::TestLog::Message
1904                         << "A reset in one context will result in a reset in all other contexts in its share group\n\n"
1905                         << tcu::TestLog::EndMessage;
1906
1907                 // Create two share contexts with the same reset notification strategies
1908                 const EGLint attribListShared[] =
1909                 {
1910                         EGL_CONTEXT_CLIENT_VERSION, 3,
1911                         EGL_CONTEXT_MINOR_VERSION_KHR, 0,
1912                         EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_TRUE,
1913                         EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_LOSE_CONTEXT_ON_RESET,
1914                         EGL_NONE
1915                 };
1916
1917                 checkRequiredEGLExtensions(attribListShared);
1918
1919                 log << tcu::TestLog::Message << "Create context A (share_context = EGL_NO_CONTEXT)" << tcu::TestLog::EndMessage;
1920                 RenderingContext contextA(m_eglTestCtx, attribListShared, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT);
1921
1922                 log << tcu::TestLog::Message << "Create context B (share_context = context A)" << tcu::TestLog::EndMessage;
1923                 RenderingContext contextB(m_eglTestCtx, attribListShared, m_eglConfig, m_eglDisplay, contextA.getContext());
1924
1925                 contextA.makeCurrent(m_eglSurface);
1926
1927                 glw::Functions gl;
1928                 contextA.initGLFunctions(&gl, paramsToApiType(m_params));
1929                 checkGLSupportForParams(gl, m_params);
1930
1931                 DE_ASSERT(m_params.getContextResetType() == CONTEXTRESETTYPE_INFINITE_LOOP);
1932                 de::UniquePtr<ContextReset> contextReset(new InfiniteLoop(gl, log, m_params.getShaderType()));
1933
1934                 contextReset->setup();
1935                 contextReset->draw();
1936
1937                 try
1938                 {
1939                         contextReset->teardown();
1940                         contextReset->finish();
1941                 }
1942                 catch (const glu::Error& error)
1943                 {
1944                         if (error.getError() == GL_CONTEXT_LOST)
1945                         {
1946                                 contextB.makeCurrent(m_eglSurface);
1947
1948                                 gl.getString(GL_VERSION); // arbitrary gl call
1949
1950                                 if (gl.getError() != GL_CONTEXT_LOST)
1951                                 {
1952                                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Test failed! glGetError() returned wrong value. Expected GL_CONTEXT_LOST in context B");
1953                                         return STOP;
1954                                 }
1955                         }
1956                         else
1957                         {
1958                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Test failed! glGetError() returned wrong value. Expected GL_CONTEXT_LOST in context A");
1959                                 return STOP;
1960                         }
1961                 }
1962
1963                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1964                 return STOP;
1965         }
1966 };
1967
1968 class InvalidContextCase : public RobustnessTestCase
1969 {
1970 public:
1971         InvalidContextCase (EglTestContext& eglTestCtx, const char* name, const char* description)
1972                 : RobustnessTestCase (eglTestCtx, name, description) {}
1973
1974         TestCase::IterateResult iterate (void)
1975         {
1976                 const Library&  egl             = m_eglTestCtx.getLibrary();
1977                 TestLog&                log             = m_testCtx.getLog();
1978                 bool                    isOk    = true;
1979
1980                 log << tcu::TestLog::Message
1981                         << "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"
1982                         << tcu::TestLog::EndMessage;
1983
1984                 const EGLint attribList[] =
1985                 {
1986                         EGL_CONTEXT_CLIENT_VERSION, 3,
1987                         EGL_CONTEXT_MINOR_VERSION_KHR, 0,
1988                         EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_LOSE_CONTEXT_ON_RESET,
1989                         EGL_NONE
1990                 };
1991
1992                 if (eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_create_context_robustness"))
1993                 {
1994                         m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Test requires EGL_EXT_create_context_robustness to be unsupported");
1995                         return STOP;
1996                 }
1997
1998                 logAttribList(m_eglTestCtx, attribList);
1999                 EGLContext context = egl.createContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, attribList);
2000
2001                 const EGLenum error = egl.getError();
2002                 if (error != EGL_BAD_ATTRIBUTE)
2003                 {
2004                         log << TestLog::Message
2005                                 << "Test failed! eglCreateContext() returned with error [" << eglu::getErrorStr(error) << ", expected " << eglu::getErrorStr(EGL_BAD_ATTRIBUTE) << "]"
2006                                 << TestLog::EndMessage;
2007
2008                         isOk = false;
2009                 }
2010
2011                 if (context != EGL_NO_CONTEXT)
2012                         egl.destroyContext(m_eglDisplay, context);
2013
2014                 if (isOk)
2015                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2016                 else
2017                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
2018
2019                 return STOP;
2020         }
2021 };
2022
2023 class RecoverFromResetCase : public RobustnessTestCase
2024 {
2025 public:
2026         RecoverFromResetCase (EglTestContext& eglTestCtx, const char* name, const char* description, Params params)
2027                 : RobustnessTestCase (eglTestCtx, name, description,  params) {}
2028
2029         TestCase::IterateResult iterate (void)
2030         {
2031                 TestLog&        log             = m_testCtx.getLog();
2032
2033                 log << tcu::TestLog::Message
2034                         << "Provoke a context reset and wait for glGetGraphicsResetStatus() to return NO_ERROR_KHR.\n"
2035                         << "Destroy the old context and successfully create a new context.\n\n"
2036                         << tcu::TestLog::EndMessage;
2037
2038                 const EGLint attribList[] =
2039                 {
2040                         EGL_CONTEXT_CLIENT_VERSION, 3,
2041                         EGL_CONTEXT_MINOR_VERSION_KHR, 0,
2042                         EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_TRUE,
2043                         EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_LOSE_CONTEXT_ON_RESET,
2044                         EGL_NONE
2045                 };
2046
2047                 checkRequiredEGLExtensions(attribList);
2048
2049                 log << tcu::TestLog::Message << "Create context A" << tcu::TestLog::EndMessage;
2050                 RenderingContext contextA(m_eglTestCtx, attribList, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT);
2051                 contextA.makeCurrent(m_eglSurface);
2052
2053                 glw::Functions gl;
2054                 contextA.initGLFunctions(&gl, paramsToApiType(m_params));
2055                 checkGLSupportForParams(gl, m_params);
2056
2057                 DE_ASSERT(m_params.getContextResetType() == CONTEXTRESETTYPE_INFINITE_LOOP);
2058                 de::UniquePtr<ContextReset> contextReset(new InfiniteLoop(gl, log, m_params.getShaderType()));
2059
2060                 contextReset->setup();
2061                 contextReset->draw();
2062
2063                 try
2064                 {
2065                         contextReset->teardown();
2066                         contextReset->finish();
2067                 }
2068                 catch (const glu::Error& error)
2069                 {
2070                         if (error.getError() == GL_CONTEXT_LOST)
2071                         {
2072                                 const glw::GLint status = gl.getGraphicsResetStatus();
2073                                 if (status == GL_NO_ERROR)
2074                                 {
2075                                         log << tcu::TestLog::Message
2076                                                 << "Test failed! glGetGraphicsResetStatus() returned wrong value [" << glu::getErrorStr(status) << ", expected " << glu::getErrorStr(GL_GUILTY_CONTEXT_RESET) << "]"
2077                                                 << tcu::TestLog::EndMessage;
2078
2079                                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
2080                                         return STOP;
2081                                 }
2082
2083                                 const int       sleepTimeMs             = 1000;                         // (1 second)
2084                                 int                     timeout                 = sleepTimeMs * 10; // (10 seconds)
2085                                 int                     reset_status    = -1;
2086
2087                                 // wait for context to reset
2088                                 while ((reset_status = gl.getGraphicsResetStatus() != GL_NO_ERROR) && timeout > 0)
2089                                 {
2090                                         deSleep(sleepTimeMs);
2091                                         timeout -= sleepTimeMs;
2092                                 }
2093
2094                                 if (reset_status != GL_NO_ERROR)
2095                                 {
2096                                         log     << tcu::TestLog::Message
2097                                                 << "Test failed! Context did not reset. glGetGraphicsResetStatus() returned wrong value [" << glu::getErrorStr(reset_status) << ", expected " << glu::getErrorStr(GL_NO_ERROR) << "]"
2098                                                 << tcu::TestLog::EndMessage;
2099
2100                                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
2101                                         return STOP;
2102                                 }
2103                         }
2104                         else
2105                         {
2106                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Test failed! glGetError() returned wrong value. Expected GL_CONTEXT_LOST in context A");
2107                                 return STOP;
2108                         }
2109                 }
2110
2111                 try
2112                 {
2113                         log << tcu::TestLog::Message << "Create context B" << tcu::TestLog::EndMessage;
2114                         RenderingContext contextB(m_eglTestCtx, attribList, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT);
2115                 }
2116                 catch (const glu::Error&)
2117                 {
2118                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Test failed! Could not create new context. glGetError() returned wrong value. Expected GL_NO_ERROR");
2119                         return STOP;
2120                 }
2121
2122                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2123                 return STOP;
2124         }
2125 };
2126
2127 } // anonymous
2128
2129 // Note: Tests limited to openGLES 3.1 contexts only
2130 TestCaseGroup* createRobustnessTests (EglTestContext& eglTestCtx)
2131 {
2132         de::MovePtr<TestCaseGroup> group (new TestCaseGroup(eglTestCtx, "robustness", "KHR_robustness tests"));
2133
2134         tcu::TestCaseGroup* const contextCreationTestGroup                      = new TestCaseGroup(eglTestCtx, "create_context",                                               "Test valid context_creation attributes");
2135         tcu::TestCaseGroup* const contextResetTestGroup                         = new TestCaseGroup(eglTestCtx, "reset_context",                                                "Test context resets scenarios");
2136         tcu::TestCaseGroup* const negativeContextTestGroup                      = new TestCaseGroup(eglTestCtx, "negative_context",                                             "Test invalid context creation attributes");
2137
2138         tcu::TestCaseGroup* const shadersTestGroup                                      = new TestCaseGroup(eglTestCtx, "shaders",                                                              "Shader specific context reset tests");
2139         tcu::TestCaseGroup* const fixedFunctionTestGroup                        = new TestCaseGroup(eglTestCtx, "fixed_function_pipeline",                              "Fixed function pipeline context reset tests with robust context");
2140         tcu::TestCaseGroup* const fixedFunctionNonRobustTestGroup       = new TestCaseGroup(eglTestCtx, "fixed_function_pipeline_non_robust",   "Fixed function pipeline context reset tests with non-robust context");
2141
2142         tcu::TestCaseGroup* const infiniteLoopTestGroup                         = new TestCaseGroup(eglTestCtx, "infinite_loop",                                                "Infinite loop scenarios");
2143         tcu::TestCaseGroup* const outOfBoundsTestGroup                          = new TestCaseGroup(eglTestCtx, "out_of_bounds",                                                "Out of bounds access scenarios with robust context");
2144
2145         tcu::TestCaseGroup* const outOfBoundsNonRobustTestGroup         = new TestCaseGroup(eglTestCtx, "out_of_bounds_non_robust",                             "Out of bounds access scenarios with non-robust context");
2146
2147         const string resetScenarioDescription   = "query error states and reset notifications";
2148         const string syncScenarioDescription    = "query sync status with getSynciv()";
2149         const string queryScenarioDescription   = "check availability of query result with getQueryObjectiv()";
2150         const string sharedScenarioDescription  = "check reset notification is propagated to shared context";
2151         const string recoverScenarioDescription = "delete the old context and create a new one";
2152
2153         // infinite loop test cases
2154         {
2155                 tcu::TestCaseGroup* const infiniteLoopResetTestGroup    = new TestCaseGroup(eglTestCtx, "reset_status",                         "Tests that query the reset status after a context reset has occurred");
2156                 tcu::TestCaseGroup* const infiniteLoopSyncTestGroup             = new TestCaseGroup(eglTestCtx, "sync_status",                          "Tests that query the sync status after a context reset has occurred");
2157                 tcu::TestCaseGroup* const infiniteLoopQueryTestGroup    = new TestCaseGroup(eglTestCtx, "query_status",                         "Tests that query the state of a query object after a context reset has occurred");
2158                 tcu::TestCaseGroup* const infiniteLoopSharedTestGroup   = new TestCaseGroup(eglTestCtx, "shared_context_status",        "Tests that query the state of a shared context after a reset has occurred");
2159                 tcu::TestCaseGroup* const infiniteLoopRecoverTestGroup  = new TestCaseGroup(eglTestCtx, "recover_from_reset",           "Tests that attempt to create a new context after a context has occurred");
2160
2161                 static const RobustnessTestCase::Params s_infiniteLoopCases[] =
2162                 {
2163                         RobustnessTestCase::Params("vertex",                            "Provoke a context reset in vertex shader and ",                                CONTEXTRESETTYPE_INFINITE_LOOP, SHADERTYPE_VERT),
2164                         RobustnessTestCase::Params("fragment",                          "Provoke a context reset in fragment shader and ",                              CONTEXTRESETTYPE_INFINITE_LOOP, SHADERTYPE_FRAG),
2165                         RobustnessTestCase::Params("vertex_and_fragment",       "Provoke a context reset in vertex and fragment shader and ",   CONTEXTRESETTYPE_INFINITE_LOOP, SHADERTYPE_VERT_AND_FRAG),
2166                         RobustnessTestCase::Params("compute",                           "Provoke a context reset in compute shader and ",                               CONTEXTRESETTYPE_INFINITE_LOOP, SHADERTYPE_COMPUTE),
2167                 };
2168
2169                 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(s_infiniteLoopCases); ++testNdx)
2170                 {
2171                         const RobustnessTestCase::Params& test = s_infiniteLoopCases[testNdx];
2172                         infiniteLoopResetTestGroup->addChild    (new BasicResetCase                             (eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test));
2173                         infiniteLoopSyncTestGroup->addChild             (new SyncObjectResetCase                (eglTestCtx, test.getName().c_str(), (test.getDescription() + syncScenarioDescription).c_str(), test));
2174                         infiniteLoopQueryTestGroup->addChild    (new QueryObjectResetCase               (eglTestCtx, test.getName().c_str(), (test.getDescription() + queryScenarioDescription).c_str(), test));
2175                         infiniteLoopSharedTestGroup->addChild   (new SharedContextResetCase             (eglTestCtx, test.getName().c_str(), (test.getDescription() + sharedScenarioDescription).c_str(), test));
2176                         infiniteLoopRecoverTestGroup->addChild  (new RecoverFromResetCase               (eglTestCtx, test.getName().c_str(), (test.getDescription() + recoverScenarioDescription).c_str(), test));
2177                 }
2178
2179                 infiniteLoopTestGroup->addChild(infiniteLoopResetTestGroup);
2180                 infiniteLoopTestGroup->addChild(infiniteLoopSyncTestGroup);
2181                 infiniteLoopTestGroup->addChild(infiniteLoopQueryTestGroup);
2182                 infiniteLoopTestGroup->addChild(infiniteLoopSharedTestGroup);
2183                 infiniteLoopTestGroup->addChild(infiniteLoopRecoverTestGroup);
2184         }
2185
2186         // out-of-bounds test cases
2187         {
2188                 // robust context
2189                 tcu::TestCaseGroup* const uboReadArrayResetTestGroup    = new TestCaseGroup(eglTestCtx, "uniform_block",                "Uniform Block Accesses");
2190                 tcu::TestCaseGroup* const uboWriteArrayResetTestGroup   = new TestCaseGroup(eglTestCtx, "uniform_block",                "Uniform Block Accesses");
2191                 tcu::TestCaseGroup* const ssboWriteArrayResetTestGroup  = new TestCaseGroup(eglTestCtx, "shader_storage_block", "Shader Storage Block accesses");
2192                 tcu::TestCaseGroup* const ssboReadArrayResetTestGroup   = new TestCaseGroup(eglTestCtx, "shader_storage_block", "Shader Storage Block accesses");
2193                 tcu::TestCaseGroup* const localWriteArrayResetTestGroup = new TestCaseGroup(eglTestCtx, "local_array",                  "Local array accesses");
2194                 tcu::TestCaseGroup* const localReadArrayResetTestGroup  = new TestCaseGroup(eglTestCtx, "local_array",                  "Local array accesses");
2195
2196                 // non-robust context (internal use only)
2197                 tcu::TestCaseGroup* const uboReadArrayResetNonRobustTestGroup           = new TestCaseGroup(eglTestCtx, "uniform_block",                "Uniform Block Accesses");
2198                 tcu::TestCaseGroup* const uboWriteArrayResetNonRobustTestGroup          = new TestCaseGroup(eglTestCtx, "uniform_block",                "Uniform Block Accesses");
2199                 tcu::TestCaseGroup* const ssboWriteArrayResetNonRobustTestGroup         = new TestCaseGroup(eglTestCtx, "shader_storage_block", "Shader Storage Block accesses");
2200                 tcu::TestCaseGroup* const ssboReadArrayResetNonRobustTestGroup          = new TestCaseGroup(eglTestCtx, "shader_storage_block", "Shader Storage Block accesses");
2201                 tcu::TestCaseGroup* const localWriteArrayResetNonRobustTestGroup        = new TestCaseGroup(eglTestCtx, "local_array",                  "Local array accesses");
2202                 tcu::TestCaseGroup* const localReadArrayResetNonRobustTestGroup         = new TestCaseGroup(eglTestCtx, "local_array",                  "Local array accesses");
2203
2204                 static const RobustnessTestCase::Params s_outOfBoundReadCases[] =
2205                 {
2206                         // ubo read only
2207                         RobustnessTestCase::Params ("vertex",                           "Provoke a context reset in vertex shader and ",                                ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT,                        RESOURCETYPE_UBO, READWRITETYPE_READ),
2208                         RobustnessTestCase::Params ("fragment",                         "Provoke a context reset in fragment shader and ",                              ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG,                        RESOURCETYPE_UBO, READWRITETYPE_READ),
2209                         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),
2210                         RobustnessTestCase::Params ("compute",                          "Provoke a context reset in compute shader and ",                               ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE,                     RESOURCETYPE_UBO, READWRITETYPE_READ),
2211
2212                         // ssbo read only
2213                         RobustnessTestCase::Params ("vertex",                           "Provoke a context reset in vertex shader and ",                                ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT,                        RESOURCETYPE_SSBO, READWRITETYPE_READ),
2214                         RobustnessTestCase::Params ("fragment",                         "Provoke a context reset in fragment shader and ",                              ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG,                        RESOURCETYPE_SSBO, READWRITETYPE_READ),
2215                         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),
2216                         RobustnessTestCase::Params ("compute",                          "Provoke a context reset in compute shader and ",                               ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE,                     RESOURCETYPE_SSBO, READWRITETYPE_READ),
2217
2218                         // local array read only
2219                         RobustnessTestCase::Params ("vertex",                           "Provoke a context reset in vertex shader and ",                                ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT,                        RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_READ),
2220                         RobustnessTestCase::Params ("fragment",                         "Provoke a context reset in fragment shader and ",                              ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG,                        RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_READ),
2221                         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),
2222                         RobustnessTestCase::Params ("compute",                          "Provoke a context reset in compute shader and ",                               ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE,                     RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_READ),
2223
2224                         // ubo read only (non-robust)
2225                         RobustnessTestCase::Params ("vertex",                           "Provoke a context reset in vertex shader and ",                                ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT,                       RESOURCETYPE_UBO, READWRITETYPE_READ),
2226                         RobustnessTestCase::Params ("fragment",                         "Provoke a context reset in fragment shader and ",                              ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG,                       RESOURCETYPE_UBO, READWRITETYPE_READ),
2227                         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),
2228                         RobustnessTestCase::Params ("compute",                          "Provoke a context reset in compute shader and ",                               ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE,            RESOURCETYPE_UBO, READWRITETYPE_READ),
2229
2230                         // ssbo read only (non-robust)
2231                         RobustnessTestCase::Params ("vertex",                           "Provoke a context reset in vertex shader and ",                                ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT,                       RESOURCETYPE_SSBO, READWRITETYPE_READ),
2232                         RobustnessTestCase::Params ("fragment",                         "Provoke a context reset in fragment shader and ",                              ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG,                       RESOURCETYPE_SSBO, READWRITETYPE_READ),
2233                         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),
2234                         RobustnessTestCase::Params ("compute",                          "Provoke a context reset in compute shader and ",                               ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE,            RESOURCETYPE_SSBO, READWRITETYPE_READ),
2235
2236                         // local array read only (non-robust)
2237                         RobustnessTestCase::Params ("vertex",                           "Provoke a context reset in vertex shader and ",                                ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT,                       RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_READ),
2238                         RobustnessTestCase::Params ("fragment",                         "Provoke a context reset in fragment shader and ",                              ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG,                       RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_READ),
2239                         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),
2240                         RobustnessTestCase::Params ("compute",                          "Provoke a context reset in compute shader and ",                               ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE,            RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_READ),
2241                 };
2242
2243                 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(s_outOfBoundReadCases); ++testNdx)
2244                 {
2245                         const RobustnessTestCase::Params& test = s_outOfBoundReadCases[testNdx];
2246
2247                         if (test.getResourceType() == RESOURCETYPE_UBO && test.getRobustAccessType() == ROBUSTACCESS_TRUE)
2248                                 uboReadArrayResetTestGroup->addChild                            (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test));
2249
2250                         if (test.getResourceType() == RESOURCETYPE_UBO && test.getRobustAccessType() == ROBUSTACCESS_FALSE)
2251                                 uboReadArrayResetNonRobustTestGroup->addChild           (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test));
2252
2253                         if (test.getResourceType() == RESOURCETYPE_SSBO && test.getRobustAccessType() == ROBUSTACCESS_TRUE)
2254                                 ssboReadArrayResetTestGroup->addChild                           (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test));
2255
2256                         if (test.getResourceType() == RESOURCETYPE_SSBO && test.getRobustAccessType() == ROBUSTACCESS_FALSE)
2257                                 ssboReadArrayResetNonRobustTestGroup->addChild          (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test));
2258
2259                         if (test.getResourceType() == RESOURCETYPE_LOCAL_ARRAY && test.getRobustAccessType() == ROBUSTACCESS_TRUE)
2260                                 localReadArrayResetTestGroup->addChild                          (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test));
2261
2262                         if (test.getResourceType() == RESOURCETYPE_LOCAL_ARRAY && test.getRobustAccessType() == ROBUSTACCESS_FALSE)
2263                                 localReadArrayResetNonRobustTestGroup->addChild         (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test));
2264                 }
2265
2266                 static const RobustnessTestCase::Params s_outOfBoundWriteCases[] =
2267                 {
2268                         // ubo write only
2269                         RobustnessTestCase::Params ("vertex",                           "Provoke a context reset in vertex shader and ",                                ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT,                        RESOURCETYPE_UBO, READWRITETYPE_WRITE),
2270                         RobustnessTestCase::Params ("fragment",                         "Provoke a context reset in fragment shader and ",                              ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG,                        RESOURCETYPE_UBO, READWRITETYPE_WRITE),
2271                         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),
2272                         RobustnessTestCase::Params ("compute",                          "Provoke a context reset in compute shader and ",                               ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE,                     RESOURCETYPE_UBO, READWRITETYPE_WRITE),
2273
2274                         // ssbo write only
2275                         RobustnessTestCase::Params ("vertex",                           "Provoke a context reset in vertex shader and ",                                ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT,                        RESOURCETYPE_SSBO, READWRITETYPE_WRITE),
2276                         RobustnessTestCase::Params ("fragment",                         "Provoke a context reset in fragment shader and ",                              ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG,                        RESOURCETYPE_SSBO, READWRITETYPE_WRITE),
2277                         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),
2278                         RobustnessTestCase::Params ("compute",                          "Provoke a context reset in compute shader and ",                               ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE,                     RESOURCETYPE_SSBO, READWRITETYPE_WRITE),
2279
2280                         // local array write only
2281                         RobustnessTestCase::Params ("vertex",                           "Provoke a context reset in vertex shader and ",                                ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT,                        RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_WRITE),
2282                         RobustnessTestCase::Params ("fragment",                         "Provoke a context reset in fragment shader and ",                              ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG,                        RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_WRITE),
2283                         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),
2284                         RobustnessTestCase::Params ("compute",                          "Provoke a context reset in compute shader and ",                               ROBUSTACCESS_TRUE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE,                     RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_WRITE),
2285
2286                         // ubo write only (non-robust)
2287                         RobustnessTestCase::Params ("vertex",                           "Provoke a context reset in vertex shader and ",                                ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT,                       RESOURCETYPE_UBO, READWRITETYPE_WRITE),
2288                         RobustnessTestCase::Params ("fragment",                         "Provoke a context reset in fragment shader and ",                              ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG,                       RESOURCETYPE_UBO, READWRITETYPE_WRITE),
2289                         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),
2290                         RobustnessTestCase::Params ("compute",                          "Provoke a context reset in compute shader and ",                               ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE,            RESOURCETYPE_UBO, READWRITETYPE_WRITE),
2291
2292                         // ssbo write only (non-robust)
2293                         RobustnessTestCase::Params ("vertex",                           "Provoke a context reset in vertex shader and ",                                ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT,                       RESOURCETYPE_SSBO, READWRITETYPE_WRITE),
2294                         RobustnessTestCase::Params ("fragment",                         "Provoke a context reset in fragment shader and ",                              ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG,                       RESOURCETYPE_SSBO, READWRITETYPE_WRITE),
2295                         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),
2296                         RobustnessTestCase::Params ("compute",                          "Provoke a context reset in compute shader and ",                               ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE,            RESOURCETYPE_SSBO, READWRITETYPE_WRITE),
2297
2298                         // local array write only (non-robust)
2299                         RobustnessTestCase::Params ("vertex",                           "Provoke a context reset in vertex shader and ",                                ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT,                       RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_WRITE),
2300                         RobustnessTestCase::Params ("fragment",                         "Provoke a context reset in fragment shader and ",                              ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG,                       RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_WRITE),
2301                         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),
2302                         RobustnessTestCase::Params ("compute",                          "Provoke a context reset in compute shader and ",                               ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE,            RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_WRITE),
2303                 };
2304
2305                 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(s_outOfBoundWriteCases); ++testNdx)
2306                 {
2307                         const RobustnessTestCase::Params& test = s_outOfBoundWriteCases[testNdx];
2308
2309                                 if (test.getResourceType() == RESOURCETYPE_UBO && test.getRobustAccessType() == ROBUSTACCESS_TRUE)
2310                                         uboWriteArrayResetTestGroup->addChild                           (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test));
2311
2312                                 if (test.getResourceType() == RESOURCETYPE_UBO && test.getRobustAccessType() == ROBUSTACCESS_FALSE)
2313                                         uboWriteArrayResetNonRobustTestGroup->addChild          (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test));
2314
2315                                 if (test.getResourceType() == RESOURCETYPE_SSBO && test.getRobustAccessType() == ROBUSTACCESS_TRUE)
2316                                         ssboWriteArrayResetTestGroup->addChild                          (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test));
2317
2318                                 if (test.getResourceType() == RESOURCETYPE_SSBO && test.getRobustAccessType() == ROBUSTACCESS_FALSE)
2319                                         ssboWriteArrayResetNonRobustTestGroup->addChild         (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test));
2320
2321                                 if (test.getResourceType() == RESOURCETYPE_LOCAL_ARRAY && test.getRobustAccessType() == ROBUSTACCESS_TRUE)
2322                                         localWriteArrayResetTestGroup->addChild                         (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test));
2323
2324                                 if (test.getResourceType() == RESOURCETYPE_LOCAL_ARRAY && test.getRobustAccessType() == ROBUSTACCESS_FALSE)
2325                                         localWriteArrayResetNonRobustTestGroup->addChild        (new BasicResetCase(eglTestCtx, test.getName().c_str(), (test.getDescription() + resetScenarioDescription).c_str(), test));
2326                 }
2327
2328                 // robust Context
2329                 tcu::TestCaseGroup* const outOfBoundsResetReadAccessTestGroup   = new TestCaseGroup(eglTestCtx, "reads",        "Out of bounds read accesses");
2330                 tcu::TestCaseGroup* const outOfBoundsResetWriteAccessTestGroup  = new TestCaseGroup(eglTestCtx, "writes",       "Out of bounds write accesses");
2331
2332                 outOfBoundsResetReadAccessTestGroup->addChild(uboReadArrayResetTestGroup);
2333                 outOfBoundsResetReadAccessTestGroup->addChild(ssboReadArrayResetTestGroup);
2334                 outOfBoundsResetReadAccessTestGroup->addChild(localReadArrayResetTestGroup);
2335
2336                 outOfBoundsResetWriteAccessTestGroup->addChild(uboWriteArrayResetTestGroup);
2337                 outOfBoundsResetWriteAccessTestGroup->addChild(ssboWriteArrayResetTestGroup);
2338                 outOfBoundsResetWriteAccessTestGroup->addChild(localWriteArrayResetTestGroup);
2339
2340                 tcu::TestCaseGroup* const outOfBoundsResetTestGroup             = new TestCaseGroup(eglTestCtx, "reset_status", "Tests that query the reset status after a context reset has occurred");
2341
2342                 outOfBoundsResetTestGroup->addChild(outOfBoundsResetReadAccessTestGroup);
2343                 outOfBoundsResetTestGroup->addChild(outOfBoundsResetWriteAccessTestGroup);
2344
2345                 outOfBoundsTestGroup->addChild(outOfBoundsResetTestGroup);
2346
2347                 // non-robust Context (internal use only)
2348                 tcu::TestCaseGroup* const outOfBoundsResetReadAccessNonRobustTestGroup  = new TestCaseGroup(eglTestCtx, "reads",        "Out of bounds read accesses");
2349                 tcu::TestCaseGroup* const outOfBoundsResetWriteAccessNonRobustTestGroup = new TestCaseGroup(eglTestCtx, "writes",       "Out of bounds write accesses");
2350
2351                 outOfBoundsResetReadAccessNonRobustTestGroup->addChild(uboReadArrayResetNonRobustTestGroup);
2352                 outOfBoundsResetReadAccessNonRobustTestGroup->addChild(ssboReadArrayResetNonRobustTestGroup);
2353                 outOfBoundsResetReadAccessNonRobustTestGroup->addChild(localReadArrayResetNonRobustTestGroup);
2354
2355                 outOfBoundsResetWriteAccessNonRobustTestGroup->addChild(uboWriteArrayResetNonRobustTestGroup);
2356                 outOfBoundsResetWriteAccessNonRobustTestGroup->addChild(ssboWriteArrayResetNonRobustTestGroup);
2357                 outOfBoundsResetWriteAccessNonRobustTestGroup->addChild(localWriteArrayResetNonRobustTestGroup);
2358
2359                 tcu::TestCaseGroup* const outOfBoundsResetNonRobustTestGroup            = new TestCaseGroup(eglTestCtx, "reset_status", "Tests that query the reset status after a context reset has occurred");
2360
2361                 outOfBoundsResetNonRobustTestGroup->addChild(outOfBoundsResetReadAccessNonRobustTestGroup);
2362                 outOfBoundsResetNonRobustTestGroup->addChild(outOfBoundsResetWriteAccessNonRobustTestGroup);
2363
2364                 outOfBoundsNonRobustTestGroup->addChild(outOfBoundsResetNonRobustTestGroup);
2365         }
2366
2367         // fixed function test cases
2368         {
2369                 // robust context
2370                 tcu::TestCaseGroup* const fixedFunctionResetStatusTestGroup                             = new TestCaseGroup(eglTestCtx, "reset_status", "Tests that query the reset status after a context reset has occurred");
2371
2372                 // non-robust context (internal use only)
2373                 tcu::TestCaseGroup* const fixedFunctionResetStatusNonRobustTestGroup    = new TestCaseGroup(eglTestCtx, "reset_status", "Tests that query the reset status after a context reset has occurred");
2374
2375                 static const RobustnessTestCase::Params s_fixedFunctionPipelineCases[] =
2376                 {
2377                         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),
2378                         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),
2379
2380                         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),
2381                         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),
2382                 };
2383
2384                 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(s_fixedFunctionPipelineCases); ++testNdx)
2385                 {
2386                         const RobustnessTestCase::Params& test = s_fixedFunctionPipelineCases[testNdx];
2387                         if (test.getRobustAccessType() == ROBUSTACCESS_TRUE)
2388                                 fixedFunctionResetStatusTestGroup->addChild(new BasicResetCase(eglTestCtx, test.getName().c_str(), test.getDescription().c_str(), test));
2389                         else
2390                                 fixedFunctionResetStatusNonRobustTestGroup->addChild(new BasicResetCase(eglTestCtx, test.getName().c_str(), test.getDescription().c_str(), test));
2391                 }
2392
2393                 fixedFunctionTestGroup->addChild(fixedFunctionResetStatusTestGroup);
2394                 fixedFunctionNonRobustTestGroup->addChild(fixedFunctionResetStatusNonRobustTestGroup);
2395         }
2396
2397         // context creation query cases
2398         {
2399                 contextCreationTestGroup->addChild(new QueryRobustAccessCase    (eglTestCtx, "query_robust_access",             "Query robust access after successfully creating a robust context"));
2400                 contextCreationTestGroup->addChild(new NoResetNotificationCase  (eglTestCtx, "no_reset_notification",   "Query reset notification strategy after specifying GL_NO_RESET_NOTIFICATION"));
2401                 contextCreationTestGroup->addChild(new LoseContextOnResetCase   (eglTestCtx, "lose_context_on_reset",   "Query reset notification strategy after specifying GL_LOSE_CONTEXT_ON_RESET"));
2402         }
2403
2404         // invalid context creation cases
2405         {
2406                 negativeContextTestGroup->addChild(new InvalidContextCase               (eglTestCtx, "invalid_robust_context_creation",                 "Create a non-robust context but specify a reset notification strategy"));
2407                 negativeContextTestGroup->addChild(new InvalidShareContextCase  (eglTestCtx, "invalid_robust_shared_context_creation",  "Create a context share group with conflicting reset notification strategies"));
2408         }
2409
2410         shadersTestGroup->addChild(infiniteLoopTestGroup);
2411         shadersTestGroup->addChild(outOfBoundsTestGroup);
2412         shadersTestGroup->addChild(outOfBoundsNonRobustTestGroup);
2413
2414         contextResetTestGroup->addChild(shadersTestGroup);
2415         contextResetTestGroup->addChild(fixedFunctionTestGroup);
2416         contextResetTestGroup->addChild(fixedFunctionNonRobustTestGroup);
2417
2418         group->addChild(contextCreationTestGroup);
2419         group->addChild(contextResetTestGroup);
2420         group->addChild(negativeContextTestGroup);
2421
2422         return group.release();
2423 }
2424
2425 } // egl
2426 } // deqp