modules/egl/teglGetProcAddressTests.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 Extension function pointer query tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "teglGetProcAddressTests.hpp"
  25 #include "teglTestCase.hpp"
  26 #include "egluCallLogWrapper.hpp"
  27 #include "egluStrUtil.hpp"
  28 #include "egluUtil.hpp"
  29 #include "eglwLibrary.hpp"
  30 #include "eglwEnums.hpp"
  31 #include "tcuTestLog.hpp"
  32 #include "deSTLUtil.hpp"
  33 #include "deStringUtil.hpp"
  34
  35 namespace deqp
  36 {
  37 namespace egl
  38 {
  39
  40 namespace
  41 {
  42
  43 using tcu::TestLog;
  44 using namespace eglw;
  45
  46 // Function name strings generated from API headers
  47
  48 #include "teglGetProcAddressTests.inl"
  49
  50 struct FunctionNames
  51 {
  52         int                                     numFunctions;
  53         const char* const*      functions;
  54
  55         FunctionNames (int numFunctions_, const char* const* functions_)
  56                 : numFunctions  (numFunctions_)
  57                 , functions             (functions_)
  58         {
  59         }
  60 };
  61
  62 FunctionNames getExtFunctionNames (const std::string& extName)
  63 {
  64         for (int ndx = 0; ndx <= DE_LENGTH_OF_ARRAY(s_extensions); ndx++)
  65         {
  66                 if (extName == s_extensions[ndx].name)
  67                         return FunctionNames(s_extensions[ndx].numFunctions, s_extensions[ndx].functions);
  68         }
  69
  70         DE_ASSERT(false);
  71         return FunctionNames(0, DE_NULL);
  72 }
  73
  74 FunctionNames getCoreFunctionNames (EGLint apiBit)
  75 {
  76         switch (apiBit)
  77         {
  78                 case 0:                                                 return FunctionNames(DE_LENGTH_OF_ARRAY(s_EGL14),       s_EGL14);
  79                 case EGL_OPENGL_ES_BIT:                 return FunctionNames(DE_LENGTH_OF_ARRAY(s_GLES10),      s_GLES10);
  80                 case EGL_OPENGL_ES2_BIT:                return FunctionNames(DE_LENGTH_OF_ARRAY(s_GLES20),      s_GLES20);
  81                 case EGL_OPENGL_ES3_BIT_KHR:    return FunctionNames(DE_LENGTH_OF_ARRAY(s_GLES30),      s_GLES30);
  82                 default:
  83                         DE_ASSERT(false);
  84         }
  85
  86         return FunctionNames(0, DE_NULL);
  87 }
  88
  89 } // anonymous
  90
  91 // Base class for eglGetProcAddress() test cases
  92
  93 class GetProcAddressCase : public TestCase, protected eglu::CallLogWrapper
  94 {
  95 public:
  96                                                                 GetProcAddressCase              (EglTestContext& eglTestCtx, const char* name, const char* description);
  97         virtual                                         ~GetProcAddressCase             (void);
  98
  99         void                                            init                                    (void);
 100         void                                            deinit                                  (void);
 101         IterateResult                           iterate                                 (void);
 102
 103         bool                                            isSupported                             (const std::string& extName);
 104
 105         virtual void                            executeTest                             (void) = 0;
 106
 107 protected:
 108         EGLDisplay                                      m_display;
 109
 110 private:
 111         std::vector<std::string>        m_supported;
 112 };
 113
 114 GetProcAddressCase::GetProcAddressCase (EglTestContext& eglTestCtx, const char* name, const char* description)
 115         : TestCase                      (eglTestCtx, name, description)
 116         , CallLogWrapper        (eglTestCtx.getLibrary(), eglTestCtx.getTestContext().getLog())
 117         , m_display                     (EGL_NO_DISPLAY)
 118 {
 119 }
 120
 121 GetProcAddressCase::~GetProcAddressCase (void)
 122 {
 123 }
 124
 125 void GetProcAddressCase::init (void)
 126 {
 127         try
 128         {
 129                 m_supported = eglu::getClientExtensions(m_eglTestCtx.getLibrary());
 130         }
 131         catch (const eglu::Error& error)
 132         {
 133                 // EGL_BAD_DISPLAY is generated if client extensions are not supported.
 134                 if (error.getError() != EGL_BAD_DISPLAY)
 135                         throw;
 136         }
 137
 138         DE_ASSERT(m_display == EGL_NO_DISPLAY);
 139
 140         m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
 141
 142         {
 143                 const std::vector<std::string> displayExtensios = eglu::getDisplayExtensions(m_eglTestCtx.getLibrary(), m_display);
 144                 m_supported.insert(m_supported.end(), displayExtensios.begin(), displayExtensios.end());
 145         }
 146
 147         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 148 }
 149
 150 void GetProcAddressCase::deinit (void)
 151 {
 152         m_eglTestCtx.getLibrary().terminate(m_display);
 153         m_display = EGL_NO_DISPLAY;
 154 }
 155
 156 tcu::TestNode::IterateResult GetProcAddressCase::iterate (void)
 157 {
 158         enableLogging(true);
 159
 160         executeTest();
 161
 162         enableLogging(false);
 163
 164         return STOP;
 165 }
 166
 167 bool GetProcAddressCase::isSupported (const std::string& extName)
 168 {
 169         return de::contains(m_supported.begin(), m_supported.end(), extName);
 170 }
 171
 172 // Test by extension
 173
 174 class GetProcAddressExtensionCase : public GetProcAddressCase
 175 {
 176 public:
 177         GetProcAddressExtensionCase (EglTestContext& eglTestCtx, const char* name, const char* description, const std::string& extName)
 178                 : GetProcAddressCase    (eglTestCtx, name, description)
 179                 , m_extName                             (extName)
 180         {
 181         }
 182
 183         virtual ~GetProcAddressExtensionCase (void)
 184         {
 185         }
 186
 187         void executeTest (void)
 188         {
 189                 TestLog&                                log                     = m_testCtx.getLog();
 190                 bool                                    supported       = isSupported(m_extName);
 191                 const FunctionNames             funcNames       = getExtFunctionNames(m_extName);
 192
 193                 DE_ASSERT(funcNames.numFunctions > 0);
 194
 195                 log << TestLog::Message << m_extName << ": " << (supported ? "supported" : "not supported") << TestLog::EndMessage;
 196                 log << TestLog::Message << TestLog::EndMessage;
 197
 198                 for (int funcNdx = 0; funcNdx < funcNames.numFunctions; funcNdx++)
 199                 {
 200                         const char*     funcName                = funcNames.functions[funcNdx];
 201                         void            (*funcPtr)(void);
 202
 203                         funcPtr = eglGetProcAddress(funcName);
 204                         eglu::checkError(eglGetError(), "eglGetProcAddress()", __FILE__, __LINE__);
 205
 206                         if (supported && funcPtr == 0)
 207                         {
 208                                 log << TestLog::Message << "Fail, received null pointer for supported extension function: " << funcName << TestLog::EndMessage;
 209                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected null pointer");
 210                         }
 211                 }
 212         }
 213
 214 private:
 215         std::string     m_extName;
 216 };
 217
 218 // Test core functions
 219
 220 class GetProcAddressCoreFunctionsCase : public GetProcAddressCase
 221 {
 222 public:
 223         GetProcAddressCoreFunctionsCase (EglTestContext& eglTestCtx, const char* name, const char* description, const EGLint apiBit)
 224                 : GetProcAddressCase    (eglTestCtx, name, description)
 225                 , m_apiBit                              (apiBit)
 226         {
 227         }
 228
 229         virtual ~GetProcAddressCoreFunctionsCase (void)
 230         {
 231         }
 232
 233         void executeTest (void)
 234         {
 235                 TestLog&                                log                                     = m_testCtx.getLog();
 236                 const bool                              funcPtrSupported        = isSupported("EGL_KHR_get_all_proc_addresses");
 237                 const bool                              apiSupported            = (eglu::getRenderableAPIsMask(m_eglTestCtx.getLibrary(), m_display) & m_apiBit) == m_apiBit;
 238                 const FunctionNames             funcNames                       = getCoreFunctionNames(m_apiBit);
 239
 240                 log << TestLog::Message << "EGL_KHR_get_all_proc_addresses: " << (funcPtrSupported ? "supported" : "not supported") << TestLog::EndMessage;
 241                 log << TestLog::Message << TestLog::EndMessage;
 242
 243                 if (!apiSupported)
 244                 {
 245                         log << TestLog::Message << eglu::getConfigAttribValueStr(EGL_RENDERABLE_TYPE, m_apiBit) << " not supported by any available configuration." << TestLog::EndMessage;
 246                         log << TestLog::Message << TestLog::EndMessage;
 247                 }
 248
 249                 for (int funcNdx = 0; funcNdx < funcNames.numFunctions; funcNdx++)
 250                 {
 251                         const char*     funcName                        = funcNames.functions[funcNdx];
 252                         void            (*funcPtr)(void);
 253
 254                         funcPtr = eglGetProcAddress(funcName);
 255                         eglu::checkError(eglGetError(), "eglGetProcAddress()", __FILE__, __LINE__);
 256
 257                         if (apiSupported && funcPtrSupported && (funcPtr == 0))
 258                         {
 259                                 log << TestLog::Message << "Fail, received null pointer for supported function: " << funcName << TestLog::EndMessage;
 260                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected null pointer");
 261                         }
 262                         else if (!apiSupported && (funcPtr != 0))
 263                         {
 264                                 log << TestLog::Message << "Warning, received non-null value for unsupported function: " << funcName << TestLog::EndMessage;
 265                                 m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Non-null value for unsupported function");
 266                         }
 267                 }
 268         }
 269
 270 private:
 271         const EGLint    m_apiBit;
 272 };
 273
 274 GetProcAddressTests::GetProcAddressTests (EglTestContext& eglTestCtx)
 275         : TestCaseGroup(eglTestCtx, "get_proc_address", "eglGetProcAddress() tests")
 276 {
 277 }
 278
 279 GetProcAddressTests::~GetProcAddressTests (void)
 280 {
 281 }
 282
 283 void GetProcAddressTests::init (void)
 284 {
 285         // extensions
 286         {
 287                 tcu::TestCaseGroup* extensionsGroup = new tcu::TestCaseGroup(m_testCtx, "extension", "Test EGL extensions");
 288                 addChild(extensionsGroup);
 289
 290                 for (int extNdx = 0; extNdx < DE_LENGTH_OF_ARRAY(s_extensions); extNdx++)
 291                 {
 292                         const std::string&              extName         = s_extensions[extNdx].name;
 293                         std::string                             testName        (extName);
 294
 295                         for (size_t ndx = 0; ndx < extName.length(); ndx++)
 296                                 testName[ndx] = de::toLower(extName[ndx]);
 297
 298                         extensionsGroup->addChild(new GetProcAddressExtensionCase(m_eglTestCtx, testName.c_str(), ("Test " + extName).c_str(), extName));
 299                 }
 300         }
 301
 302         // core functions
 303         {
 304                 tcu::TestCaseGroup* coreFuncGroup = new tcu::TestCaseGroup(m_testCtx, "core", "Test core functions");
 305                 addChild(coreFuncGroup);
 306
 307                 coreFuncGroup->addChild(new GetProcAddressCoreFunctionsCase     (m_eglTestCtx,  "egl",          "Test EGL core functions",                      0));
 308                 coreFuncGroup->addChild(new GetProcAddressCoreFunctionsCase     (m_eglTestCtx,  "gles",         "Test OpenGL ES core functions",        EGL_OPENGL_ES_BIT));
 309                 coreFuncGroup->addChild(new GetProcAddressCoreFunctionsCase     (m_eglTestCtx,  "gles2",        "Test OpenGL ES 2 core functions",      EGL_OPENGL_ES2_BIT));
 310                 coreFuncGroup->addChild(new GetProcAddressCoreFunctionsCase     (m_eglTestCtx,  "gles3",        "Test OpenGL ES 3 core functions",      EGL_OPENGL_ES3_BIT_KHR));
 311         }
 312 }
 313
 314 } // egl
 315 } // deqp