| /*------------------------------------------------------------------------- |
| * drawElements Quality Program EGL Module |
| * --------------------------------------- |
| * |
| * Copyright 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Robustness tests for KHR_robustness. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "teglRobustnessTests.hpp" |
| |
| #include "tcuTestLog.hpp" |
| #include "tcuStringTemplate.hpp" |
| |
| #include "egluConfigFilter.hpp" |
| #include "egluStrUtil.hpp" |
| #include "egluUtil.hpp" |
| #include "eglwLibrary.hpp" |
| |
| #include "gluStrUtil.hpp" |
| #include "gluShaderProgram.hpp" |
| #include "gluDrawUtil.hpp" |
| |
| #include "glwFunctions.hpp" |
| #include "glwEnums.hpp" |
| |
| #include "deSTLUtil.hpp" |
| #include "deStringUtil.hpp" |
| #include "deThread.hpp" |
| #include "deSharedPtr.hpp" |
| |
| #include <set> |
| |
| using std::set; |
| using std::string; |
| using std::vector; |
| using tcu::TestLog; |
| |
| using namespace eglw; |
| |
| DE_STATIC_ASSERT(GL_RESET_NOTIFICATION_STRATEGY == 0x8256); |
| DE_STATIC_ASSERT(GL_LOSE_CONTEXT_ON_RESET == 0x8252); |
| DE_STATIC_ASSERT(GL_NO_RESET_NOTIFICATION == 0x8261); |
| |
| namespace deqp |
| { |
| namespace egl |
| { |
| namespace |
| { |
| |
| enum ContextResetType |
| { |
| CONTEXTRESETTYPE_SHADER_OOB, |
| CONTEXTRESETTYPE_FIXED_FUNC_OOB, |
| }; |
| |
| enum ShaderType |
| { |
| SHADERTYPE_VERT, |
| SHADERTYPE_FRAG, |
| SHADERTYPE_COMPUTE, |
| SHADERTYPE_VERT_AND_FRAG, |
| }; |
| |
| enum ReadWriteType |
| { |
| READWRITETYPE_READ, |
| READWRITETYPE_WRITE, |
| }; |
| |
| enum ResourceType |
| { |
| RESOURCETYPE_UBO, |
| RESOURCETYPE_SSBO, |
| RESOURCETYPE_LOCAL_ARRAY, |
| }; |
| |
| enum FixedFunctionType |
| { |
| FIXEDFUNCTIONTYPE_INDICES, |
| FIXEDFUNCTIONTYPE_VERTICES, |
| }; |
| |
| enum RobustAccessType |
| { |
| ROBUSTACCESS_TRUE, |
| ROBUSTACCESS_FALSE, |
| }; |
| |
| void requireEGLExtension(const Library &egl, EGLDisplay eglDisplay, const char *requiredExtension) |
| { |
| if (!eglu::hasExtension(egl, eglDisplay, requiredExtension)) |
| TCU_THROW(NotSupportedError, (string(requiredExtension) + " not supported").c_str()); |
| } |
| |
| bool isWindow(const eglu::CandidateConfig &c) |
| { |
| return (c.surfaceType() & EGL_WINDOW_BIT) == EGL_WINDOW_BIT; |
| } |
| |
| template <uint32_t Type> |
| bool renderable(const eglu::CandidateConfig &c) |
| { |
| return (c.renderableType() & Type) == Type; |
| } |
| |
| eglu::ConfigFilter getRenderableFilter(uint32_t bits) |
| { |
| switch (bits) |
| { |
| case EGL_OPENGL_ES2_BIT: |
| return renderable<EGL_OPENGL_ES2_BIT>; |
| case EGL_OPENGL_ES3_BIT: |
| return renderable<EGL_OPENGL_ES3_BIT>; |
| case EGL_OPENGL_BIT: |
| return renderable<EGL_OPENGL_BIT>; |
| default: |
| DE_FATAL("Unknown EGL bitfied value"); |
| return renderable<0>; |
| } |
| } |
| |
| const char *eglResetNotificationStrategyToString(EGLint strategy) |
| { |
| switch (strategy) |
| { |
| case EGL_NO_RESET_NOTIFICATION_KHR: |
| return "EGL_NO_RESET_NOTIFICATION_KHR"; |
| case EGL_LOSE_CONTEXT_ON_RESET_KHR: |
| return "EGL_LOSE_CONTEXT_ON_RESET_KHR"; |
| default: |
| return "<Unknown>"; |
| } |
| } |
| |
| void logAttribList(const EglTestContext &eglTestCtx, const EGLint *attribList) |
| { |
| const EGLint *iter = &(attribList[0]); |
| std::ostringstream attribListString; |
| |
| while ((*iter) != EGL_NONE) |
| { |
| switch (*iter) |
| { |
| // case EGL_CONTEXT_CLIENT_VERSION: |
| case EGL_CONTEXT_MAJOR_VERSION_KHR: |
| iter++; |
| attribListString << "EGL_CONTEXT_CLIENT_VERSION, " << (*iter) << ", "; |
| iter++; |
| break; |
| |
| case EGL_CONTEXT_MINOR_VERSION_KHR: |
| iter++; |
| attribListString << "EGL_CONTEXT_MINOR_VERSION_KHR, " << (*iter) << ", "; |
| iter++; |
| break; |
| |
| case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT: |
| iter++; |
| attribListString << "EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, " |
| << eglResetNotificationStrategyToString(*iter) << ", "; |
| iter++; |
| break; |
| |
| case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR: |
| iter++; |
| attribListString << "EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR, " |
| << eglResetNotificationStrategyToString(*iter) << ", "; |
| iter++; |
| break; |
| |
| case EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT: |
| iter++; |
| attribListString << "EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, "; |
| |
| if (*iter == EGL_FALSE || *iter == EGL_TRUE) |
| attribListString << (*iter ? "EGL_TRUE" : "EGL_FALSE") << ", "; |
| else |
| attribListString << (*iter) << ", "; |
| iter++; |
| break; |
| |
| default: |
| DE_FATAL("Unsupported attribute"); |
| } |
| } |
| |
| attribListString << "EGL_NONE"; |
| eglTestCtx.getTestContext().getLog() << TestLog::Message << "EGL attrib list: { " << attribListString.str() |
| << " }\n\n" |
| << TestLog::EndMessage; |
| } |
| |
| class RobustnessTestCase : public TestCase |
| { |
| public: |
| class Params |
| { |
| public: |
| Params(void) |
| { |
| } |
| |
| Params(const string &name, const string &description, const RobustAccessType &robustAccessType, |
| const ContextResetType &contextResetType, const FixedFunctionType &fixedFunctionType); |
| |
| Params(const string &name, const string &description, const RobustAccessType &robustAccessType, |
| const ContextResetType &contextResetType, const ShaderType &shaderType, const ResourceType &resourceType, |
| const ReadWriteType &readWriteType); |
| |
| const string &getName(void) const |
| { |
| return m_name; |
| } |
| const string &getDescription(void) const |
| { |
| return m_description; |
| } |
| const ContextResetType &getContextResetType(void) const |
| { |
| return m_contextResetType; |
| } |
| const ShaderType &getShaderType(void) const |
| { |
| return m_shaderType; |
| } |
| const ResourceType &getResourceType(void) const |
| { |
| return m_resourceType; |
| } |
| const ReadWriteType &getReadWriteType(void) const |
| { |
| return m_readWriteType; |
| } |
| const FixedFunctionType &getFixedFunctionType(void) const |
| { |
| return m_fixedFunctionType; |
| } |
| const RobustAccessType &getRobustAccessType(void) const |
| { |
| return m_robustAccessType; |
| } |
| |
| private: |
| string m_name; |
| string m_description; |
| RobustAccessType m_robustAccessType; |
| ContextResetType m_contextResetType; |
| ShaderType m_shaderType; |
| ResourceType m_resourceType; |
| ReadWriteType m_readWriteType; |
| FixedFunctionType m_fixedFunctionType; |
| }; |
| |
| RobustnessTestCase(EglTestContext &eglTestCtx, const char *name, const char *description); |
| RobustnessTestCase(EglTestContext &eglTestCtx, const char *name, const char *description, Params params); |
| ~RobustnessTestCase(void); |
| |
| void checkRequiredEGLExtensions(const EGLint *attribList); |
| |
| protected: |
| Params m_params; |
| EGLDisplay m_eglDisplay; |
| EGLConfig m_eglConfig; |
| EGLSurface m_eglSurface; |
| |
| private: |
| void init(void); |
| void deinit(void); |
| void initEGLSurface(void); |
| EGLConfig getEGLConfig(void); |
| |
| eglu::NativeWindow *m_window; |
| }; |
| |
| RobustnessTestCase::Params::Params(const string &name, const string &description, |
| const RobustAccessType &robustAccessType, const ContextResetType &contextResetType, |
| const FixedFunctionType &fixedFunctionType) |
| : m_name(name) |
| , m_description(description) |
| , m_robustAccessType(robustAccessType) |
| , m_contextResetType(contextResetType) |
| , m_fixedFunctionType(fixedFunctionType) |
| { |
| } |
| |
| RobustnessTestCase::Params::Params(const string &name, const string &description, |
| const RobustAccessType &robustAccessType, const ContextResetType &contextResetType, |
| const ShaderType &shaderType, const ResourceType &resourceType, |
| const ReadWriteType &readWriteType) |
| : m_name(name) |
| , m_description(description) |
| , m_robustAccessType(robustAccessType) |
| , m_contextResetType(contextResetType) |
| , m_shaderType(shaderType) |
| , m_resourceType(resourceType) |
| , m_readWriteType(readWriteType) |
| { |
| } |
| |
| RobustnessTestCase::RobustnessTestCase(EglTestContext &eglTestCtx, const char *name, const char *description) |
| : TestCase(eglTestCtx, name, description) |
| , m_eglDisplay(EGL_NO_DISPLAY) |
| , m_eglConfig(0) |
| , m_eglSurface(EGL_NO_SURFACE) |
| , m_window(DE_NULL) |
| { |
| } |
| |
| RobustnessTestCase::RobustnessTestCase(EglTestContext &eglTestCtx, const char *name, const char *description, |
| Params params) |
| : TestCase(eglTestCtx, name, description) |
| , m_params(params) |
| , m_eglDisplay(EGL_NO_DISPLAY) |
| , m_eglConfig(0) |
| , m_eglSurface(EGL_NO_SURFACE) |
| , m_window(DE_NULL) |
| { |
| } |
| |
| RobustnessTestCase::~RobustnessTestCase(void) |
| { |
| deinit(); |
| } |
| |
| void RobustnessTestCase::init(void) |
| { |
| m_eglDisplay = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay()); |
| m_eglConfig = getEGLConfig(); |
| |
| initEGLSurface(); |
| } |
| |
| void RobustnessTestCase::deinit(void) |
| { |
| const Library &egl = m_eglTestCtx.getLibrary(); |
| |
| if (m_eglSurface != EGL_NO_SURFACE) |
| { |
| egl.destroySurface(m_eglDisplay, m_eglSurface); |
| m_eglSurface = EGL_NO_SURFACE; |
| } |
| if (m_eglDisplay != EGL_NO_DISPLAY) |
| { |
| egl.terminate(m_eglDisplay); |
| m_eglDisplay = EGL_NO_DISPLAY; |
| } |
| |
| delete m_window; |
| m_window = DE_NULL; |
| } |
| |
| EGLConfig RobustnessTestCase::getEGLConfig(void) |
| { |
| eglu::FilterList filters; |
| filters << isWindow << getRenderableFilter(EGL_OPENGL_ES3_BIT); |
| return eglu::chooseSingleConfig(m_eglTestCtx.getLibrary(), m_eglDisplay, filters); |
| } |
| |
| void RobustnessTestCase::initEGLSurface(void) |
| { |
| EGLU_CHECK_CALL(m_eglTestCtx.getLibrary(), bindAPI(EGL_OPENGL_ES_API)); |
| |
| const eglu::NativeWindowFactory &factory = |
| eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine()); |
| |
| const eglu::WindowParams windowParams = |
| eglu::WindowParams(256, 256, eglu::parseWindowVisibility(m_testCtx.getCommandLine())); |
| m_window = factory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_eglDisplay, m_eglConfig, DE_NULL, windowParams); |
| m_eglSurface = |
| eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *m_window, m_eglDisplay, m_eglConfig, DE_NULL); |
| } |
| |
| glu::ApiType paramsToApiType(const RobustnessTestCase::Params ¶ms) |
| { |
| EGLint minorVersion = 0; |
| if (params.getShaderType() == SHADERTYPE_COMPUTE || params.getResourceType() == RESOURCETYPE_SSBO || |
| params.getContextResetType() == CONTEXTRESETTYPE_SHADER_OOB) |
| { |
| minorVersion = 1; |
| } |
| |
| return glu::ApiType::es(3, minorVersion); |
| } |
| |
| void RobustnessTestCase::checkRequiredEGLExtensions(const EGLint *attribList) |
| { |
| set<string> requiredExtensions; |
| vector<string> extensions = eglu::getDisplayExtensions(m_eglTestCtx.getLibrary(), m_eglDisplay); |
| |
| { |
| const EGLint *iter = attribList; |
| |
| while ((*iter) != EGL_NONE) |
| { |
| switch (*iter) |
| { |
| case EGL_CONTEXT_MAJOR_VERSION_KHR: |
| iter++; |
| iter++; |
| break; |
| |
| case EGL_CONTEXT_MINOR_VERSION_KHR: |
| iter++; |
| requiredExtensions.insert("EGL_KHR_create_context"); |
| iter++; |
| break; |
| |
| case EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT: |
| case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT: |
| iter++; |
| requiredExtensions.insert("EGL_EXT_create_context_robustness"); |
| iter++; |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| } |
| |
| for (std::set<string>::const_iterator reqExt = requiredExtensions.begin(); reqExt != requiredExtensions.end(); |
| ++reqExt) |
| { |
| if (!de::contains(extensions.begin(), extensions.end(), *reqExt)) |
| { |
| const char *const extension = reqExt->c_str(); |
| requireEGLExtension(m_eglTestCtx.getLibrary(), m_eglDisplay, extension); |
| } |
| } |
| } |
| |
| void checkRequiredGLSupport(const glw::Functions &gl, glu::ApiType requiredApi) |
| { |
| if (!glu::hasExtension(gl, requiredApi, "GL_KHR_robustness") && |
| !glu::hasExtension(gl, requiredApi, "GL_EXT_robustness")) |
| { |
| TCU_THROW(NotSupportedError, (string("GL_KHR_robustness and GL_EXT_robustness") + " not supported").c_str()); |
| } |
| else |
| { |
| int realMinorVersion = 0; |
| gl.getIntegerv(GL_MINOR_VERSION, &realMinorVersion); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Get minor version failed"); |
| |
| if (realMinorVersion < requiredApi.getMinorVersion()) |
| TCU_THROW(NotSupportedError, "Test case requires GLES 3.1"); |
| } |
| } |
| |
| void checkGLSupportForParams(const glw::Functions &gl, const RobustnessTestCase::Params ¶ms) |
| { |
| int minorVersion = 0; |
| if (params.getShaderType() == SHADERTYPE_COMPUTE || params.getResourceType() == RESOURCETYPE_SSBO || |
| params.getContextResetType() == CONTEXTRESETTYPE_SHADER_OOB) |
| { |
| minorVersion = 1; |
| } |
| checkRequiredGLSupport(gl, glu::ApiType::es(3, minorVersion)); |
| } |
| |
| class RenderingContext |
| { |
| public: |
| RenderingContext(const EglTestContext &eglTestCtx, const EGLint *attribList, const EGLConfig &config, |
| const EGLDisplay &display, const EGLContext &sharedContext); |
| ~RenderingContext(void); |
| |
| void initGLFunctions(glw::Functions *gl, const glu::ApiType apiType); |
| void makeCurrent(const EGLSurface &surface); |
| EGLContext getContext(void); |
| |
| private: |
| const EglTestContext &m_eglTestCtx; |
| const EGLint *m_attribList; |
| const EGLConfig &m_config; |
| const EGLDisplay &m_display; |
| const Library &m_egl; |
| |
| EGLContext m_context; |
| |
| void createContext(const EGLConfig &sharedConfig); |
| void destroyContext(void); |
| |
| RenderingContext(const RenderingContext &); |
| RenderingContext &operator=(const RenderingContext &); |
| }; |
| |
| RenderingContext::RenderingContext(const EglTestContext &eglTestCtx, const EGLint *attribList, const EGLConfig &config, |
| const EGLDisplay &display, const EGLContext &sharedContext) |
| : m_eglTestCtx(eglTestCtx) |
| , m_attribList(attribList) |
| , m_config(config) |
| , m_display(display) |
| , m_egl(eglTestCtx.getLibrary()) |
| , m_context(EGL_NO_CONTEXT) |
| { |
| logAttribList(eglTestCtx, m_attribList); |
| createContext(sharedContext); |
| } |
| |
| RenderingContext::~RenderingContext(void) |
| { |
| destroyContext(); |
| } |
| |
| void RenderingContext::createContext(const EGLConfig &sharedContext) |
| { |
| m_context = m_egl.createContext(m_display, m_config, sharedContext, m_attribList); |
| EGLU_CHECK_MSG(m_egl, "eglCreateContext()"); |
| } |
| |
| void RenderingContext::destroyContext(void) |
| { |
| EGLU_CHECK_CALL(m_eglTestCtx.getLibrary(), makeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); |
| |
| if (m_context != EGL_NO_CONTEXT) |
| m_egl.destroyContext(m_display, m_context); |
| } |
| |
| void RenderingContext::makeCurrent(const EGLSurface &surface) |
| { |
| EGLU_CHECK_CALL(m_egl, makeCurrent(m_display, surface, surface, m_context)); |
| } |
| |
| void RenderingContext::initGLFunctions(glw::Functions *gl, const glu::ApiType apiType) |
| { |
| // \todo [2017-03-23 pyry] Current version has 2 somewhat ugly hacks: |
| // |
| // 1) Core functions are loaded twice. We need glGetString(i) to query supported |
| // extensions to determine if we need to load EXT or KHR-suffixed robustness |
| // functions. This could be fixed by exposing glw::FunctionLoader in EglTestContext |
| // for example. |
| // |
| // 2) We assume that calling code will check for KHR_robustness or EXT_robustness |
| // support after calling initGLFunctions(). We could move the check here. |
| |
| m_eglTestCtx.initGLFunctions(gl, apiType); |
| |
| { |
| const char *const robustnessExt = |
| glu::hasExtension(*gl, apiType, "GL_KHR_robustness") ? "GL_KHR_robustness" : "GL_EXT_robustness"; |
| const char *const extensions[] = {robustnessExt}; |
| |
| m_eglTestCtx.initGLFunctions(gl, apiType, DE_LENGTH_OF_ARRAY(extensions), &extensions[0]); |
| } |
| } |
| |
| EGLContext RenderingContext::getContext(void) |
| { |
| return m_context; |
| } |
| |
| class ContextReset |
| { |
| public: |
| ContextReset(glw::Functions &gl, tcu::TestLog &log, FixedFunctionType fixedFunctionType); |
| ContextReset(glw::Functions &gl, tcu::TestLog &log, ShaderType shaderType, ResourceType resourceType, |
| ReadWriteType readWriteType); |
| |
| virtual ~ContextReset(void) |
| { |
| } |
| |
| virtual void setup(void) = 0; |
| virtual void draw(void) = 0; |
| virtual void teardown(void) = 0; |
| |
| void finish(void); |
| |
| glw::GLint getError(void); |
| glw::GLint getGraphicsResetStatus(void); |
| |
| glw::GLsync getSyncObject(void) const |
| { |
| return m_sync; |
| } |
| glw::GLuint getQueryID(void) const |
| { |
| return m_queryID; |
| } |
| |
| glw::Functions &m_gl; |
| tcu::TestLog &m_log; |
| ShaderType m_shaderType; |
| ResourceType m_resourceType; |
| ReadWriteType m_readWriteType; |
| FixedFunctionType m_fixedFunctionType; |
| |
| private: |
| ContextReset(const ContextReset &); |
| ContextReset &operator=(const ContextReset &); |
| |
| glw::GLuint m_queryID; |
| glw::GLsync m_sync; |
| }; |
| |
| ContextReset::ContextReset(glw::Functions &gl, tcu::TestLog &log, FixedFunctionType fixedFunctionType) |
| : m_gl(gl) |
| , m_log(log) |
| , m_fixedFunctionType(fixedFunctionType) |
| { |
| } |
| |
| ContextReset::ContextReset(glw::Functions &gl, tcu::TestLog &log, ShaderType shaderType, ResourceType resourceType, |
| ReadWriteType readWriteType) |
| : m_gl(gl) |
| , m_log(log) |
| , m_shaderType(shaderType) |
| , m_resourceType(resourceType) |
| , m_readWriteType(readWriteType) |
| { |
| } |
| |
| void ContextReset::finish(void) |
| { |
| GLU_CHECK_GLW_CALL(m_gl, finish()); |
| } |
| |
| glw::GLint ContextReset::getError(void) |
| { |
| glw::GLint error; |
| error = m_gl.getError(); |
| |
| return error; |
| } |
| |
| glw::GLint ContextReset::getGraphicsResetStatus(void) |
| { |
| glw::GLint resetStatus; |
| resetStatus = m_gl.getGraphicsResetStatus(); |
| |
| return resetStatus; |
| } |
| |
| class FixedFunctionOOB : public ContextReset |
| { |
| public: |
| FixedFunctionOOB(glw::Functions &gl, tcu::TestLog &log, FixedFunctionType fixedFunctionType); |
| ~FixedFunctionOOB(void); |
| |
| struct TestConfig |
| { |
| int textureWidth; |
| int textureHeight; |
| }; |
| |
| virtual void setup(void); |
| virtual void draw(void); |
| virtual void teardown(void); |
| |
| private: |
| glu::ProgramSources genSources(void); |
| glw::GLuint m_coordinatesBuffer; |
| glw::GLint m_coordLocation; |
| }; |
| |
| FixedFunctionOOB::FixedFunctionOOB(glw::Functions &gl, tcu::TestLog &log, FixedFunctionType fixedFunctionType) |
| : ContextReset(gl, log, fixedFunctionType) |
| , m_coordinatesBuffer(0) |
| , m_coordLocation(0) |
| { |
| } |
| |
| FixedFunctionOOB::~FixedFunctionOOB(void) |
| { |
| try |
| { |
| // Reset GL_CONTEXT_LOST error before destroying resources |
| m_gl.getGraphicsResetStatus(); |
| teardown(); |
| } |
| catch (...) |
| { |
| // Ignore GL errors from teardown() |
| } |
| } |
| |
| glu::ProgramSources FixedFunctionOOB::genSources(void) |
| { |
| const char *const vert = "#version 300 es\n" |
| "in highp vec4 a_position;\n" |
| "void main (void)\n" |
| "{\n" |
| " gl_Position = a_position;\n" |
| "}\n"; |
| |
| const char *const frag = "#version 300 es\n" |
| "layout(location = 0) out highp vec4 fragColor;\n" |
| "void main (void)\n" |
| "{\n" |
| " fragColor = vec4(1.0f);\n" |
| "}\n"; |
| |
| return glu::ProgramSources() << glu::VertexSource(vert) << glu::FragmentSource(frag); |
| } |
| |
| void FixedFunctionOOB::setup(void) |
| { |
| glu::ShaderProgram program(m_gl, genSources()); |
| |
| m_log << program; |
| |
| if (!program.isOk()) |
| TCU_FAIL("Failed to compile shader program"); |
| |
| GLU_CHECK_GLW_CALL(m_gl, useProgram(program.getProgram())); |
| |
| const glw::GLfloat coords[] = {-1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f}; |
| |
| m_coordLocation = m_gl.getAttribLocation(program.getProgram(), "a_position"); |
| GLU_CHECK_GLW_MSG(m_gl, "glGetAttribLocation()"); |
| TCU_CHECK(m_coordLocation != (glw::GLint)-1); |
| |
| // Load the vertex data |
| m_coordinatesBuffer = 0; |
| GLU_CHECK_GLW_CALL(m_gl, genBuffers(1, &m_coordinatesBuffer)); |
| GLU_CHECK_GLW_CALL(m_gl, bindBuffer(GL_ARRAY_BUFFER, m_coordinatesBuffer)); |
| GLU_CHECK_GLW_CALL(m_gl, bufferData(GL_ARRAY_BUFFER, (glw::GLsizeiptr)sizeof(coords), coords, GL_STATIC_DRAW)); |
| GLU_CHECK_GLW_CALL(m_gl, enableVertexAttribArray(m_coordLocation)); |
| GLU_CHECK_GLW_CALL(m_gl, vertexAttribPointer(m_coordLocation, 2, GL_FLOAT, GL_FALSE, 0, DE_NULL)); |
| } |
| |
| void FixedFunctionOOB::draw(void) |
| { |
| const glw::GLint bad_indices[] = {0, 10, 100, 1000, 10000, 100000}; |
| |
| if (m_fixedFunctionType == FIXEDFUNCTIONTYPE_INDICES) |
| m_gl.drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, bad_indices); |
| else if (m_fixedFunctionType == FIXEDFUNCTIONTYPE_VERTICES) |
| m_gl.drawArrays(GL_TRIANGLES, 0, 1000); |
| else |
| DE_FATAL("Unknown fixed function type"); |
| } |
| |
| void FixedFunctionOOB::teardown(void) |
| { |
| if (m_coordLocation) |
| { |
| GLU_CHECK_GLW_CALL(m_gl, disableVertexAttribArray(m_coordLocation)); |
| m_coordLocation = 0; |
| } |
| |
| if (m_coordinatesBuffer) |
| { |
| GLU_CHECK_GLW_CALL(m_gl, deleteBuffers(1, &m_coordinatesBuffer)); |
| m_coordinatesBuffer = 0; |
| } |
| |
| GLU_CHECK_GLW_CALL(m_gl, useProgram(0)); |
| } |
| |
| class ShadersOOB : public ContextReset |
| { |
| public: |
| ShadersOOB(glw::Functions &gl, tcu::TestLog &log, ShaderType shaderType, ResourceType resourceType, |
| ReadWriteType readWriteType); |
| ~ShadersOOB(void); |
| |
| virtual void setup(void); |
| virtual void draw(void); |
| virtual void teardown(void); |
| |
| private: |
| static const int s_numBindings = 3; |
| |
| glw::GLuint m_coordinatesBuffer; |
| glw::GLint m_coordLocation; |
| |
| bool m_isUBO; |
| bool m_isRead; |
| bool m_isLocalArray; |
| std::vector<glw::GLuint> m_buffers; |
| |
| std::string genVertexShader(const std::string &shaderDecl, const std::string &shaderBody); |
| std::string genFragmentShader(const std::string &shaderDecl, const std::string &shaderBody); |
| std::string genComputeShader(const std::string &shaderDecl, const std::string &shaderBody); |
| |
| glu::ProgramSources genNonComputeSource(void); |
| glu::ProgramSources genComputeSource(void); |
| glu::ProgramSources genSources(void); |
| }; |
| |
| ShadersOOB::ShadersOOB(glw::Functions &gl, tcu::TestLog &log, ShaderType shaderType, ResourceType resourceType, |
| ReadWriteType readWriteType) |
| : ContextReset(gl, log, shaderType, resourceType, readWriteType) |
| , m_coordinatesBuffer(0) |
| , m_coordLocation(0) |
| , m_buffers(s_numBindings, 0) |
| { |
| m_isUBO = (m_resourceType == RESOURCETYPE_UBO); |
| m_isLocalArray = (m_resourceType == RESOURCETYPE_LOCAL_ARRAY); |
| m_isRead = (m_readWriteType == READWRITETYPE_READ); |
| } |
| |
| ShadersOOB::~ShadersOOB(void) |
| { |
| try |
| { |
| // Reset GL_CONTEXT_LOST error before destroying resources |
| m_gl.getGraphicsResetStatus(); |
| teardown(); |
| } |
| catch (...) |
| { |
| // Ignore GL errors from teardown() |
| } |
| } |
| |
| std::string ShadersOOB::genVertexShader(const std::string &shaderDecl, const std::string &shaderBody) |
| { |
| static const char *const s_simpleVertexShaderSource = "#version 310 es\n" |
| "in highp vec4 a_position;\n" |
| "void main (void)\n" |
| "{\n" |
| " gl_Position = a_position;\n" |
| "}\n"; |
| |
| switch (m_shaderType) |
| { |
| case SHADERTYPE_VERT: |
| case SHADERTYPE_VERT_AND_FRAG: |
| { |
| std::ostringstream vertexShaderSource; |
| vertexShaderSource << "#version 310 es\n" |
| << "in highp vec4 a_position;\n" |
| << "out highp vec4 v_color;\n" |
| << shaderDecl << "\n" |
| << "void main (void)\n" |
| << "{\n" |
| << " highp vec4 color = vec4(0.0f);\n" |
| << shaderBody << "\n" |
| << " v_color = color;\n" |
| << " gl_Position = a_position;\n" |
| << "}\n"; |
| |
| return vertexShaderSource.str(); |
| } |
| |
| case SHADERTYPE_FRAG: |
| return s_simpleVertexShaderSource; |
| |
| default: |
| DE_FATAL("Unknown shader type"); |
| return ""; |
| } |
| } |
| |
| std::string ShadersOOB::genFragmentShader(const std::string &shaderDecl, const std::string &shaderBody) |
| { |
| static const char *const s_simpleFragmentShaderSource = "#version 310 es\n" |
| "in highp vec4 v_color;\n" |
| "layout(location = 0) out highp vec4 fragColor;\n" |
| "void main (void)\n" |
| "{\n" |
| " fragColor = v_color;\n" |
| "}\n"; |
| |
| switch (m_shaderType) |
| { |
| case SHADERTYPE_VERT: |
| return s_simpleFragmentShaderSource; |
| |
| case SHADERTYPE_FRAG: |
| { |
| std::ostringstream fragmentShaderSource; |
| fragmentShaderSource << "#version 310 es\n" |
| << "layout(location = 0) out highp vec4 fragColor;\n" |
| << shaderDecl << "\n" |
| << "void main (void)\n" |
| << "{\n" |
| << " highp vec4 color = vec4(0.0f);\n" |
| << shaderBody << "\n" |
| << " fragColor = color;\n" |
| << "}\n"; |
| |
| return fragmentShaderSource.str(); |
| } |
| case SHADERTYPE_VERT_AND_FRAG: |
| { |
| std::ostringstream fragmentShaderSource; |
| fragmentShaderSource << "#version 310 es\n" |
| << "in highp vec4 v_color;\n" |
| << "layout(location = 0) out highp vec4 fragColor;\n" |
| << shaderDecl << "\n" |
| << "void main (void)\n" |
| << "{\n" |
| << " highp vec4 color = vec4(0.0f);\n" |
| << shaderBody << "\n" |
| << " fragColor = color;\n" |
| << "}\n"; |
| |
| return fragmentShaderSource.str(); |
| } |
| |
| default: |
| DE_FATAL("Unknown shader type"); |
| return ""; |
| } |
| } |
| |
| std::string ShadersOOB::genComputeShader(const std::string &shaderDecl, const std::string &shaderBody) |
| { |
| std::ostringstream computeShaderSource; |
| |
| computeShaderSource << "#version 310 es\n" |
| << "layout(local_size_x = 1, local_size_y = 1) in;\n" |
| << "\n" |
| << "layout(binding = 0) buffer Output {\n" |
| << " highp vec4 values;\n" |
| << "} sb_out;\n" |
| << "\n" |
| << shaderDecl << "void main ()\n" |
| << "{\n" |
| << shaderBody << "}\n"; |
| |
| return computeShaderSource.str(); |
| } |
| |
| glu::ProgramSources ShadersOOB::genNonComputeSource(void) |
| { |
| std::ostringstream shaderDecl; |
| std::ostringstream shaderBody; |
| |
| shaderDecl << "uniform highp int u_index;\n"; |
| |
| if (m_isLocalArray) |
| { |
| const char *const readWriteStatement = |
| (m_isRead) ? " color.x = color_out[u_index];\n" : " color[u_index] = color_out[0];\n"; |
| |
| shaderBody << " highp float color_out[4] = float[4](0.25f, 0.5f, 0.75f, 1.0f);\n" << readWriteStatement; |
| } |
| else |
| { |
| const std::string resName = (m_isUBO) ? "ub_in" : "sb_in"; |
| |
| shaderDecl << "layout(std140, binding = 0) " << ((m_isUBO) ? "uniform" : "buffer") << " Block\n" |
| << "{\n" |
| << " highp float color_out[4];\n" |
| << "} " << resName << "[" << s_numBindings << "];\n"; |
| |
| const std::string readWriteStatement = (m_isRead) ? " color.x = " + resName + "[0].color_out[u_index];\n" : |
| " color[u_index] = " + resName + "[0].color_out[0];\n"; |
| |
| shaderBody << readWriteStatement; |
| } |
| |
| return glu::ProgramSources() << glu::VertexSource(genVertexShader(shaderDecl.str(), shaderBody.str())) |
| << glu::FragmentSource(genFragmentShader(shaderDecl.str(), shaderBody.str())); |
| } |
| |
| glu::ProgramSources ShadersOOB::genComputeSource(void) |
| { |
| std::ostringstream shaderDecl; |
| std::ostringstream shaderBody; |
| |
| shaderDecl << "uniform highp int u_index;\n"; |
| |
| shaderBody << " uvec3 size = gl_NumWorkGroups * gl_WorkGroupSize;\n" |
| << " uint groupNdx = size.x*gl_GlobalInvocationID.y + gl_GlobalInvocationID.x;\n"; |
| |
| if (m_isLocalArray) |
| { |
| const char *const readWriteStatement = |
| (m_isRead) ? " sb_out.values.x = values[u_index];\n" : " sb_out.values[u_index] = values.x;\n"; |
| |
| shaderBody << " highp vec4 values = vec4(1.0f, 0.0f, 3.0f, 2.0f) * float(groupNdx);\n" << readWriteStatement; |
| } |
| else |
| { |
| const std::string resName = (m_isUBO) ? "ub_in" : "sb_in"; |
| |
| shaderDecl << "layout(std140, binding = 1) " << ((m_isUBO) ? "uniform" : "buffer") << " Input\n" |
| << "{\n" |
| << " highp vec4 values;\n" |
| << "} " << resName << "[" << s_numBindings << "];\n"; |
| |
| std::string readWriteStatement = |
| (m_isRead) ? " sb_out.values.x = " + resName + "[0].values[u_index] * float(groupNdx);\n" : |
| " sb_out.values[u_index] = " + resName + "[0].values.x * float(groupNdx);\n"; |
| |
| shaderBody << readWriteStatement; |
| } |
| |
| return glu::ProgramSources() << glu::ComputeSource(genComputeShader(shaderDecl.str(), shaderBody.str())); |
| } |
| |
| glu::ProgramSources ShadersOOB::genSources(void) |
| { |
| if (m_shaderType == SHADERTYPE_COMPUTE) |
| return genComputeSource(); |
| else |
| return genNonComputeSource(); |
| } |
| |
| void ShadersOOB::setup(void) |
| { |
| if (!m_isUBO && !m_isLocalArray && (m_shaderType != SHADERTYPE_COMPUTE)) |
| { |
| // Check implementation limits for shader SSBO |
| int shaderStorageBlockSupported = -1; |
| const bool isVertex = |
| (m_shaderType == SHADERTYPE_VERT || m_shaderType == SHADERTYPE_VERT_AND_FRAG) ? true : false; |
| string shaderTypeStr = |
| isVertex ? "GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS" : "GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS"; |
| |
| GLU_CHECK_GLW_CALL( |
| m_gl, getIntegerv(isVertex ? GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS : GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS, |
| &shaderStorageBlockSupported)); |
| |
| if (shaderStorageBlockSupported < (int)m_buffers.size()) |
| TCU_THROW(NotSupportedError, |
| ("Test requires " + shaderTypeStr + " >= " + de::toString((int)m_buffers.size()) + ", got " + |
| de::toString(shaderStorageBlockSupported)) |
| .c_str()); |
| } |
| |
| glu::ShaderProgram program(m_gl, genSources()); |
| |
| m_log << program; |
| |
| if (!program.isOk()) |
| TCU_FAIL("Failed to compile shader program"); |
| |
| GLU_CHECK_GLW_CALL(m_gl, useProgram(program.getProgram())); |
| |
| const glw::GLint indexLocation = m_gl.getUniformLocation(program.getProgram(), "u_index"); |
| GLU_CHECK_GLW_MSG(m_gl, "glGetUniformLocation()"); |
| TCU_CHECK(indexLocation != (glw::GLint)-1); |
| |
| const glw::GLint index = -1; |
| GLU_CHECK_GLW_CALL(m_gl, uniform1i(indexLocation, index)); |
| |
| if (m_shaderType != SHADERTYPE_COMPUTE) |
| { |
| const glw::GLfloat coords[] = {-1.0f, -1.0f, +1.0f, -1.0f, +1.0f, +1.0f, -1.0f, +1.0f}; |
| |
| // Setup vertices position |
| m_coordLocation = m_gl.getAttribLocation(program.getProgram(), "a_position"); |
| GLU_CHECK_GLW_MSG(m_gl, "glGetAttribLocation()"); |
| TCU_CHECK(m_coordLocation != (glw::GLint)-1); |
| |
| // Load the vertex data |
| m_coordinatesBuffer = 0; |
| GLU_CHECK_GLW_CALL(m_gl, genBuffers(1, &m_coordinatesBuffer)); |
| GLU_CHECK_GLW_CALL(m_gl, bindBuffer(GL_ARRAY_BUFFER, m_coordinatesBuffer)); |
| GLU_CHECK_GLW_CALL(m_gl, bufferData(GL_ARRAY_BUFFER, (glw::GLsizeiptr)sizeof(coords), coords, GL_STATIC_DRAW)); |
| GLU_CHECK_GLW_CALL(m_gl, enableVertexAttribArray(m_coordLocation)); |
| GLU_CHECK_GLW_CALL(m_gl, vertexAttribPointer(m_coordLocation, 2, GL_FLOAT, GL_FALSE, 0, DE_NULL)); |
| } |
| |
| // Create dummy data for filling buffer objects |
| const std::vector<tcu::Vec4> refValues(s_numBindings, tcu::Vec4(0.0f, 1.0f, 1.0f, 1.0f)); |
| |
| if (m_isLocalArray && m_shaderType == SHADERTYPE_COMPUTE) |
| { |
| // Setup output buffer |
| GLU_CHECK_GLW_CALL(m_gl, genBuffers((glw::GLsizei)1u, &m_buffers[0])); |
| |
| GLU_CHECK_GLW_CALL(m_gl, bindBuffer(GL_SHADER_STORAGE_BUFFER, m_buffers[0])); |
| GLU_CHECK_GLW_CALL(m_gl, |
| bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(tcu::Vec4), &(refValues[0]), GL_STATIC_DRAW)); |
| GLU_CHECK_GLW_CALL(m_gl, bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_buffers[0])); |
| } |
| else if (!m_isLocalArray) |
| { |
| // Set up interface block of buffer bindings |
| GLU_CHECK_GLW_CALL(m_gl, genBuffers((glw::GLsizei)m_buffers.size(), &m_buffers[0])); |
| |
| for (int bufNdx = 0; bufNdx < (int)m_buffers.size(); ++bufNdx) |
| { |
| const glw::GLenum resType = m_isUBO && (m_shaderType != SHADERTYPE_COMPUTE || bufNdx != 0) ? |
| GL_UNIFORM_BUFFER : |
| GL_SHADER_STORAGE_BUFFER; |
| |
| GLU_CHECK_GLW_CALL(m_gl, bindBuffer(resType, m_buffers[bufNdx])); |
| GLU_CHECK_GLW_CALL(m_gl, bufferData(resType, sizeof(tcu::Vec4), &(refValues[bufNdx]), GL_STATIC_DRAW)); |
| GLU_CHECK_GLW_CALL(m_gl, bindBufferBase(resType, bufNdx, m_buffers[bufNdx])); |
| } |
| } |
| } |
| |
| void ShadersOOB::draw(void) |
| { |
| if (m_shaderType == SHADERTYPE_COMPUTE) |
| m_gl.dispatchCompute(1, 1, 1); |
| else |
| { |
| const glw::GLuint indices[] = {0, 1, 2, 2, 3, 0}; |
| m_gl.drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, indices); |
| } |
| } |
| |
| void ShadersOOB::teardown(void) |
| { |
| if (m_shaderType != SHADERTYPE_COMPUTE) |
| { |
| if (m_coordLocation) |
| { |
| GLU_CHECK_GLW_CALL(m_gl, disableVertexAttribArray(m_coordLocation)); |
| m_coordLocation = 0; |
| } |
| } |
| |
| if (m_coordinatesBuffer) |
| { |
| GLU_CHECK_GLW_CALL(m_gl, deleteBuffers(1, &m_coordinatesBuffer)); |
| m_coordinatesBuffer = 0; |
| } |
| |
| if (!m_isLocalArray) |
| { |
| if (!m_buffers.empty()) |
| { |
| GLU_CHECK_GLW_CALL(m_gl, deleteBuffers((glw::GLsizei)m_buffers.size(), &m_buffers[0])); |
| m_buffers.clear(); |
| } |
| } |
| |
| GLU_CHECK_GLW_CALL(m_gl, useProgram(0)); |
| } |
| |
| class QueryRobustAccessCase : public RobustnessTestCase |
| { |
| public: |
| QueryRobustAccessCase(EglTestContext &eglTestCtx, const char *name, const char *description) |
| : RobustnessTestCase(eglTestCtx, name, description) |
| { |
| } |
| |
| TestCase::IterateResult iterate(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << tcu::TestLog::Message |
| << "Check that after successfully creating a robust context the robust access query returned by " |
| "glBooleanv() equals GL_TRUE\n\n" |
| << tcu::TestLog::EndMessage; |
| |
| const EGLint attribList[] = {EGL_CONTEXT_CLIENT_VERSION, |
| 3, |
| EGL_CONTEXT_MINOR_VERSION_KHR, |
| 0, |
| EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, |
| EGL_TRUE, |
| EGL_NONE}; |
| |
| checkRequiredEGLExtensions(attribList); |
| |
| RenderingContext context(m_eglTestCtx, attribList, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT); |
| context.makeCurrent(m_eglSurface); |
| |
| glw::Functions gl; |
| { |
| const glu::ApiType apiType(3, 0, glu::PROFILE_ES); |
| context.initGLFunctions(&gl, apiType); |
| checkRequiredGLSupport(gl, apiType); |
| } |
| |
| uint8_t robustAccessGL; |
| gl.getBooleanv(GL_CONTEXT_ROBUST_ACCESS_EXT, &robustAccessGL); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv()"); |
| |
| if (robustAccessGL != GL_TRUE) |
| { |
| log << TestLog::Message << "Invalid GL_CONTEXT_ROBUST_ACCESS returned by glGetBooleanv(). Got '" |
| << robustAccessGL << "' expected GL_TRUE." << TestLog::EndMessage; |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| return STOP; |
| } |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| }; |
| |
| class NoResetNotificationCase : public RobustnessTestCase |
| { |
| public: |
| NoResetNotificationCase(EglTestContext &eglTestCtx, const char *name, const char *description) |
| : RobustnessTestCase(eglTestCtx, name, description) |
| { |
| } |
| |
| TestCase::IterateResult iterate(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << tcu::TestLog::Message |
| << "Check the reset notification strategy returned by glGetIntegerv() equals GL_NO_RESET_NOTIFICATION\n\n" |
| << tcu::TestLog::EndMessage; |
| |
| const EGLint attribList[] = {EGL_CONTEXT_CLIENT_VERSION, |
| 3, |
| EGL_CONTEXT_MINOR_VERSION_KHR, |
| 0, |
| EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, |
| EGL_TRUE, |
| EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, |
| EGL_NO_RESET_NOTIFICATION, |
| EGL_NONE}; |
| |
| checkRequiredEGLExtensions(attribList); |
| |
| RenderingContext context(m_eglTestCtx, attribList, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT); |
| context.makeCurrent(m_eglSurface); |
| |
| glw::Functions gl; |
| { |
| const glu::ApiType apiType(3, 0, glu::PROFILE_ES); |
| context.initGLFunctions(&gl, apiType); |
| checkRequiredGLSupport(gl, apiType); |
| } |
| |
| uint8_t robustAccessGL; |
| gl.getBooleanv(GL_CONTEXT_ROBUST_ACCESS_EXT, &robustAccessGL); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv()"); |
| |
| glw::GLint reset = 0; |
| gl.getIntegerv(GL_RESET_NOTIFICATION_STRATEGY, &reset); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()"); |
| |
| if (reset != GL_NO_RESET_NOTIFICATION) |
| { |
| log << tcu::TestLog::Message << "Test failed! glGetIntegerv() returned wrong value. [" |
| << glu::getErrorStr(reset) << ", expected " << glu::getErrorStr(GL_NO_RESET_NOTIFICATION) << "]" |
| << tcu::TestLog::EndMessage; |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| return STOP; |
| } |
| |
| GLU_CHECK_GLW_CALL(gl, getGraphicsResetStatus()); |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| }; |
| |
| class LoseContextOnResetCase : public RobustnessTestCase |
| { |
| public: |
| LoseContextOnResetCase(EglTestContext &eglTestCtx, const char *name, const char *description) |
| : RobustnessTestCase(eglTestCtx, name, description) |
| { |
| } |
| |
| TestCase::IterateResult iterate(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << tcu::TestLog::Message |
| << "Check the reset notification strategy returned by glGetIntegerv() equals GL_LOSE_CONTEXT_ON_RESET\n\n" |
| << tcu::TestLog::EndMessage; |
| |
| const EGLint attribList[] = {EGL_CONTEXT_CLIENT_VERSION, |
| 3, |
| EGL_CONTEXT_MINOR_VERSION_KHR, |
| 0, |
| EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, |
| EGL_TRUE, |
| EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, |
| EGL_LOSE_CONTEXT_ON_RESET, |
| EGL_NONE}; |
| |
| checkRequiredEGLExtensions(attribList); |
| |
| RenderingContext context(m_eglTestCtx, attribList, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT); |
| context.makeCurrent(m_eglSurface); |
| |
| glw::Functions gl; |
| { |
| const glu::ApiType apiType(3, 0, glu::PROFILE_ES); |
| context.initGLFunctions(&gl, apiType); |
| checkRequiredGLSupport(gl, apiType); |
| } |
| glw::GLint reset = 0; |
| gl.getIntegerv(GL_RESET_NOTIFICATION_STRATEGY, &reset); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()"); |
| |
| if (reset != GL_LOSE_CONTEXT_ON_RESET) |
| { |
| log << tcu::TestLog::Message << "Test failed! glGetIntegerv() returned wrong value. [" << reset |
| << ", expected " << glu::getErrorStr(GL_LOSE_CONTEXT_ON_RESET) << "]" << tcu::TestLog::EndMessage; |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| return STOP; |
| } |
| |
| log << tcu::TestLog::Message << "Check the graphics reset status returned by glGetGraphicsResetStatus() " |
| << "equals GL_NO_ERROR\n" |
| << tcu::TestLog::EndMessage; |
| |
| GLU_CHECK_GLW_CALL(gl, getGraphicsResetStatus()); |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| }; |
| |
| de::SharedPtr<ContextReset> contextResetFactory(const RobustnessTestCase::Params params, glw::Functions &gl, |
| tcu::TestLog &log) |
| { |
| if (params.getContextResetType() == CONTEXTRESETTYPE_FIXED_FUNC_OOB) |
| return de::SharedPtr<ContextReset>(new FixedFunctionOOB(gl, log, params.getFixedFunctionType())); |
| |
| if (params.getContextResetType() == CONTEXTRESETTYPE_SHADER_OOB) |
| return de::SharedPtr<ContextReset>( |
| new ShadersOOB(gl, log, params.getShaderType(), params.getResourceType(), params.getReadWriteType())); |
| else |
| { |
| DE_FATAL("Unknown context reset type"); |
| return de::SharedPtr<ContextReset>(DE_NULL); |
| } |
| } |
| |
| class ContextResetCase : public RobustnessTestCase |
| { |
| |
| public: |
| ContextResetCase(EglTestContext &eglTestCtx, const char *name, const char *description, Params params); |
| virtual ~ContextResetCase(void) |
| { |
| } |
| |
| virtual void provokeReset(de::SharedPtr<ContextReset> &contextReset) = 0; |
| virtual void waitForReset(de::SharedPtr<ContextReset> &contextReset) = 0; |
| virtual void passAndLog(de::SharedPtr<ContextReset> &contextReset) = 0; |
| |
| TestCase::IterateResult iterate(void); |
| void execute(glw::Functions &gl); |
| |
| private: |
| ContextResetCase(const ContextResetCase &); |
| ContextResetCase &operator=(const ContextResetCase &); |
| }; |
| |
| ContextResetCase::ContextResetCase(EglTestContext &eglTestCtx, const char *name, const char *description, Params params) |
| : RobustnessTestCase(eglTestCtx, name, description, params) |
| { |
| } |
| |
| TestCase::IterateResult ContextResetCase::iterate(void) |
| { |
| glw::Functions gl; |
| |
| const EGLint attribList[] = {EGL_CONTEXT_CLIENT_VERSION, |
| 3, |
| EGL_CONTEXT_MINOR_VERSION_KHR, |
| 0, |
| EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, |
| (m_params.getRobustAccessType() == ROBUSTACCESS_TRUE) ? EGL_TRUE : EGL_FALSE, |
| EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, |
| EGL_LOSE_CONTEXT_ON_RESET, |
| EGL_NONE}; |
| |
| checkRequiredEGLExtensions(attribList); |
| |
| RenderingContext context(m_eglTestCtx, attribList, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT); |
| context.makeCurrent(m_eglSurface); |
| |
| { |
| const glu::ApiType apiType = paramsToApiType(m_params); |
| context.initGLFunctions(&gl, apiType); |
| checkGLSupportForParams(gl, m_params); |
| } |
| |
| execute(gl); |
| |
| return STOP; |
| } |
| |
| void ContextResetCase::execute(glw::Functions &gl) |
| { |
| de::SharedPtr<ContextReset> contextReset = contextResetFactory(m_params, gl, m_testCtx.getLog()); |
| glw::GLboolean isContextRobust = GL_FALSE; |
| |
| GLU_CHECK_GLW_CALL(gl, getBooleanv(GL_CONTEXT_ROBUST_ACCESS_EXT, &isContextRobust)); |
| provokeReset(contextReset); |
| |
| if (m_params.getContextResetType() == CONTEXTRESETTYPE_SHADER_OOB || |
| m_params.getContextResetType() == CONTEXTRESETTYPE_FIXED_FUNC_OOB) |
| { |
| try |
| { |
| waitForReset(contextReset); |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Context was NOT lost. Test skipped"); |
| } |
| catch (const glu::Error &error) |
| { |
| if (error.getError() == GL_CONTEXT_LOST) |
| { |
| if (isContextRobust) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, |
| "No context reset should of occurred GL_CONTEXT_ROBUST_ACCESS == TRUE"); |
| else |
| passAndLog(contextReset); |
| } |
| else if (isContextRobust) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got unknown error."); |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, |
| "Warning: glGetError() returned wrong value. Expected GL_CONTEXT_LOST"); |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Warning: glGetError() returned wrong value [" |
| << error.what() << ", expected " << glu::getErrorStr(GL_CONTEXT_LOST) << "]" |
| << tcu::TestLog::EndMessage; |
| } |
| } |
| } |
| else |
| DE_FATAL("Unknown context reset type"); |
| } |
| |
| class BasicResetCase : public ContextResetCase |
| { |
| public: |
| BasicResetCase(EglTestContext &eglTestCtx, const char *name, const char *description, Params params) |
| : ContextResetCase(eglTestCtx, name, description, params) |
| { |
| } |
| |
| virtual void provokeReset(de::SharedPtr<ContextReset> &contextReset) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Check the graphics reset status returned by glGetGraphicsResetStatus() equals " |
| << "GL_GUILTY_CONTEXT_RESET after a context reset\n\n" |
| << tcu::TestLog::EndMessage; |
| |
| contextReset->setup(); |
| contextReset->draw(); |
| } |
| |
| virtual void waitForReset(de::SharedPtr<ContextReset> &contextReset) |
| { |
| contextReset->teardown(); |
| contextReset->finish(); |
| } |
| |
| virtual void passAndLog(de::SharedPtr<ContextReset> &contextReset) |
| { |
| const glw::GLint status = contextReset->getGraphicsResetStatus(); |
| |
| if (status == GL_NO_ERROR) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Test failed! glGetGraphicsResetStatus() returned wrong value [" |
| << glu::getGraphicsResetStatusStr(status) << ", expected " |
| << glu::getGraphicsResetStatusStr(GL_GUILTY_CONTEXT_RESET) << "]" |
| << tcu::TestLog::EndMessage; |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| else |
| { |
| if (contextReset->getError() != GL_NO_ERROR) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, |
| "Error flag not reset after calling getGraphicsResetStatus()"); |
| else |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| } |
| }; |
| |
| class InvalidShareContextCase : public RobustnessTestCase |
| { |
| public: |
| InvalidShareContextCase(EglTestContext &eglTestCtx, const char *name, const char *description) |
| : RobustnessTestCase(eglTestCtx, name, description) |
| { |
| } |
| |
| TestCase::IterateResult iterate(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| const Library &egl = m_eglTestCtx.getLibrary(); |
| bool isOk = true; |
| |
| log << tcu::TestLog::Message |
| << "EGL_BAD_MATCH is generated if reset notification strategies do not match when creating shared " |
| "contexts\n\n" |
| << tcu::TestLog::EndMessage; |
| |
| const EGLint attribListA[] = {EGL_CONTEXT_CLIENT_VERSION, |
| 3, |
| EGL_CONTEXT_MINOR_VERSION_KHR, |
| 0, |
| EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, |
| EGL_TRUE, |
| EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, |
| EGL_NO_RESET_NOTIFICATION, |
| EGL_NONE}; |
| |
| const EGLint attribListB[] = {EGL_CONTEXT_CLIENT_VERSION, |
| 3, |
| EGL_CONTEXT_MINOR_VERSION_KHR, |
| 0, |
| EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, |
| EGL_TRUE, |
| EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, |
| EGL_LOSE_CONTEXT_ON_RESET, |
| EGL_NONE}; |
| |
| checkRequiredEGLExtensions(attribListA); |
| |
| log << tcu::TestLog::Message << "Create context A (share_context = EGL_NO_CONTEXT)" << tcu::TestLog::EndMessage; |
| RenderingContext contextA(m_eglTestCtx, attribListA, m_eglConfig, m_eglDisplay, EGL_NO_CONTEXT); |
| |
| log << tcu::TestLog::Message << "Create context B (share_context = context A)" << tcu::TestLog::EndMessage; |
| logAttribList(m_eglTestCtx, attribListB); |
| |
| EGLContext contextB = egl.createContext(m_eglDisplay, m_eglConfig, contextA.getContext(), attribListB); |
| |
| const EGLenum error = egl.getError(); |
| if (error != EGL_BAD_MATCH) |
| { |
| log << TestLog::Message << "Test failed! eglCreateContext() returned with error [" |
| << eglu::getErrorStr(error) << ", expected " << eglu::getErrorStr(EGL_BAD_MATCH) << "]" |
| << TestLog::EndMessage; |
| |
| isOk = false; |
| } |
| |
| if (contextB != EGL_NO_CONTEXT) |
| egl.destroyContext(m_eglDisplay, contextB); |
| |
| if (isOk) |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| else |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| |
| return STOP; |
| } |
| }; |
| |
| class InvalidNotificationEnumCase : public RobustnessTestCase |
| { |
| public: |
| InvalidNotificationEnumCase(EglTestContext &eglTestCtx, const char *name, const char *description) |
| : RobustnessTestCase(eglTestCtx, name, description) |
| { |
| } |
| |
| TestCase::IterateResult iterate(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| const Library &egl = m_eglTestCtx.getLibrary(); |
| bool isOk = true; |
| |
| log << tcu::TestLog::Message |
| << "EGL_BAD_ATTRIBUTE is generated if EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR is used with EGL " |
| "versions <= 1.4\n\n" |
| << tcu::TestLog::EndMessage; |
| |
| const EGLint attribList[] = {EGL_CONTEXT_CLIENT_VERSION, |
| 3, |
| EGL_CONTEXT_MINOR_VERSION_KHR, |
| 1, |
| EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR, |
| EGL_NO_RESET_NOTIFICATION, |
| EGL_NONE}; |
| |
| if (eglu::getVersion(egl, m_eglDisplay) >= eglu::Version(1, 5)) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Test requires EGL version to be under 1.5"); |
| return STOP; |
| } |
| |
| logAttribList(m_eglTestCtx, attribList); |
| EGLContext context = egl.createContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, attribList); |
| |
| const EGLenum error = egl.getError(); |
| if (error != EGL_BAD_ATTRIBUTE) |
| { |
| log << TestLog::Message << "Test failed! eglCreateContext() returned with error [" |
| << eglu::getErrorStr(error) << ", expected " << eglu::getErrorStr(EGL_BAD_ATTRIBUTE) << "]" |
| << TestLog::EndMessage; |
| |
| isOk = false; |
| } |
| |
| if (context != EGL_NO_CONTEXT) |
| egl.destroyContext(m_eglDisplay, context); |
| |
| if (isOk) |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| else |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| |
| return STOP; |
| } |
| }; |
| |
| class InvalidContextCase : public RobustnessTestCase |
| { |
| public: |
| InvalidContextCase(EglTestContext &eglTestCtx, const char *name, const char *description) |
| : RobustnessTestCase(eglTestCtx, name, description) |
| { |
| } |
| |
| TestCase::IterateResult iterate(void) |
| { |
| const Library &egl = m_eglTestCtx.getLibrary(); |
| TestLog &log = m_testCtx.getLog(); |
| bool isOk = true; |
| |
| log << tcu::TestLog::Message |
| << "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" |
| << tcu::TestLog::EndMessage; |
| |
| const EGLint attribList[] = {EGL_CONTEXT_CLIENT_VERSION, |
| 3, |
| EGL_CONTEXT_MINOR_VERSION_KHR, |
| 0, |
| EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, |
| EGL_LOSE_CONTEXT_ON_RESET, |
| EGL_NONE}; |
| |
| if (eglu::hasExtension(egl, m_eglDisplay, "EGL_EXT_create_context_robustness")) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, |
| "Test requires EGL_EXT_create_context_robustness to be unsupported"); |
| return STOP; |
| } |
| |
| logAttribList(m_eglTestCtx, attribList); |
| EGLContext context = egl.createContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, attribList); |
| |
| const EGLenum error = egl.getError(); |
| if (error != EGL_BAD_ATTRIBUTE) |
| { |
| log << TestLog::Message << "Test failed! eglCreateContext() returned with error [" |
| << eglu::getErrorStr(error) << ", expected " << eglu::getErrorStr(EGL_BAD_ATTRIBUTE) << "]" |
| << TestLog::EndMessage; |
| |
| isOk = false; |
| } |
| |
| if (context != EGL_NO_CONTEXT) |
| egl.destroyContext(m_eglDisplay, context); |
| |
| if (isOk) |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| else |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| |
| return STOP; |
| } |
| }; |
| |
| } // namespace |
| |
| // Note: Tests limited to openGLES 3.1 contexts only |
| TestCaseGroup *createRobustnessTests(EglTestContext &eglTestCtx) |
| { |
| de::MovePtr<TestCaseGroup> group(new TestCaseGroup(eglTestCtx, "robustness", "KHR_robustness tests")); |
| |
| tcu::TestCaseGroup *const contextCreationTestGroup = |
| new TestCaseGroup(eglTestCtx, "create_context", "Test valid context_creation attributes"); |
| tcu::TestCaseGroup *const contextResetTestGroup = |
| new TestCaseGroup(eglTestCtx, "reset_context", "Test context resets scenarios"); |
| tcu::TestCaseGroup *const negativeContextTestGroup = |
| new TestCaseGroup(eglTestCtx, "negative_context", "Test invalid context creation attributes"); |
| |
| tcu::TestCaseGroup *const shadersTestGroup = |
| new TestCaseGroup(eglTestCtx, "shaders", "Shader specific context reset tests"); |
| tcu::TestCaseGroup *const fixedFunctionTestGroup = new TestCaseGroup( |
| eglTestCtx, "fixed_function_pipeline", "Fixed function pipeline context reset tests with robust context"); |
| tcu::TestCaseGroup *const fixedFunctionNonRobustTestGroup = |
| new TestCaseGroup(eglTestCtx, "fixed_function_pipeline_non_robust", |
| "Fixed function pipeline context reset tests with non-robust context"); |
| |
| tcu::TestCaseGroup *const outOfBoundsTestGroup = |
| new TestCaseGroup(eglTestCtx, "out_of_bounds", "Out of bounds access scenarios with robust context"); |
| |
| tcu::TestCaseGroup *const outOfBoundsNonRobustTestGroup = new TestCaseGroup( |
| eglTestCtx, "out_of_bounds_non_robust", "Out of bounds access scenarios with non-robust context"); |
| |
| const string resetScenarioDescription = "query error states and reset notifications"; |
| |
| // out-of-bounds test cases |
| { |
| // robust context |
| tcu::TestCaseGroup *const uboReadArrayResetTestGroup = |
| new TestCaseGroup(eglTestCtx, "uniform_block", "Uniform Block Accesses"); |
| tcu::TestCaseGroup *const uboWriteArrayResetTestGroup = |
| new TestCaseGroup(eglTestCtx, "uniform_block", "Uniform Block Accesses"); |
| tcu::TestCaseGroup *const ssboWriteArrayResetTestGroup = |
| new TestCaseGroup(eglTestCtx, "shader_storage_block", "Shader Storage Block accesses"); |
| tcu::TestCaseGroup *const ssboReadArrayResetTestGroup = |
| new TestCaseGroup(eglTestCtx, "shader_storage_block", "Shader Storage Block accesses"); |
| tcu::TestCaseGroup *const localWriteArrayResetTestGroup = |
| new TestCaseGroup(eglTestCtx, "local_array", "Local array accesses"); |
| tcu::TestCaseGroup *const localReadArrayResetTestGroup = |
| new TestCaseGroup(eglTestCtx, "local_array", "Local array accesses"); |
| |
| // non-robust context (internal use only) |
| tcu::TestCaseGroup *const uboReadArrayResetNonRobustTestGroup = |
| new TestCaseGroup(eglTestCtx, "uniform_block", "Uniform Block Accesses"); |
| tcu::TestCaseGroup *const uboWriteArrayResetNonRobustTestGroup = |
| new TestCaseGroup(eglTestCtx, "uniform_block", "Uniform Block Accesses"); |
| tcu::TestCaseGroup *const ssboWriteArrayResetNonRobustTestGroup = |
| new TestCaseGroup(eglTestCtx, "shader_storage_block", "Shader Storage Block accesses"); |
| tcu::TestCaseGroup *const ssboReadArrayResetNonRobustTestGroup = |
| new TestCaseGroup(eglTestCtx, "shader_storage_block", "Shader Storage Block accesses"); |
| tcu::TestCaseGroup *const localWriteArrayResetNonRobustTestGroup = |
| new TestCaseGroup(eglTestCtx, "local_array", "Local array accesses"); |
| tcu::TestCaseGroup *const localReadArrayResetNonRobustTestGroup = |
| new TestCaseGroup(eglTestCtx, "local_array", "Local array accesses"); |
| |
| static const RobustnessTestCase::Params s_outOfBoundReadCases[] = { |
| // ubo read only |
| RobustnessTestCase::Params("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_UBO, |
| READWRITETYPE_READ), |
| RobustnessTestCase::Params("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_UBO, |
| READWRITETYPE_READ), |
| 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), |
| RobustnessTestCase::Params("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_UBO, |
| READWRITETYPE_READ), |
| |
| // ssbo read only |
| RobustnessTestCase::Params("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_SSBO, |
| READWRITETYPE_READ), |
| RobustnessTestCase::Params("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_SSBO, |
| READWRITETYPE_READ), |
| 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), |
| RobustnessTestCase::Params("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_SSBO, |
| READWRITETYPE_READ), |
| |
| // local array read only |
| RobustnessTestCase::Params("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_LOCAL_ARRAY, |
| READWRITETYPE_READ), |
| RobustnessTestCase::Params("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_LOCAL_ARRAY, |
| READWRITETYPE_READ), |
| 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), |
| RobustnessTestCase::Params("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_LOCAL_ARRAY, |
| READWRITETYPE_READ), |
| |
| // ubo read only (non-robust) |
| RobustnessTestCase::Params("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_FALSE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_UBO, |
| READWRITETYPE_READ), |
| RobustnessTestCase::Params("fragment", "Provoke a context reset in fragment shader and ", |
| ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, |
| RESOURCETYPE_UBO, READWRITETYPE_READ), |
| 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), |
| RobustnessTestCase::Params("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_FALSE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_UBO, |
| READWRITETYPE_READ), |
| |
| // ssbo read only (non-robust) |
| RobustnessTestCase::Params("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_FALSE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_SSBO, |
| READWRITETYPE_READ), |
| RobustnessTestCase::Params("fragment", "Provoke a context reset in fragment shader and ", |
| ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, |
| RESOURCETYPE_SSBO, READWRITETYPE_READ), |
| 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), |
| RobustnessTestCase::Params("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_FALSE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_SSBO, |
| READWRITETYPE_READ), |
| |
| // local array read only (non-robust) |
| RobustnessTestCase::Params("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_FALSE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_LOCAL_ARRAY, |
| READWRITETYPE_READ), |
| RobustnessTestCase::Params("fragment", "Provoke a context reset in fragment shader and ", |
| ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, |
| RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_READ), |
| 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), |
| RobustnessTestCase::Params("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_FALSE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_LOCAL_ARRAY, |
| READWRITETYPE_READ), |
| }; |
| |
| for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(s_outOfBoundReadCases); ++testNdx) |
| { |
| const RobustnessTestCase::Params &test = s_outOfBoundReadCases[testNdx]; |
| |
| if (test.getResourceType() == RESOURCETYPE_UBO && test.getRobustAccessType() == ROBUSTACCESS_TRUE) |
| uboReadArrayResetTestGroup->addChild( |
| new BasicResetCase(eglTestCtx, test.getName().c_str(), |
| (test.getDescription() + resetScenarioDescription).c_str(), test)); |
| |
| if (test.getResourceType() == RESOURCETYPE_UBO && test.getRobustAccessType() == ROBUSTACCESS_FALSE) |
| uboReadArrayResetNonRobustTestGroup->addChild( |
| new BasicResetCase(eglTestCtx, test.getName().c_str(), |
| (test.getDescription() + resetScenarioDescription).c_str(), test)); |
| |
| if (test.getResourceType() == RESOURCETYPE_SSBO && test.getRobustAccessType() == ROBUSTACCESS_TRUE) |
| ssboReadArrayResetTestGroup->addChild( |
| new BasicResetCase(eglTestCtx, test.getName().c_str(), |
| (test.getDescription() + resetScenarioDescription).c_str(), test)); |
| |
| if (test.getResourceType() == RESOURCETYPE_SSBO && test.getRobustAccessType() == ROBUSTACCESS_FALSE) |
| ssboReadArrayResetNonRobustTestGroup->addChild( |
| new BasicResetCase(eglTestCtx, test.getName().c_str(), |
| (test.getDescription() + resetScenarioDescription).c_str(), test)); |
| |
| if (test.getResourceType() == RESOURCETYPE_LOCAL_ARRAY && test.getRobustAccessType() == ROBUSTACCESS_TRUE) |
| localReadArrayResetTestGroup->addChild( |
| new BasicResetCase(eglTestCtx, test.getName().c_str(), |
| (test.getDescription() + resetScenarioDescription).c_str(), test)); |
| |
| if (test.getResourceType() == RESOURCETYPE_LOCAL_ARRAY && test.getRobustAccessType() == ROBUSTACCESS_FALSE) |
| localReadArrayResetNonRobustTestGroup->addChild( |
| new BasicResetCase(eglTestCtx, test.getName().c_str(), |
| (test.getDescription() + resetScenarioDescription).c_str(), test)); |
| } |
| |
| static const RobustnessTestCase::Params s_outOfBoundWriteCases[] = { |
| // ubo write only |
| RobustnessTestCase::Params("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_UBO, |
| READWRITETYPE_WRITE), |
| RobustnessTestCase::Params("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_UBO, |
| READWRITETYPE_WRITE), |
| 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), |
| RobustnessTestCase::Params("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_UBO, |
| READWRITETYPE_WRITE), |
| |
| // ssbo write only |
| RobustnessTestCase::Params("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_SSBO, |
| READWRITETYPE_WRITE), |
| RobustnessTestCase::Params("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_SSBO, |
| READWRITETYPE_WRITE), |
| 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), |
| RobustnessTestCase::Params("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_SSBO, |
| READWRITETYPE_WRITE), |
| |
| // local array write only |
| RobustnessTestCase::Params("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_LOCAL_ARRAY, |
| READWRITETYPE_WRITE), |
| RobustnessTestCase::Params("fragment", "Provoke a context reset in fragment shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, RESOURCETYPE_LOCAL_ARRAY, |
| READWRITETYPE_WRITE), |
| 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), |
| RobustnessTestCase::Params("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_TRUE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_LOCAL_ARRAY, |
| READWRITETYPE_WRITE), |
| |
| // ubo write only (non-robust) |
| RobustnessTestCase::Params("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_FALSE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_UBO, |
| READWRITETYPE_WRITE), |
| RobustnessTestCase::Params("fragment", "Provoke a context reset in fragment shader and ", |
| ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, |
| RESOURCETYPE_UBO, READWRITETYPE_WRITE), |
| 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), |
| RobustnessTestCase::Params("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_FALSE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_UBO, |
| READWRITETYPE_WRITE), |
| |
| // ssbo write only (non-robust) |
| RobustnessTestCase::Params("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_FALSE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_SSBO, |
| READWRITETYPE_WRITE), |
| RobustnessTestCase::Params("fragment", "Provoke a context reset in fragment shader and ", |
| ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, |
| RESOURCETYPE_SSBO, READWRITETYPE_WRITE), |
| 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), |
| RobustnessTestCase::Params("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_FALSE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_SSBO, |
| READWRITETYPE_WRITE), |
| |
| // local array write only (non-robust) |
| RobustnessTestCase::Params("vertex", "Provoke a context reset in vertex shader and ", ROBUSTACCESS_FALSE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_VERT, RESOURCETYPE_LOCAL_ARRAY, |
| READWRITETYPE_WRITE), |
| RobustnessTestCase::Params("fragment", "Provoke a context reset in fragment shader and ", |
| ROBUSTACCESS_FALSE, CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_FRAG, |
| RESOURCETYPE_LOCAL_ARRAY, READWRITETYPE_WRITE), |
| 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), |
| RobustnessTestCase::Params("compute", "Provoke a context reset in compute shader and ", ROBUSTACCESS_FALSE, |
| CONTEXTRESETTYPE_SHADER_OOB, SHADERTYPE_COMPUTE, RESOURCETYPE_LOCAL_ARRAY, |
| READWRITETYPE_WRITE), |
| }; |
| |
| for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(s_outOfBoundWriteCases); ++testNdx) |
| { |
| const RobustnessTestCase::Params &test = s_outOfBoundWriteCases[testNdx]; |
| |
| if (test.getResourceType() == RESOURCETYPE_UBO && test.getRobustAccessType() == ROBUSTACCESS_TRUE) |
| uboWriteArrayResetTestGroup->addChild( |
| new BasicResetCase(eglTestCtx, test.getName().c_str(), |
| (test.getDescription() + resetScenarioDescription).c_str(), test)); |
| |
| if (test.getResourceType() == RESOURCETYPE_UBO && test.getRobustAccessType() == ROBUSTACCESS_FALSE) |
| uboWriteArrayResetNonRobustTestGroup->addChild( |
| new BasicResetCase(eglTestCtx, test.getName().c_str(), |
| (test.getDescription() + resetScenarioDescription).c_str(), test)); |
| |
| if (test.getResourceType() == RESOURCETYPE_SSBO && test.getRobustAccessType() == ROBUSTACCESS_TRUE) |
| ssboWriteArrayResetTestGroup->addChild( |
| new BasicResetCase(eglTestCtx, test.getName().c_str(), |
| (test.getDescription() + resetScenarioDescription).c_str(), test)); |
| |
| if (test.getResourceType() == RESOURCETYPE_SSBO && test.getRobustAccessType() == ROBUSTACCESS_FALSE) |
| ssboWriteArrayResetNonRobustTestGroup->addChild( |
| new BasicResetCase(eglTestCtx, test.getName().c_str(), |
| (test.getDescription() + resetScenarioDescription).c_str(), test)); |
| |
| if (test.getResourceType() == RESOURCETYPE_LOCAL_ARRAY && test.getRobustAccessType() == ROBUSTACCESS_TRUE) |
| localWriteArrayResetTestGroup->addChild( |
| new BasicResetCase(eglTestCtx, test.getName().c_str(), |
| (test.getDescription() + resetScenarioDescription).c_str(), test)); |
| |
| if (test.getResourceType() == RESOURCETYPE_LOCAL_ARRAY && test.getRobustAccessType() == ROBUSTACCESS_FALSE) |
| localWriteArrayResetNonRobustTestGroup->addChild( |
| new BasicResetCase(eglTestCtx, test.getName().c_str(), |
| (test.getDescription() + resetScenarioDescription).c_str(), test)); |
| } |
| |
| // robust Context |
| tcu::TestCaseGroup *const outOfBoundsResetReadAccessTestGroup = |
| new TestCaseGroup(eglTestCtx, "reads", "Out of bounds read accesses"); |
| tcu::TestCaseGroup *const outOfBoundsResetWriteAccessTestGroup = |
| new TestCaseGroup(eglTestCtx, "writes", "Out of bounds write accesses"); |
| |
| outOfBoundsResetReadAccessTestGroup->addChild(uboReadArrayResetTestGroup); |
| outOfBoundsResetReadAccessTestGroup->addChild(ssboReadArrayResetTestGroup); |
| outOfBoundsResetReadAccessTestGroup->addChild(localReadArrayResetTestGroup); |
| |
| outOfBoundsResetWriteAccessTestGroup->addChild(uboWriteArrayResetTestGroup); |
| outOfBoundsResetWriteAccessTestGroup->addChild(ssboWriteArrayResetTestGroup); |
| outOfBoundsResetWriteAccessTestGroup->addChild(localWriteArrayResetTestGroup); |
| |
| tcu::TestCaseGroup *const outOfBoundsResetTestGroup = new TestCaseGroup( |
| eglTestCtx, "reset_status", "Tests that query the reset status after a context reset has occurred"); |
| |
| outOfBoundsResetTestGroup->addChild(outOfBoundsResetReadAccessTestGroup); |
| outOfBoundsResetTestGroup->addChild(outOfBoundsResetWriteAccessTestGroup); |
| |
| outOfBoundsTestGroup->addChild(outOfBoundsResetTestGroup); |
| |
| // non-robust Context (internal use only) |
| tcu::TestCaseGroup *const outOfBoundsResetReadAccessNonRobustTestGroup = |
| new TestCaseGroup(eglTestCtx, "reads", "Out of bounds read accesses"); |
| tcu::TestCaseGroup *const outOfBoundsResetWriteAccessNonRobustTestGroup = |
| new TestCaseGroup(eglTestCtx, "writes", "Out of bounds write accesses"); |
| |
| outOfBoundsResetReadAccessNonRobustTestGroup->addChild(uboReadArrayResetNonRobustTestGroup); |
| outOfBoundsResetReadAccessNonRobustTestGroup->addChild(ssboReadArrayResetNonRobustTestGroup); |
| outOfBoundsResetReadAccessNonRobustTestGroup->addChild(localReadArrayResetNonRobustTestGroup); |
| |
| outOfBoundsResetWriteAccessNonRobustTestGroup->addChild(uboWriteArrayResetNonRobustTestGroup); |
| outOfBoundsResetWriteAccessNonRobustTestGroup->addChild(ssboWriteArrayResetNonRobustTestGroup); |
| outOfBoundsResetWriteAccessNonRobustTestGroup->addChild(localWriteArrayResetNonRobustTestGroup); |
| |
| tcu::TestCaseGroup *const outOfBoundsResetNonRobustTestGroup = new TestCaseGroup( |
| eglTestCtx, "reset_status", "Tests that query the reset status after a context reset has occurred"); |
| |
| outOfBoundsResetNonRobustTestGroup->addChild(outOfBoundsResetReadAccessNonRobustTestGroup); |
| outOfBoundsResetNonRobustTestGroup->addChild(outOfBoundsResetWriteAccessNonRobustTestGroup); |
| |
| outOfBoundsNonRobustTestGroup->addChild(outOfBoundsResetNonRobustTestGroup); |
| } |
| |
| // fixed function test cases |
| { |
| // robust context |
| tcu::TestCaseGroup *const fixedFunctionResetStatusTestGroup = new TestCaseGroup( |
| eglTestCtx, "reset_status", "Tests that query the reset status after a context reset has occurred"); |
| |
| // non-robust context (internal use only) |
| tcu::TestCaseGroup *const fixedFunctionResetStatusNonRobustTestGroup = new TestCaseGroup( |
| eglTestCtx, "reset_status", "Tests that query the reset status after a context reset has occurred"); |
| |
| static const RobustnessTestCase::Params s_fixedFunctionPipelineCases[] = { |
| 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), |
| 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), |
| |
| 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), |
| 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), |
| }; |
| |
| for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(s_fixedFunctionPipelineCases); ++testNdx) |
| { |
| const RobustnessTestCase::Params &test = s_fixedFunctionPipelineCases[testNdx]; |
| if (test.getRobustAccessType() == ROBUSTACCESS_TRUE) |
| fixedFunctionResetStatusTestGroup->addChild( |
| new BasicResetCase(eglTestCtx, test.getName().c_str(), test.getDescription().c_str(), test)); |
| else |
| fixedFunctionResetStatusNonRobustTestGroup->addChild( |
| new BasicResetCase(eglTestCtx, test.getName().c_str(), test.getDescription().c_str(), test)); |
| } |
| |
| fixedFunctionTestGroup->addChild(fixedFunctionResetStatusTestGroup); |
| fixedFunctionNonRobustTestGroup->addChild(fixedFunctionResetStatusNonRobustTestGroup); |
| } |
| |
| // context creation query cases |
| { |
| contextCreationTestGroup->addChild(new QueryRobustAccessCase( |
| eglTestCtx, "query_robust_access", "Query robust access after successfully creating a robust context")); |
| contextCreationTestGroup->addChild( |
| new NoResetNotificationCase(eglTestCtx, "no_reset_notification", |
| "Query reset notification strategy after specifying GL_NO_RESET_NOTIFICATION")); |
| contextCreationTestGroup->addChild( |
| new LoseContextOnResetCase(eglTestCtx, "lose_context_on_reset", |
| "Query reset notification strategy after specifying GL_LOSE_CONTEXT_ON_RESET")); |
| } |
| |
| // invalid context creation cases |
| { |
| negativeContextTestGroup->addChild( |
| new InvalidContextCase(eglTestCtx, "invalid_robust_context_creation", |
| "Create a non-robust context but specify a reset notification strategy")); |
| negativeContextTestGroup->addChild( |
| new InvalidShareContextCase(eglTestCtx, "invalid_robust_shared_context_creation", |
| "Create a context share group with conflicting reset notification strategies")); |
| negativeContextTestGroup->addChild(new InvalidNotificationEnumCase( |
| eglTestCtx, "invalid_notification_strategy_enum", |
| "Create a robust context using EGL 1.5 only enum with EGL versions <= 1.4")); |
| } |
| |
| shadersTestGroup->addChild(outOfBoundsTestGroup); |
| shadersTestGroup->addChild(outOfBoundsNonRobustTestGroup); |
| |
| contextResetTestGroup->addChild(shadersTestGroup); |
| contextResetTestGroup->addChild(fixedFunctionTestGroup); |
| contextResetTestGroup->addChild(fixedFunctionNonRobustTestGroup); |
| |
| group->addChild(contextCreationTestGroup); |
| group->addChild(contextResetTestGroup); |
| group->addChild(negativeContextTestGroup); |
| |
| return group.release(); |
| } |
| |
| } // namespace egl |
| } // namespace deqp |
