modules/egl/teglCreateContextTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program EGL Module
   3  * ---------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Simple Context construction test.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "teglCreateContextTests.hpp"
  25 #include "teglSimpleConfigCase.hpp"
  26 #include "egluStrUtil.hpp"
  27 #include "egluUtil.hpp"
  28 #include "egluUnique.hpp"
  29 #include "eglwLibrary.hpp"
  30 #include "eglwEnums.hpp"
  31 #include "tcuTestLog.hpp"
  32 #include "deSTLUtil.hpp"
  33
  34 namespace deqp
  35 {
  36 namespace egl
  37 {
  38
  39 using std::vector;
  40 using tcu::TestLog;
  41 using namespace eglw;
  42
  43 static const EGLint s_es1Attrs[] = { EGL_CONTEXT_CLIENT_VERSION,        1, EGL_NONE };
  44 static const EGLint s_es2Attrs[] = { EGL_CONTEXT_CLIENT_VERSION,        2, EGL_NONE };
  45 static const EGLint s_es3Attrs[] = { EGL_CONTEXT_MAJOR_VERSION_KHR,     3, EGL_NONE };
  46
  47 static const struct
  48 {
  49         const char*             name;
  50         EGLenum                 api;
  51         EGLint                  apiBit;
  52         bool                    noConfigOptional;
  53         const EGLint*   ctxAttrs;
  54 } s_apis[] =
  55 {
  56         { "OpenGL",                     EGL_OPENGL_API,         EGL_OPENGL_BIT,                 false,  DE_NULL         },
  57         { "OpenGL ES 1",        EGL_OPENGL_ES_API,      EGL_OPENGL_ES_BIT,              true,   s_es1Attrs      },
  58         { "OpenGL ES 2",        EGL_OPENGL_ES_API,      EGL_OPENGL_ES2_BIT,             true,   s_es2Attrs      },
  59         { "OpenGL ES 3",        EGL_OPENGL_ES_API,      EGL_OPENGL_ES3_BIT_KHR, false,  s_es3Attrs      },
  60         { "OpenVG",                     EGL_OPENVG_API,         EGL_OPENVG_BIT,                 false,  DE_NULL         }
  61 };
  62
  63 class CreateContextCase : public SimpleConfigCase
  64 {
  65 public:
  66                                                 CreateContextCase                       (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters);
  67                                                 ~CreateContextCase                      (void);
  68
  69         void                            executeForConfig                        (EGLDisplay display, EGLConfig config);
  70 };
  71
  72 CreateContextCase::CreateContextCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters)
  73         : SimpleConfigCase(eglTestCtx, name, description, filters)
  74 {
  75 }
  76
  77 CreateContextCase::~CreateContextCase (void)
  78 {
  79 }
  80
  81 void CreateContextCase::executeForConfig (EGLDisplay display, EGLConfig config)
  82 {
  83         const Library&  egl             = m_eglTestCtx.getLibrary();
  84         TestLog&                log             = m_testCtx.getLog();
  85         EGLint                  id              = eglu::getConfigAttribInt(egl, display, config, EGL_CONFIG_ID);
  86         EGLint                  apiBits = eglu::getConfigAttribInt(egl, display, config, EGL_RENDERABLE_TYPE);
  87
  88         for (int apiNdx = 0; apiNdx < (int)DE_LENGTH_OF_ARRAY(s_apis); apiNdx++)
  89         {
  90                 if ((apiBits & s_apis[apiNdx].apiBit) == 0)
  91                         continue; // Not supported API
  92
  93                 log << TestLog::Message << "Creating " << s_apis[apiNdx].name << " context with config ID " << id << TestLog::EndMessage;
  94                 EGLU_CHECK_MSG(egl, "init");
  95
  96                 EGLU_CHECK_CALL(egl, bindAPI(s_apis[apiNdx].api));
  97
  98                 EGLContext      context = egl.createContext(display, config, EGL_NO_CONTEXT, s_apis[apiNdx].ctxAttrs);
  99                 EGLenum         err             = egl.getError();
 100
 101                 if (context == EGL_NO_CONTEXT || err != EGL_SUCCESS)
 102                 {
 103                         log << TestLog::Message << "  Fail, context: " << tcu::toHex(context) << ", error: " << eglu::getErrorName(err) << TestLog::EndMessage;
 104                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to create context");
 105                 }
 106                 else
 107                 {
 108                         // Destroy
 109                         EGLU_CHECK_CALL(egl, destroyContext(display, context));
 110                         log << TestLog::Message << "  Pass" << TestLog::EndMessage;
 111                 }
 112         }
 113 }
 114
 115 class CreateContextNoConfigCase : public TestCase
 116 {
 117 public:
 118         CreateContextNoConfigCase (EglTestContext& eglTestCtx)
 119                 : TestCase(eglTestCtx, "no_config", "EGL_KHR_no_config_context")
 120         {
 121         }
 122
 123         IterateResult iterate (void)
 124         {
 125                 const eglw::Library&            egl             = m_eglTestCtx.getLibrary();
 126                 const eglu::UniqueDisplay       display (egl, eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay(), DE_NULL));
 127                 tcu::TestLog&                           log             = m_testCtx.getLog();
 128
 129                 if (!eglu::hasExtension(egl, *display, "EGL_KHR_no_config_context"))
 130                         TCU_THROW(NotSupportedError, "EGL_KHR_no_config_context is not supported");
 131
 132                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "pass");
 133
 134                 for (int apiNdx = 0; apiNdx < (int)DE_LENGTH_OF_ARRAY(s_apis); apiNdx++)
 135                 {
 136                         const EGLenum   api             = s_apis[apiNdx].api;
 137
 138                         if (egl.bindAPI(api) == EGL_FALSE)
 139                         {
 140                                 TCU_CHECK(egl.getError() == EGL_BAD_PARAMETER);
 141                                 log << TestLog::Message << "eglBindAPI(" << eglu::getAPIStr(api) << ") failed, skipping" << TestLog::EndMessage;
 142                                 continue;
 143                         }
 144
 145                         log << TestLog::Message << "Creating " << s_apis[apiNdx].name << " context" << TestLog::EndMessage;
 146
 147                         const EGLContext        context = egl.createContext(*display, (EGLConfig)0, EGL_NO_CONTEXT, s_apis[apiNdx].ctxAttrs);
 148                         const EGLenum           err             = egl.getError();
 149
 150                         if (context == EGL_NO_CONTEXT && err == EGL_BAD_MATCH && s_apis[apiNdx].noConfigOptional)
 151                         {
 152                                 log << TestLog::Message << "  Unsupported" << TestLog::EndMessage;
 153                         }
 154                         else if (context == EGL_NO_CONTEXT || err != EGL_SUCCESS)
 155                         {
 156                                 log << TestLog::Message << "  Fail, context: " << tcu::toHex(context) << ", error: " << eglu::getErrorName(err) << TestLog::EndMessage;
 157                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to create context");
 158                         }
 159                         else
 160                         {
 161                                 // Destroy
 162                                 EGLU_CHECK_CALL(egl, destroyContext(*display, context));
 163                                 log << TestLog::Message << "  Pass" << TestLog::EndMessage;
 164                         }
 165                 }
 166
 167                 return STOP;
 168         }
 169 };
 170
 171 CreateContextTests::CreateContextTests (EglTestContext& eglTestCtx)
 172         : TestCaseGroup(eglTestCtx, "create_context", "Basic eglCreateContext() tests")
 173 {
 174 }
 175
 176 CreateContextTests::~CreateContextTests (void)
 177 {
 178 }
 179
 180 void CreateContextTests::init (void)
 181 {
 182         vector<NamedFilterList> filterLists;
 183         getDefaultFilterLists(filterLists, eglu::FilterList());
 184
 185         for (vector<NamedFilterList>::iterator i = filterLists.begin(); i != filterLists.end(); i++)
 186                 addChild(new CreateContextCase(m_eglTestCtx, i->getName(), i->getDescription(), *i));
 187
 188         addChild(new CreateContextNoConfigCase(m_eglTestCtx));
 189 }
 190
 191 } // egl
 192 } // deqp