/*-------------------------------------------------------------------------
 * 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 "egluUnique.hpp"

#include "eglwLibrary.hpp"
#include "eglwEnums.hpp"

#include "gluDefs.hpp"
#include "gluRenderConfig.hpp"

#include "glwFunctions.hpp"
#include "glwEnums.hpp"

#include "deStringUtil.hpp"
#include "deUniquePtr.hpp"
#include "deSTLUtil.hpp"

#include <string>
#include <vector>
#include <set>
#include <sstream>

#include <cstring>

using std::set;
using std::string;
using std::vector;
using tcu::TestLog;

using namespace eglw;

// Make sure KHR / core values match to those in GL_ARB_robustness and GL_EXT_robustness
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);

#if !defined(GL_CONTEXT_ROBUST_ACCESS)
#define GL_CONTEXT_ROBUST_ACCESS 0x90F3
#endif

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 executeForSurface(EGLConfig config, EGLSurface 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;

    EGLDisplay m_display;
    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(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_display(EGL_NO_DISPLAY)
    , m_glContextType(attribListToContextType(api, attribList))
{
}

CreateContextExtCase::~CreateContextExtCase(void)
{
    deinit();
}

void CreateContextExtCase::init(void)
{
    m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
    m_configs = eglu::chooseConfigs(m_eglTestCtx.getLibrary(), m_display, m_filter);
}

void CreateContextExtCase::deinit(void)
{
    m_attribList.clear();
    m_configs.clear();

    if (m_display != EGL_NO_DISPLAY)
    {
        m_eglTestCtx.getLibrary().terminate(m_display);
        m_display = EGL_NO_DISPLAY;
    }
}

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(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 = eglu::getDisplayExtensions(m_eglTestCtx.getLibrary(), m_display);

    {
        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");

                if (*iter & EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR)
                    requiredExtensions.insert("EGL_EXT_create_context_robustness");

                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(false);
            }
        }
    }

    for (std::set<string>::const_iterator reqExt = requiredExtensions.begin(); reqExt != requiredExtensions.end();
         ++reqExt)
    {
        if (!de::contains(extensions.begin(), extensions.end(), *reqExt))
        {
            m_testCtx.getLog() << TestLog::Message << "Required extension '" << (*reqExt) << "' not supported"
                               << TestLog::EndMessage;
            isOk = false;
        }
    }

    if (!isOk)
        TCU_THROW(NotSupportedError, "Required extensions not supported");
}

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 (glu::hasExtension(gl, glu::ApiType::core(3, 1), "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))
            {
                int32_t 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))
            {
                int32_t 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)
{
    int32_t majorVersion = 0;
    int32_t 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(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)))
        {
            int32_t 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
        {
            int32_t profileMaskGL = 0;

            gl.getIntegerv(GL_CONTEXT_PROFILE_MASK, &profileMaskGL);
            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;
            }
        }
    }

    DE_ASSERT(notificationStrategy == -1 || notificationStrategyExt == -1);

    if (notificationStrategy != -1 || notificationStrategyExt != -1)
    {
        const int32_t expected = notificationStrategy != -1 ? notificationStrategy : notificationStrategyExt;
        int32_t strategy       = 0;

        gl.getIntegerv(GL_RESET_NOTIFICATION_STRATEGY, &strategy);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()");

        if (expected == EGL_NO_RESET_NOTIFICATION && strategy != GL_NO_RESET_NOTIFICATION)
        {
            log << TestLog::Message << "glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY) returned '" << strategy
                << "', expected 'GL_NO_RESET_NOTIFICATION'" << TestLog::EndMessage;
            isOk = false;
        }
        else if (expected == EGL_LOSE_CONTEXT_ON_RESET && strategy != GL_LOSE_CONTEXT_ON_RESET)
        {
            log << TestLog::Message << "glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY) returned '" << strategy
                << "', expected 'GL_LOSE_CONTEXT_ON_RESET'" << TestLog::EndMessage;
            isOk = false;
        }
    }

    if (robustAccessExt == EGL_TRUE)
    {
        if (m_api == EGL_OPENGL_API)
        {
            if (!glu::hasExtension(gl, glu::ApiType::core(majorVersion, minorVersion), "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 (!glu::hasExtension(gl, glu::ApiType::es(majorVersion, minorVersion), "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)))
        {
            int32_t contextFlagsGL;

            DE_ASSERT(m_api == EGL_OPENGL_API);

            gl.getIntegerv(GL_CONTEXT_FLAGS, &contextFlagsGL);

            if ((contextFlagsGL & GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT) != 0)
            {
                log << TestLog::Message
                    << "Invalid GL_CONTEXT_FLAGS. GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT to be set, got '"
                    << eglContextFlagsToString(contextFlagsGL) << "'" << TestLog::EndMessage;
                isOk = false;
            }
        }
        else if (m_api == EGL_OPENGL_ES_API)
        {
            uint8_t robustAccessGL;

            gl.getBooleanv(GL_CONTEXT_ROBUST_ACCESS, &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;
                isOk = false;
            }
        }
    }

    return isOk;
}

TestCase::IterateResult CreateContextExtCase::iterate(void)
{
    if (m_iteration == 0)
    {
        logAttribList();
        checkRequiredExtensions();
    }

    if (m_iteration < (int)m_configs.size())
    {
        const Library &egl        = m_eglTestCtx.getLibrary();
        const EGLConfig config    = m_configs[m_iteration];
        const EGLint surfaceTypes = eglu::getConfigAttribInt(egl, m_display, config, EGL_SURFACE_TYPE);
        const EGLint configId     = eglu::getConfigAttribInt(egl, m_display, 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};
            eglu::UniqueSurface surface(egl, m_display, egl.createPbufferSurface(m_display, config, attribList));
            EGLU_CHECK_MSG(egl, "eglCreatePbufferSurface");

            executeForSurface(config, *surface);
        }
        else if ((surfaceTypes & EGL_WINDOW_BIT) != 0)
        {
            const eglu::NativeWindowFactory &factory =
                eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());

            de::UniquePtr<eglu::NativeWindow> window(factory.createWindow(
                &m_eglTestCtx.getNativeDisplay(), m_display, config, DE_NULL,
                eglu::WindowParams(256, 256, eglu::parseWindowVisibility(m_testCtx.getCommandLine()))));
            eglu::UniqueSurface surface(
                egl, m_display,
                eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *window, m_display, config, DE_NULL));

            executeForSurface(config, *surface);
        }
        else if ((surfaceTypes & EGL_PIXMAP_BIT) != 0)
        {
            const eglu::NativePixmapFactory &factory =
                eglu::selectNativePixmapFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());

            de::UniquePtr<eglu::NativePixmap> pixmap(
                factory.createPixmap(&m_eglTestCtx.getNativeDisplay(), m_display, config, DE_NULL, 256, 256));
            eglu::UniqueSurface surface(
                egl, m_display,
                eglu::createPixmapSurface(m_eglTestCtx.getNativeDisplay(), *pixmap, m_display, config, DE_NULL));

            executeForSurface(config, *surface);
        }
        else // No supported surface type
            TCU_FAIL("Invalid or empty surface type bits");

        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::executeForSurface(EGLConfig config, EGLSurface surface)
{
    const Library &egl = m_eglTestCtx.getLibrary();

    EGLU_CHECK_CALL(egl, bindAPI(m_api));

    try
    {
        glw::Functions gl;
        eglu::UniqueContext context(egl, m_display,
                                    egl.createContext(m_display, config, EGL_NO_CONTEXT, &m_attribList[0]));
        EGLU_CHECK_MSG(egl, "eglCreateContext");

        EGLU_CHECK_CALL(egl, makeCurrent(m_display, surface, surface, *context));

        m_eglTestCtx.initGLFunctions(&gl, m_glContextType.getAPI());

        if (!validateCurrentContext(gl))
            m_isOk = false;
    }
    catch (const eglu::Error &error)
    {
        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;
        }
    }

    EGLU_CHECK_CALL(egl, makeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
}

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)
{
}

template <int Red, int Green, int Blue, int Alpha>
static bool colorBits(const eglu::CandidateConfig &c)
{
    return c.redSize() == Red && c.greenSize() == Green && c.blueSize() == Blue && c.alphaSize() == Alpha;
}

static bool hasDepth(const eglu::CandidateConfig &c)
{
    return c.depthSize() > 0;
}
static bool noDepth(const eglu::CandidateConfig &c)
{
    return c.depthSize() == 0;
}
static bool hasStencil(const eglu::CandidateConfig &c)
{
    return c.stencilSize() > 0;
}
static bool noStencil(const eglu::CandidateConfig &c)
{
    return c.stencilSize() == 0;
}

template <uint32_t Type>
static bool renderable(const eglu::CandidateConfig &c)
{
    return (c.renderableType() & Type) == Type;
}

static 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_ASSERT(false);
        return renderable<0>;
    }
}

void CreateContextExtGroup::init(void)
{
    const struct
    {
        const char *name;
        const char *description;

        eglu::ConfigFilter colorFilter;
        eglu::ConfigFilter depthFilter;
        eglu::ConfigFilter stencilFilter;
    } groups[] = {
        {"rgb565_no_depth_no_stencil", "RGB565 configs without depth or stencil", colorBits<5, 6, 5, 0>, noDepth,
         noStencil},
        {"rgb565_no_depth_stencil", "RGB565 configs with stencil and no depth", colorBits<5, 6, 5, 0>, noDepth,
         hasStencil},
        {"rgb565_depth_no_stencil", "RGB565 configs with depth and no stencil", colorBits<5, 6, 5, 0>, hasDepth,
         noStencil},
        {"rgb565_depth_stencil", "RGB565 configs with depth and stencil", colorBits<5, 6, 5, 0>, hasDepth, hasStencil},

        {"rgb888_no_depth_no_stencil", "RGB888 configs without depth or stencil", colorBits<8, 8, 8, 0>, noDepth,
         noStencil},
        {"rgb888_no_depth_stencil", "RGB888 configs with stencil and no depth", colorBits<8, 8, 8, 0>, noDepth,
         hasStencil},
        {"rgb888_depth_no_stencil", "RGB888 configs with depth and no stencil", colorBits<8, 8, 8, 0>, hasDepth,
         noStencil},
        {"rgb888_depth_stencil", "RGB888 configs with depth and stencil", colorBits<8, 8, 8, 0>, hasDepth, hasStencil},

        {"rgba4444_no_depth_no_stencil", "RGBA4444 configs without depth or stencil", colorBits<4, 4, 4, 4>, noDepth,
         noStencil},
        {"rgba4444_no_depth_stencil", "RGBA4444 configs with stencil and no depth", colorBits<4, 4, 4, 4>, noDepth,
         hasStencil},
        {"rgba4444_depth_no_stencil", "RGBA4444 configs with depth and no stencil", colorBits<4, 4, 4, 4>, hasDepth,
         noStencil},
        {"rgba4444_depth_stencil", "RGBA4444 configs with depth and stencil", colorBits<4, 4, 4, 4>, hasDepth,
         hasStencil},

        {"rgba5551_no_depth_no_stencil", "RGBA5551 configs without depth or stencil", colorBits<5, 5, 5, 1>, noDepth,
         noStencil},
        {"rgba5551_no_depth_stencil", "RGBA5551 configs with stencil and no depth", colorBits<5, 5, 5, 1>, noDepth,
         hasStencil},
        {"rgba5551_depth_no_stencil", "RGBA5551 configs with depth and no stencil", colorBits<5, 5, 5, 1>, hasDepth,
         noStencil},
        {"rgba5551_depth_stencil", "RGBA5551 configs with depth and stencil", colorBits<5, 5, 5, 1>, hasDepth,
         hasStencil},

        {"rgba8888_no_depth_no_stencil", "RGBA8888 configs without depth or stencil", colorBits<8, 8, 8, 8>, noDepth,
         noStencil},
        {"rgba8888_no_depth_stencil", "RGBA8888 configs with stencil and no depth", colorBits<8, 8, 8, 8>, noDepth,
         hasStencil},
        {"rgba8888_depth_no_stencil", "RGBA8888 configs with depth and no stencil", colorBits<8, 8, 8, 8>, hasDepth,
         noStencil},
        {"rgba8888_depth_stencil", "RGBA8888 configs with depth and stencil", colorBits<8, 8, 8, 8>, hasDepth,
         hasStencil}};

    for (int groupNdx = 0; groupNdx < DE_LENGTH_OF_ARRAY(groups); groupNdx++)
    {
        eglu::FilterList filter;

        filter << groups[groupNdx].colorFilter << groups[groupNdx].depthFilter << groups[groupNdx].stencilFilter
               << getRenderableFilter(m_apiBit);

        addChild(new CreateContextExtCase(m_eglTestCtx, m_api, &(m_attribList[0]), filter, groups[groupNdx].name,
                                          groups[groupNdx].description));
    }
    // \todo [mika] Add other group
}

} // namespace

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}},
        // 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}},
#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));
}

} // namespace egl
} // namespace deqp