/*-------------------------------------------------------------------------
* drawElements Quality Program EGL Module
* ---------------------------------------
*
* Copyright 2014 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 Simple context construction test for EGL_KHR_create_context.
*//*--------------------------------------------------------------------*/
#include "teglCreateContextExtTests.hpp"
#include "tcuTestLog.hpp"
#include "egluNativeDisplay.hpp"
#include "egluNativeWindow.hpp"
#include "egluNativePixmap.hpp"
#include "egluConfigFilter.hpp"
#include "egluStrUtil.hpp"
#include "egluUtil.hpp"
#include "gluDefs.hpp"
#include "gluRenderConfig.hpp"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"
#include "deStringUtil.hpp"
#include "deUniquePtr.hpp"
#include <EGL/eglext.h>
#include <string>
#include <vector>
#include <set>
#include <sstream>
#include <cstring>
// \note Taken from official EGL/eglext.h. EGL_EGLEXT_VERSION 20131028
#ifndef EGL_KHR_create_context
#define EGL_KHR_create_context 1
#define EGL_CONTEXT_MAJOR_VERSION_KHR 0x3098
#define EGL_CONTEXT_MINOR_VERSION_KHR 0x30FB
#define EGL_CONTEXT_FLAGS_KHR 0x30FC
#define EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR 0x30FD
#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR 0x31BD
#define EGL_NO_RESET_NOTIFICATION_KHR 0x31BE
#define EGL_LOSE_CONTEXT_ON_RESET_KHR 0x31BF
#define EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR 0x00000001
#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR 0x00000002
#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR 0x00000004
#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR 0x00000001
#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR 0x00000002
#define EGL_OPENGL_ES3_BIT_KHR 0x00000040
#endif /* EGL_KHR_create_context */
#ifndef EGL_EXT_create_context_robustness
#define EGL_EXT_create_context_robustness 1
#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT 0x30BF
#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT 0x3138
#define EGL_NO_RESET_NOTIFICATION_EXT 0x31BE
#define EGL_LOSE_CONTEXT_ON_RESET_EXT 0x31BF
#endif /* EGL_EXT_create_context_robustness */
// \note Taken from official GLES2/gl2ext.h. Generated on date 20131202.
#ifndef GL_EXT_robustness
#define GL_EXT_robustness 1
#define GL_GUILTY_CONTEXT_RESET_EXT 0x8253
#define GL_INNOCENT_CONTEXT_RESET_EXT 0x8254
#define GL_UNKNOWN_CONTEXT_RESET_EXT 0x8255
#define GL_CONTEXT_ROBUST_ACCESS_EXT 0x90F3
#define GL_RESET_NOTIFICATION_STRATEGY_EXT 0x8256
#define GL_LOSE_CONTEXT_ON_RESET_EXT 0x8252
#define GL_NO_RESET_NOTIFICATION_EXT 0x8261
#endif /* GL_EXT_robustness */
#ifndef GL_ARB_robustness
/* reuse GL_NO_ERROR */
#define GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB 0x00000004
#define GL_LOSE_CONTEXT_ON_RESET_ARB 0x8252
#define GL_GUILTY_CONTEXT_RESET_ARB 0x8253
#define GL_INNOCENT_CONTEXT_RESET_ARB 0x8254
#define GL_UNKNOWN_CONTEXT_RESET_ARB 0x8255
#define GL_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
#define GL_NO_RESET_NOTIFICATION_ARB 0x8261
#endif
using std::set;
using std::string;
using std::vector;
using tcu::TestLog;
namespace deqp
{
namespace egl
{
namespace
{
size_t getAttribListLength (const EGLint* attribList)
{
size_t size = 0;
while (attribList[size] != EGL_NONE)
size++;
return size + 1;
}
string eglContextFlagsToString (EGLint flags)
{
std::ostringstream stream;
if (flags == 0)
stream << "<None>";
else
{
bool first = true;
if ((flags & EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR) != 0)
{
if (!first)
stream << "|";
first = false;
stream << "EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR";
}
if ((flags & EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR) != 0)
{
if (!first)
stream << "|";
first = false;
stream << "EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR";
}
if ((flags & EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR) != 0)
{
if (!first)
stream << "|";
stream << "EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR";
}
}
return stream.str();
}
string eglProfileMaskToString (EGLint mask)
{
std::ostringstream stream;
if (mask == 0)
stream << "<None>";
else
{
bool first = true;
if ((mask & EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR) != 0)
{
if (!first)
stream << "|";
first = false;
stream << "EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR";
}
if ((mask & EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR) != 0)
{
if (!first)
stream << "|";
stream << "EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR";
}
}
return stream.str();
}
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>";
}
}
class CreateContextExtCase : public TestCase
{
public:
CreateContextExtCase (EglTestContext& eglTestCtx, EGLenum api, const EGLint* attribList, const eglu::FilterList& filter, const char* name, const char* description);
~CreateContextExtCase (void);
void executeForConfig (tcu::egl::Display& display, EGLConfig config, tcu::egl::Surface& surface);
void init (void);
void deinit (void);
IterateResult iterate (void);
void checkRequiredExtensions (void);
void logAttribList (void);
bool validateCurrentContext (const glw::Functions& gl);
private:
bool m_isOk;
int m_iteration;
const eglu::FilterList m_filter;
vector<EGLint> m_attribList;
const EGLenum m_api;
vector<EGLConfig> m_configs;
glu::ContextType m_glContextType;
};
glu::ContextType attribListToContextType (EGLenum api, const EGLint* attribList)
{
EGLint majorVersion = 1;
EGLint minorVersion = 0;
glu::ContextFlags flags = glu::ContextFlags(0);
glu::Profile profile = api == EGL_OPENGL_ES_API ? glu::PROFILE_ES : glu::PROFILE_CORE;
const EGLint* iter = attribList;
while((*iter) != EGL_NONE)
{
switch (*iter)
{
case EGL_CONTEXT_MAJOR_VERSION_KHR:
iter++;
majorVersion = (*iter);
iter++;
break;
case EGL_CONTEXT_MINOR_VERSION_KHR:
iter++;
minorVersion = (*iter);
iter++;
break;
case EGL_CONTEXT_FLAGS_KHR:
iter++;
if ((*iter & EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR) != 0)
flags = flags | glu::CONTEXT_ROBUST;
if ((*iter & EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR) != 0)
flags = flags | glu::CONTEXT_DEBUG;
if ((*iter & EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR) != 0)
flags = flags | glu::CONTEXT_FORWARD_COMPATIBLE;
iter++;
break;
case EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR:
iter++;
if (*iter == EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR)
profile = glu::PROFILE_COMPATIBILITY;
else if (*iter != EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR)
throw tcu::InternalError("Indeterminate OpenGL profile");
iter++;
break;
case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR:
iter += 2;
break;
case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT:
iter += 2;
break;
case EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT:
iter += 2;
break;
default:
DE_ASSERT(DE_FALSE);
}
}
return glu::ContextType(majorVersion, minorVersion, profile, flags);
}
CreateContextExtCase::CreateContextExtCase (EglTestContext& eglTestCtx, EGLenum api, const EGLint* attribList, const eglu::FilterList& filter, const char* name, const char* description)
: TestCase (eglTestCtx, name, description)
, m_isOk (true)
, m_iteration (0)
, m_filter (filter)
, m_attribList (attribList, attribList + getAttribListLength(attribList))
, m_api (api)
, m_glContextType (attribListToContextType(api, attribList))
{
}
CreateContextExtCase::~CreateContextExtCase (void)
{
deinit();
}
void CreateContextExtCase::init (void)
{
vector<EGLConfig> configs;
m_eglTestCtx.getDisplay().getConfigs(configs);
for (int configNdx = 0; configNdx < (int)configs.size(); configNdx++)
{
if (m_filter.match(m_eglTestCtx.getDisplay().getEGLDisplay(), configs[configNdx]))
m_configs.push_back(configs[configNdx]);
}
}
void CreateContextExtCase::deinit (void)
{
m_attribList = vector<EGLint>();
m_configs = vector<EGLConfig>();
}
void CreateContextExtCase::logAttribList (void)
{
const EGLint* iter = &(m_attribList[0]);
std::ostringstream attribListString;
while ((*iter) != EGL_NONE)
{
switch (*iter)
{
case EGL_CONTEXT_MAJOR_VERSION_KHR:
iter++;
attribListString << "EGL_CONTEXT_MAJOR_VERSION_KHR(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_FLAGS_KHR:
iter++;
attribListString << "EGL_CONTEXT_FLAGS_KHR, " << eglContextFlagsToString(*iter) << ", ";
iter++;
break;
case EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR:
iter++;
attribListString << "EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR, " << eglProfileMaskToString(*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_ASSERT(DE_FALSE);
}
}
attribListString << "EGL_NONE";
m_testCtx.getLog() << TestLog::Message << "EGL attrib list: { " << attribListString.str() << " }" << TestLog::EndMessage;
}
void CreateContextExtCase::checkRequiredExtensions (void)
{
bool isOk = true;
set<string> requiredExtensions;
vector<string> extensions;
m_eglTestCtx.getDisplay().getExtensions(extensions);
{
const EGLint* iter = &(m_attribList[0]);
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_FLAGS_KHR:
iter++;
requiredExtensions.insert("EGL_KHR_create_context");
iter++;
break;
case EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR:
iter++;
requiredExtensions.insert("EGL_KHR_create_context");
iter++;
break;
case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR:
iter++;
requiredExtensions.insert("EGL_KHR_create_context");
iter++;
break;
case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT:
iter++;
requiredExtensions.insert("EGL_EXT_create_context_robustness");
iter++;
break;
case EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT:
iter++;
requiredExtensions.insert("EGL_EXT_create_context_robustness");
iter++;
break;
default:
DE_ASSERT(DE_FALSE);
}
}
}
for (std::set<string>::const_iterator reqExt = requiredExtensions.begin(); reqExt != requiredExtensions.end(); ++reqExt)
{
bool found = false;
for (int extNdx = 0; extNdx < (int)extensions.size(); extNdx++)
{
if (*reqExt == extensions[extNdx])
found = true;
}
if (!found)
{
m_testCtx.getLog() << TestLog::Message << "Required extension '" << (*reqExt) << "' not supported" << TestLog::EndMessage;
isOk = false;
}
}
if (!isOk)
throw tcu::NotSupportedError("Required extensions not supported", "", __FILE__, __LINE__);
}
bool hasExtension (const glw::Functions& gl, const char* extension)
{
std::istringstream stream((const char*)gl.getString(GL_EXTENSIONS));
string ext;
while (std::getline(stream, ext, ' '))
{
if (ext == extension)
return true;
}
return false;
}
bool checkVersionString (TestLog& log, const glw::Functions& gl, bool desktop, int major, int minor)
{
const char* const versionStr = (const char*)gl.getString(GL_VERSION);
const char* iter = versionStr;
int majorVersion = 0;
int minorVersion = 0;
// Check embedded version prefixes
if (!desktop)
{
const char* prefix = NULL;
const char* prefixIter = NULL;
if (major == 1)
prefix = "OpenGL ES-CM ";
else
prefix = "OpenGL ES ";
prefixIter = prefix;
while (*prefixIter)
{
if ((*prefixIter) != (*iter))
{
log << TestLog::Message << "Invalid version string prefix. Expected '" << prefix << "'." << TestLog::EndMessage;
return false;
}
prefixIter++;
iter++;
}
}
while ((*iter) && (*iter) != '.')
{
const int val = (*iter) - '0';
// Not a number
if (val < 0 || val > 9)
{
log << TestLog::Message << "Failed to parse major version number. Not a number." << TestLog::EndMessage;
return false;
}
// Leading zero
if (majorVersion == 0 && val == 0)
{
log << TestLog::Message << "Failed to parse major version number. Begins with zero." << TestLog::EndMessage;
return false;
}
majorVersion = majorVersion * 10 + val;
iter++;
}
// Invalid format
if ((*iter) != '.')
{
log << TestLog::Message << "Failed to parse version. Expected '.' after major version number." << TestLog::EndMessage;
return false;
}
iter++;
while ((*iter) && (*iter) != ' ' && (*iter) != '.')
{
const int val = (*iter) - '0';
// Not a number
if (val < 0 || val > 9)
{
log << TestLog::Message << "Failed to parse minor version number. Not a number." << TestLog::EndMessage;
return false;
}
// Leading zero
if (minorVersion == 0 && val == 0)
{
// Leading zeros in minor version
if ((*(iter + 1)) != ' ' && (*(iter + 1)) != '.' && (*(iter + 1)) != '\0')
{
log << TestLog::Message << "Failed to parse minor version number. Leading zeros." << TestLog::EndMessage;
return false;
}
}
minorVersion = minorVersion * 10 + val;
iter++;
}
// Invalid format
if ((*iter) != ' ' && (*iter) != '.' && (*iter) != '\0')
return false;
if (desktop)
{
if (majorVersion < major)
{
log << TestLog::Message << "Major version is less than required." << TestLog::EndMessage;
return false;
}
else if (majorVersion == major && minorVersion < minor)
{
log << TestLog::Message << "Minor version is less than required." << TestLog::EndMessage;
return false;
}
else if (majorVersion == major && minorVersion == minor)
return true;
if (major < 3 || (major == 3 && minor == 0))
{
if (majorVersion == 3 && minorVersion == 1)
{
if (hasExtension(gl, "GL_ARB_compatibility"))
return true;
else
{
log << TestLog::Message << "Required OpenGL 3.0 or earlier. Got OpenGL 3.1 without GL_ARB_compatibility." << TestLog::EndMessage;
return false;
}
}
else if (majorVersion > 3 || (majorVersion == 3 && minorVersion >= minor))
{
deInt32 profile = 0;
gl.getIntegerv(GL_CONTEXT_PROFILE_MASK, &profile);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()");
if (profile == GL_CONTEXT_COMPATIBILITY_PROFILE_BIT)
return true;
else
{
log << TestLog::Message << "Required OpenGL 3.0 or earlier. Got later version without compatibility profile." << TestLog::EndMessage;
return false;
}
}
else
DE_ASSERT(false);
return false;
}
else if (major == 3 && minor == 1)
{
if (majorVersion > 3 || (majorVersion == 3 && minorVersion >= minor))
{
deInt32 profile = 0;
gl.getIntegerv(GL_CONTEXT_PROFILE_MASK, &profile);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()");
if (profile == GL_CONTEXT_CORE_PROFILE_BIT)
return true;
else
{
log << TestLog::Message << "Required OpenGL 3.1. Got later version without core profile." << TestLog::EndMessage;
return false;
}
}
else
DE_ASSERT(false);
return false;
}
else
{
log << TestLog::Message << "Couldn't do any further compatibilyt checks." << TestLog::EndMessage;
return true;
}
}
else
{
if (majorVersion < major)
{
log << TestLog::Message << "Major version is less than required." << TestLog::EndMessage;
return false;
}
else if (majorVersion == major && minorVersion < minor)
{
log << TestLog::Message << "Minor version is less than required." << TestLog::EndMessage;
return false;
}
else
return true;
}
}
bool checkVersionQueries (TestLog& log, const glw::Functions& gl, int major, int minor)
{
deInt32 majorVersion = 0;
deInt32 minorVersion = 0;
gl.getIntegerv(GL_MAJOR_VERSION, &majorVersion);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()");
gl.getIntegerv(GL_MINOR_VERSION, &minorVersion);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()");
if (majorVersion < major || (majorVersion == major && minorVersion < minor))
{
if (majorVersion < major)
log << TestLog::Message << "glGetIntegerv(GL_MAJOR_VERSION) returned '" << majorVersion << "' expected at least '" << major << "'" << TestLog::EndMessage;
else if (majorVersion == major && minorVersion < minor)
log << TestLog::Message << "glGetIntegerv(GL_MINOR_VERSION) returned '" << minorVersion << "' expected '" << minor << "'" << TestLog::EndMessage;
else
DE_ASSERT(false);
return false;
}
else
return true;
}
bool CreateContextExtCase::validateCurrentContext (const glw::Functions& gl)
{
bool isOk = true;
TestLog& log = m_testCtx.getLog();
const EGLint* iter = &(m_attribList[0]);
EGLint majorVersion = -1;
EGLint minorVersion = -1;
EGLint contextFlags = -1;
EGLint profileMask = -1;
EGLint notificationStrategy = -1;
EGLint robustAccessExt = -1;
EGLint notificationStrategyExt = -1;
while ((*iter) != EGL_NONE)
{
switch (*iter)
{
case EGL_CONTEXT_MAJOR_VERSION_KHR:
iter++;
majorVersion = (*iter);
iter++;
break;
case EGL_CONTEXT_MINOR_VERSION_KHR:
iter++;
minorVersion = (*iter);
iter++;
break;
case EGL_CONTEXT_FLAGS_KHR:
iter++;
contextFlags = (*iter);
iter++;
break;
case EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR:
iter++;
profileMask = (*iter);
iter++;
break;
case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR:
iter++;
notificationStrategy = (*iter);
iter++;
break;
case EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT:
iter++;
robustAccessExt = *iter;
iter++;
break;
case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT:
iter++;
notificationStrategyExt = *iter;
iter++;
break;
default:
DE_ASSERT(DE_FALSE);
}
}
const string version = (const char*)gl.getString(GL_VERSION);
log << TestLog::Message << "GL_VERSION: '" << version << "'" << TestLog::EndMessage;
if (majorVersion == -1)
majorVersion = 1;
if (minorVersion == -1)
minorVersion = 0;
if (m_api == EGL_OPENGL_ES_API)
{
if (!checkVersionString(log, gl, false, majorVersion, minorVersion))
isOk = false;
if (majorVersion == 3)
{
if (!checkVersionQueries(log, gl, majorVersion, minorVersion))
isOk = false;
}
}
else if (m_api == EGL_OPENGL_API)
{
if (!checkVersionString(log, gl, true, majorVersion, minorVersion))
isOk = false;
if (majorVersion >= 3)
{
if (!checkVersionQueries(log, gl, majorVersion, minorVersion))
isOk = false;
}
}
else
DE_ASSERT(false);
if (contextFlags != -1)
{
if (m_api == EGL_OPENGL_API && (majorVersion > 3 || (majorVersion == 3 && minorVersion >= 1)))
{
deInt32 contextFlagsGL;
DE_ASSERT(m_api == EGL_OPENGL_API);
if (contextFlags == -1)
contextFlags = 0;
gl.getIntegerv(GL_CONTEXT_FLAGS, &contextFlagsGL);
if (contextFlags != contextFlagsGL)
{
log << TestLog::Message << "Invalid GL_CONTEXT_FLAGS. Expected '" << eglContextFlagsToString(contextFlags) << "' got '" << eglContextFlagsToString(contextFlagsGL) << "'" << TestLog::EndMessage;
isOk = false;
}
}
}
if (profileMask != -1 || (m_api == EGL_OPENGL_API && (majorVersion >= 3)))
{
if (profileMask == -1)
profileMask = EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR;
DE_ASSERT(m_api == EGL_OPENGL_API);
if (majorVersion < 3 || (majorVersion == 3 && minorVersion < 2))
{
// \note Ignore profile masks. This is not an error
}
else
{
deInt32 profileMaskGL = 0;
gl.getIntegerv(GL_CONTEXT_PROFILE_MASK, &profileMask);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()");
if (profileMask != profileMaskGL)
{
log << TestLog::Message << "Invalid GL_CONTEXT_PROFILE_MASK. Expected '" << eglProfileMaskToString(profileMask) << "' got '" << eglProfileMaskToString(profileMaskGL) << "'" << TestLog::EndMessage;
isOk = false;
}
}
}
if (notificationStrategy != -1)
{
if (m_api == EGL_OPENGL_API)
{
deInt32 strategy;
gl.getIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()");
if (notificationStrategy == EGL_NO_RESET_NOTIFICATION_KHR && strategy != GL_NO_RESET_NOTIFICATION_ARB)
{
log << TestLog::Message << "glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB) returned '" << strategy << "', expected 'GL_NO_RESET_NOTIFICATION_ARB'" << TestLog::EndMessage;
isOk = false;
}
else if (notificationStrategy == EGL_LOSE_CONTEXT_ON_RESET_KHR && strategy != GL_LOSE_CONTEXT_ON_RESET_ARB)
{
log << TestLog::Message << "glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB) returned '" << strategy << "', expected 'GL_LOSE_CONTEXT_ON_RESET_ARB'" << TestLog::EndMessage;
isOk = false;
}
}
else if (m_api == EGL_OPENGL_ES_API)
{
deInt32 strategy;
gl.getIntegerv(GL_RESET_NOTIFICATION_STRATEGY_EXT, &strategy);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()");
if (notificationStrategy == EGL_NO_RESET_NOTIFICATION_KHR && strategy != GL_NO_RESET_NOTIFICATION_EXT)
{
log << TestLog::Message << "glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_EXT) returned '" << strategy << "', expected 'GL_NO_RESET_NOTIFICATION_EXT'" << TestLog::EndMessage;
isOk = false;
}
else if (notificationStrategy == EGL_LOSE_CONTEXT_ON_RESET_KHR && strategy != GL_LOSE_CONTEXT_ON_RESET_EXT)
{
log << TestLog::Message << "glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_EXT) returned '" << strategy << "', expected 'GL_LOSE_CONTEXT_ON_RESET_EXT'" << TestLog::EndMessage;
isOk = false;
}
}
}
if (notificationStrategyExt != -1)
{
if (m_api == EGL_OPENGL_API)
{
deInt32 strategy;
gl.getIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()");
if (notificationStrategyExt == EGL_NO_RESET_NOTIFICATION_KHR && strategy != GL_NO_RESET_NOTIFICATION_ARB)
{
log << TestLog::Message << "glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB) returned '" << strategy << "', expected 'GL_NO_RESET_NOTIFICATION_ARB'" << TestLog::EndMessage;
isOk = false;
}
else if (notificationStrategyExt == EGL_LOSE_CONTEXT_ON_RESET_KHR && strategy != GL_LOSE_CONTEXT_ON_RESET_ARB)
{
log << TestLog::Message << "glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB) returned '" << strategy << "', expected 'GL_LOSE_CONTEXT_ON_RESET_ARB'" << TestLog::EndMessage;
isOk = false;
}
}
else if (m_api == EGL_OPENGL_ES_API)
{
deInt32 strategy;
gl.getIntegerv(GL_RESET_NOTIFICATION_STRATEGY_EXT, &strategy);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()");
if (notificationStrategyExt == EGL_NO_RESET_NOTIFICATION_KHR && strategy != GL_NO_RESET_NOTIFICATION_EXT)
{
log << TestLog::Message << "glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_EXT) returned '" << strategy << "', expected 'GL_NO_RESET_NOTIFICATION_EXT'" << TestLog::EndMessage;
isOk = false;
}
else if (notificationStrategyExt == EGL_LOSE_CONTEXT_ON_RESET_KHR && strategy != GL_LOSE_CONTEXT_ON_RESET_EXT)
{
log << TestLog::Message << "glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_EXT) returned '" << strategy << "', expected 'GL_LOSE_CONTEXT_ON_RESET_EXT'" << TestLog::EndMessage;
isOk = false;
}
}
}
if (robustAccessExt == EGL_TRUE)
{
if (m_api == EGL_OPENGL_API)
{
if (!hasExtension(gl, "GL_ARB_robustness"))
{
log << TestLog::Message << "Created robustness context but it doesn't support GL_ARB_robustness." << TestLog::EndMessage;
isOk = false;
}
}
else if (m_api == EGL_OPENGL_ES_API)
{
if (!hasExtension(gl, "GL_EXT_robustness"))
{
log << TestLog::Message << "Created robustness context but it doesn't support GL_EXT_robustness." << TestLog::EndMessage;
isOk = false;
}
}
if (m_api == EGL_OPENGL_API && (majorVersion > 3 || (majorVersion == 3 && minorVersion >= 1)))
{
deInt32 contextFlagsGL;
DE_ASSERT(m_api == EGL_OPENGL_API);
gl.getIntegerv(GL_CONTEXT_FLAGS, &contextFlagsGL);
if ((contextFlagsGL & GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB) != 0)
{
log << TestLog::Message << "Invalid GL_CONTEXT_FLAGS. GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB to be set, got '" << eglContextFlagsToString(contextFlagsGL) << "'" << TestLog::EndMessage;
isOk = false;
}
}
else if (m_api == EGL_OPENGL_ES_API)
{
deUint8 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_EXT returned by glGetBooleanv(). Got '" << robustAccessGL << "' expected GL_TRUE." << TestLog::EndMessage;
isOk = false;
}
}
}
return isOk;
}
TestCase::IterateResult CreateContextExtCase::iterate (void)
{
if (m_iteration == 0)
{
logAttribList();
checkRequiredExtensions();
}
if (m_iteration < (int)m_configs.size())
{
const EGLConfig config = m_configs[m_iteration];
tcu::egl::Display& display = m_eglTestCtx.getDisplay();
const EGLint surfaceTypes = display.getConfigAttrib(config, EGL_SURFACE_TYPE);
const EGLint configId = display.getConfigAttrib(config, EGL_CONFIG_ID);
if ((surfaceTypes & EGL_PBUFFER_BIT) != 0)
{
tcu::ScopedLogSection section(m_testCtx.getLog(), ("EGLConfig ID: " + de::toString(configId) + " with PBuffer").c_str(), ("EGLConfig ID: " + de::toString(configId)).c_str());
const EGLint attribList[] =
{
EGL_WIDTH, 64,
EGL_HEIGHT, 64,
EGL_NONE
};
tcu::egl::PbufferSurface pbuffer(display, config, attribList);
executeForConfig(display, config, pbuffer);
}
else if ((surfaceTypes & EGL_WINDOW_BIT) != 0)
{
de::UniquePtr<eglu::NativeWindow> window (m_eglTestCtx.createNativeWindow(display.getEGLDisplay(), config, DE_NULL, 256, 256, eglu::parseWindowVisibility(m_testCtx.getCommandLine())));
tcu::egl::WindowSurface surface (display, eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *window, display.getEGLDisplay(), config, DE_NULL));
executeForConfig(display, config, surface);
}
else if ((surfaceTypes & EGL_PIXMAP_BIT) != 0)
{
de::UniquePtr<eglu::NativePixmap> pixmap (m_eglTestCtx.createNativePixmap(display.getEGLDisplay(), config, DE_NULL, 256, 256));
tcu::egl::PixmapSurface surface (display, eglu::createPixmapSurface(m_eglTestCtx.getNativeDisplay(), *pixmap, display.getEGLDisplay(), config, DE_NULL));
executeForConfig(display, config, surface);
}
else // No supported surface type
TCU_CHECK(false);
m_iteration++;
return CONTINUE;
}
else
{
if (m_configs.size() == 0)
{
m_testCtx.getLog() << TestLog::Message << "No supported configs found" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "No supported configs found");
}
else if (m_isOk)
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
else
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
return STOP;
}
}
void CreateContextExtCase::executeForConfig (tcu::egl::Display& display, EGLConfig config, tcu::egl::Surface& surface)
{
tcu::egl::Context* context = DE_NULL;
TCU_CHECK_EGL_CALL(eglBindAPI(m_api));
try
{
glw::Functions gl;
context = new tcu::egl::Context(display, config, &(m_attribList[0]), m_api);
context->makeCurrent(surface, surface);
m_eglTestCtx.getGLFunctions(gl, m_glContextType.getAPI());
if (!validateCurrentContext(gl))
m_isOk = false;
delete context;
}
catch (const eglu::Error& error)
{
delete context;
if (error.getError() == EGL_BAD_MATCH)
m_testCtx.getLog() << TestLog::Message << "Context creation failed with error EGL_BAD_CONTEXT. Config doesn't support api version." << TestLog::EndMessage;
else if (error.getError() == EGL_BAD_CONFIG)
m_testCtx.getLog() << TestLog::Message << "Context creation failed with error EGL_BAD_MATCH. Context attribute compination not supported." << TestLog::EndMessage;
else
{
m_testCtx.getLog() << TestLog::Message << "Context creation failed with error " << eglu::getErrorStr(error.getError()) << ". Error is not result of unsupported api etc." << TestLog::EndMessage;
m_isOk = false;
}
}
catch (...)
{
delete context;
throw;
}
}
class CreateContextExtGroup : public TestCaseGroup
{
public:
CreateContextExtGroup (EglTestContext& eglTestCtx, EGLenum api, EGLint apiBit, const EGLint* attribList, const char* name, const char* description);
virtual ~CreateContextExtGroup (void);
void init (void);
private:
const EGLenum m_api;
const EGLint m_apiBit;
vector<EGLint> m_attribList;
};
CreateContextExtGroup::CreateContextExtGroup (EglTestContext& eglTestCtx, EGLenum api, EGLint apiBit, const EGLint* attribList, const char* name, const char* description)
: TestCaseGroup (eglTestCtx, name, description)
, m_api (api)
, m_apiBit (apiBit)
, m_attribList (attribList, attribList + getAttribListLength(attribList))
{
}
CreateContextExtGroup::~CreateContextExtGroup (void)
{
}
void CreateContextExtGroup::init (void)
{
const struct
{
const char* name;
const char* description;
EGLint redSize;
EGLint greenSize;
EGLint blueSize;
EGLint alphaSize;
bool hasDepth;
bool hasStencil;
} groups[] =
{
{ "rgb565_no_depth_no_stencil", "RGB565 configs without depth or stencil", 5, 6, 5, 0, false, false },
{ "rgb565_no_depth_stencil", "RGB565 configs with stencil and no depth", 5, 6, 5, 0, false, true },
{ "rgb565_depth_no_stencil", "RGB565 configs with depth and no stencil", 5, 6, 5, 0, true, false },
{ "rgb565_depth_stencil", "RGB565 configs with depth and stencil", 5, 6, 5, 0, true, true },
{ "rgb888_no_depth_no_stencil", "RGB888 configs without depth or stencil", 8, 8, 8, 0, false, false },
{ "rgb888_no_depth_stencil", "RGB888 configs with stencil and no depth", 8, 8, 8, 0, false, true },
{ "rgb888_depth_no_stencil", "RGB888 configs with depth and no stencil", 8, 8, 8, 0, true, false },
{ "rgb888_depth_stencil", "RGB888 configs with depth and stencil", 8, 8, 8, 0, true, true },
{ "rgba4444_no_depth_no_stencil", "RGBA4444 configs without depth or stencil", 4, 4, 4, 4, false, false },
{ "rgba4444_no_depth_stencil", "RGBA4444 configs with stencil and no depth", 4, 4, 4, 4, false, true },
{ "rgba4444_depth_no_stencil", "RGBA4444 configs with depth and no stencil", 4, 4, 4, 4, false, false },
{ "rgba4444_depth_stencil", "RGBA4444 configs with depth and stencil", 4, 4, 4, 4, true, true },
{ "rgba5551_no_depth_no_stencil", "RGBA5551 configs without depth or stencil", 5, 5, 5, 1, false, false },
{ "rgba5551_no_depth_stencil", "RGBA5551 configs with stencil and no depth", 5, 5, 5, 1, false, true },
{ "rgba5551_depth_no_stencil", "RGBA5551 configs with depth and no stencil", 5, 5, 5, 1, true, false },
{ "rgba5551_depth_stencil", "RGBA5551 configs with depth and stencil", 5, 5, 5, 1, true, true },
{ "rgba8888_no_depth_no_stencil", "RGBA8888 configs without depth or stencil", 8, 8, 8, 8, false, false },
{ "rgba8888_no_depth_stencil", "RGBA8888 configs with stencil and no depth", 8, 8, 8, 8, false, true },
{ "rgba8888_depth_no_stencil", "RGBA8888 configs with depth and no stencil", 8, 8, 8, 8, true, false },
{ "rgba8888_depth_stencil", "RGBA8888 configs with depth and stencil", 8, 8, 8, 8, true, true }
};
for (int groupNdx = 0; groupNdx < DE_LENGTH_OF_ARRAY(groups); groupNdx++)
{
eglu::FilterList filter;
filter
<< (eglu::ConfigRedSize() == groups[groupNdx].redSize)
<< (eglu::ConfigGreenSize() == groups[groupNdx].greenSize)
<< (eglu::ConfigBlueSize() == groups[groupNdx].blueSize)
<< (eglu::ConfigAlphaSize() == groups[groupNdx].alphaSize);
if (groups[groupNdx].hasDepth)
filter << (eglu::ConfigDepthSize() >= 1);
if (groups[groupNdx].hasStencil)
filter << (eglu::ConfigStencilSize() >= 1);
filter << (eglu::ConfigRenderableType() & m_apiBit);
addChild(new CreateContextExtCase(m_eglTestCtx, m_api, &(m_attribList[0]), filter, groups[groupNdx].name, groups[groupNdx].description));
}
// \todo [mika] Add other group
}
} // anonymous
CreateContextExtTests::CreateContextExtTests (EglTestContext& eglTestCtx)
: TestCaseGroup(eglTestCtx, "create_context_ext", "EGL_KHR_create_context tests.")
{
}
CreateContextExtTests::~CreateContextExtTests (void)
{
}
void CreateContextExtTests::init (void)
{
const size_t maxAttributeCount = 10;
const struct
{
const char* name;
const char* description;
EGLenum api;
EGLint apiBit;
EGLint attribList[maxAttributeCount];
} groupList[] =
{
#if 0
// \todo [mika] Not supported by glw
// OpenGL ES 1.x
{ "gles_10", "Create OpenGL ES 1.0 context", EGL_OPENGL_ES_API, EGL_OPENGL_ES_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 1, EGL_CONTEXT_MINOR_VERSION_KHR, 0, EGL_NONE} },
{ "gles_11", "Create OpenGL ES 1.1 context", EGL_OPENGL_ES_API, EGL_OPENGL_ES_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 1, EGL_CONTEXT_MINOR_VERSION_KHR, 1, EGL_NONE } },
#endif
// OpenGL ES 2.x
{ "gles_20", "Create OpenGL ES 2.0 context", EGL_OPENGL_ES_API, EGL_OPENGL_ES2_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 2, EGL_CONTEXT_MINOR_VERSION_KHR, 0, EGL_NONE } },
{ "robust_gles_20", "Create robust OpenGL ES 2.0 context", EGL_OPENGL_ES_API, EGL_OPENGL_ES2_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 2, EGL_CONTEXT_MINOR_VERSION_KHR, 0, EGL_CONTEXT_FLAGS_KHR, EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR, EGL_NONE } },
// OpenGL ES 3.x
{ "gles_30", "Create OpenGL ES 3.0 context", EGL_OPENGL_ES_API, EGL_OPENGL_ES3_BIT_KHR,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 3, EGL_CONTEXT_MINOR_VERSION_KHR, 0, EGL_NONE} },
{ "robust_gles_30", "Create OpenGL ES 3.0 context", EGL_OPENGL_ES_API, EGL_OPENGL_ES3_BIT_KHR,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 3, EGL_CONTEXT_MINOR_VERSION_KHR, 0, EGL_CONTEXT_FLAGS_KHR, EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR, EGL_NONE } },
#if 0
// \todo [mika] Not supported by glw
// \note [mika] Should we really test 1.x?
{ "gl_10", "Create OpenGL 1.0 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 1, EGL_CONTEXT_MINOR_VERSION_KHR, 0, EGL_NONE} },
{ "gl_11", "Create OpenGL 1.1 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 1, EGL_CONTEXT_MINOR_VERSION_KHR, 1, EGL_NONE } },
// OpenGL 2.x
{ "gl_20", "Create OpenGL 2.0 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 2, EGL_CONTEXT_MINOR_VERSION_KHR, 0, EGL_NONE } },
{ "gl_21", "Create OpenGL 2.1 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 2, EGL_CONTEXT_MINOR_VERSION_KHR, 1, EGL_NONE } },
#endif
// OpenGL 3.x
{ "gl_30", "Create OpenGL 3.0 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 3, EGL_CONTEXT_MINOR_VERSION_KHR, 0, EGL_NONE } },
{ "robust_gl_30", "Create robust OpenGL 3.0 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 3, EGL_CONTEXT_MINOR_VERSION_KHR, 0, EGL_CONTEXT_FLAGS_KHR, EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR, EGL_NONE } },
{ "gl_31", "Create OpenGL 3.1 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 3, EGL_CONTEXT_MINOR_VERSION_KHR, 1, EGL_NONE } },
{ "robust_gl_31", "Create robust OpenGL 3.1 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 3, EGL_CONTEXT_MINOR_VERSION_KHR, 1, EGL_CONTEXT_FLAGS_KHR, EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR, EGL_NONE } },
{ "gl_32", "Create OpenGL 3.2 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 3, EGL_CONTEXT_MINOR_VERSION_KHR, 2, EGL_NONE } },
{ "robust_gl_32", "Create robust OpenGL 3.2 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 3, EGL_CONTEXT_MINOR_VERSION_KHR, 2, EGL_CONTEXT_FLAGS_KHR, EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR, EGL_NONE } },
{ "gl_33", "Create OpenGL 3.3 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 3, EGL_CONTEXT_MINOR_VERSION_KHR, 3, EGL_NONE } },
{ "robust_gl_33", "Create robust OpenGL 3.3 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 3, EGL_CONTEXT_MINOR_VERSION_KHR, 3, EGL_CONTEXT_FLAGS_KHR, EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR, EGL_NONE } },
// OpenGL 4.x
{ "gl_40", "Create OpenGL 4.0 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 4, EGL_CONTEXT_MINOR_VERSION_KHR, 0, EGL_NONE } },
{ "robust_gl_40", "Create robust OpenGL 4.0 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 4, EGL_CONTEXT_MINOR_VERSION_KHR, 0, EGL_CONTEXT_FLAGS_KHR, EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR, EGL_NONE } },
{ "gl_41", "Create OpenGL 4.1 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 4, EGL_CONTEXT_MINOR_VERSION_KHR, 1, EGL_NONE } },
{ "robust_gl_41", "Create robust OpenGL 4.1 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 4, EGL_CONTEXT_MINOR_VERSION_KHR, 1, EGL_CONTEXT_FLAGS_KHR, EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR, EGL_NONE } },
{ "gl_42", "Create OpenGL 4.2 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 4, EGL_CONTEXT_MINOR_VERSION_KHR, 2, EGL_NONE } },
{ "robust_gl_42", "Create robust OpenGL 4.2 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 4, EGL_CONTEXT_MINOR_VERSION_KHR, 2, EGL_CONTEXT_FLAGS_KHR, EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR, EGL_NONE } },
{ "gl_43", "Create OpenGL 4.3 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 4, EGL_CONTEXT_MINOR_VERSION_KHR, 3, EGL_NONE } },
{ "robust_gl_43", "Create robust OpenGL 4.3 context", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_MAJOR_VERSION_KHR, 4, EGL_CONTEXT_MINOR_VERSION_KHR, 3, EGL_CONTEXT_FLAGS_KHR, EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR, EGL_NONE } },
// Robust contexts with EGL_EXT_create_context_robustness
{ "robust_gles_2_ext", "Create robust OpenGL ES 2.0 context with EGL_EXT_create_context_robustness.", EGL_OPENGL_ES_API, EGL_OPENGL_ES2_BIT,
{ EGL_CONTEXT_CLIENT_VERSION, 2, EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_TRUE, EGL_NONE } },
{ "robust_gles_3_ext", "Create robust OpenGL ES 3.0 context with EGL_EXT_create_context_robustness.", EGL_OPENGL_ES_API, EGL_OPENGL_ES3_BIT_KHR,
{ EGL_CONTEXT_CLIENT_VERSION, 3, EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_TRUE, EGL_NONE } },
#if 0
// glu/glw doesn't support any version of OpenGL and EGL doesn't allow use of EGL_CONTEXT_CLIENT_VERSION with OpenGL and doesn't define which OpenGL version should be returned.
{ "robust_gl_ext", "Create robust OpenGL context with EGL_EXT_create_context_robustness.", EGL_OPENGL_API, EGL_OPENGL_BIT,
{ EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_TRUE, EGL_NONE } }
#endif
};
for (int groupNdx = 0; groupNdx < DE_LENGTH_OF_ARRAY(groupList); groupNdx++)
addChild(new CreateContextExtGroup(m_eglTestCtx, groupList[groupNdx].api, groupList[groupNdx].apiBit, groupList[groupNdx].attribList, groupList[groupNdx].name, groupList[groupNdx].description));
}
} // egl
} // deqp