modules/egl/teglQueryConfigTests.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 Config query tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "teglQueryConfigTests.hpp"
  25 #include "teglSimpleConfigCase.hpp"
  26 #include "tcuTestLog.hpp"
  27 #include "tcuTestContext.hpp"
  28 #include "tcuCommandLine.hpp"
  29 #include "egluCallLogWrapper.hpp"
  30 #include "egluStrUtil.hpp"
  31 #include "egluUtil.hpp"
  32 #include "eglwLibrary.hpp"
  33 #include "eglwEnums.hpp"
  34 #include "deRandom.hpp"
  35
  36 #include <string>
  37 #include <vector>
  38
  39 namespace deqp
  40 {
  41 namespace egl
  42 {
  43
  44 using eglu::ConfigInfo;
  45 using tcu::TestLog;
  46 using namespace eglw;
  47
  48 static void logConfigAttribute (TestLog& log, EGLenum attrib, EGLint value)
  49 {
  50         log << TestLog::Message << "  " << eglu::getConfigAttribName(attrib) << ": " << eglu::getConfigAttribValueStr(attrib, value) << TestLog::EndMessage;
  51 }
  52
  53 static bool isAttributePresent (const eglu::Version& version, EGLenum attribute)
  54 {
  55         switch (attribute)
  56         {
  57                 case EGL_CONFORMANT:
  58                         if (version < eglu::Version(1, 3)) return false;
  59                         break;
  60                 case EGL_LUMINANCE_SIZE:
  61                 case EGL_ALPHA_MASK_SIZE:
  62                 case EGL_COLOR_BUFFER_TYPE:
  63                 case EGL_MATCH_NATIVE_PIXMAP:
  64                         if (version < eglu::Version(1, 2)) return false;
  65                         break;
  66                 case EGL_BIND_TO_TEXTURE_RGB:
  67                 case EGL_BIND_TO_TEXTURE_RGBA:
  68                 case EGL_MAX_SWAP_INTERVAL:
  69                 case EGL_MIN_SWAP_INTERVAL:
  70                 case EGL_RENDERABLE_TYPE:
  71                         if (version < eglu::Version(1, 1)) return false;
  72                         break;
  73                 default:
  74                         break;
  75         }
  76
  77         return true;
  78 }
  79
  80 class GetConfigsBoundsCase : public TestCase, protected eglu::CallLogWrapper
  81 {
  82 public:
  83         GetConfigsBoundsCase (EglTestContext& eglTestCtx, const char* name, const char* description)
  84                 : TestCase              (eglTestCtx, name, description)
  85                 , CallLogWrapper(eglTestCtx.getLibrary(), eglTestCtx.getTestContext().getLog())
  86                 , m_display             (EGL_NO_DISPLAY)
  87         {
  88         }
  89
  90         void init (void)
  91         {
  92                 DE_ASSERT(m_display == EGL_NO_DISPLAY);
  93                 m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
  94                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
  95         }
  96
  97         void deinit (void)
  98         {
  99                 m_eglTestCtx.getLibrary().terminate(m_display);
 100                 m_display = EGL_NO_DISPLAY;
 101         }
 102
 103         void checkGetConfigsBounds (de::Random& rnd, const int numConfigAll, const int numConfigRequested)
 104         {
 105                 tcu::TestLog&                   log                             = m_testCtx.getLog();
 106                 std::vector<EGLConfig>  buffer                  (numConfigAll + 10);
 107
 108                 std::vector<deUint32>   magicBuffer             ((buffer.size() * sizeof(EGLConfig)) / sizeof(deUint32) + 1);
 109                 const EGLConfig*                magicConfigs    = reinterpret_cast<EGLConfig*>(&magicBuffer[0]);
 110
 111                 int                                             numConfigReturned;
 112
 113                 // Fill buffers with magic
 114                 for (size_t ndx = 0; ndx < magicBuffer.size(); ndx++)   magicBuffer[ndx]        = rnd.getUint32();
 115                 for (size_t ndx = 0; ndx < buffer.size(); ndx++)                buffer[ndx]                     = magicConfigs[ndx];
 116
 117                 eglGetConfigs(m_display, &buffer[0], numConfigRequested, &numConfigReturned);
 118                 eglu::checkError(eglGetError(), DE_NULL, __FILE__, __LINE__);
 119
 120                 log << TestLog::Message << numConfigReturned << " configs returned" << TestLog::EndMessage;
 121
 122                 // Compare results with stored magic
 123                 {
 124                         int     numOverwritten  = 0;
 125
 126                         for (size_t ndx = 0; ndx < buffer.size(); ndx++)
 127                         {
 128                                 if (buffer[ndx] == magicConfigs[ndx])
 129                                 {
 130                                         numOverwritten = (int)ndx;
 131                                         break;
 132                                 }
 133                         }
 134
 135                         log << TestLog::Message << numOverwritten << " values actually written" << TestLog::EndMessage;
 136
 137                         if (numConfigReturned > deMax32(numConfigRequested, 0))
 138                         {
 139                                 log << TestLog::Message << "Fail, more configs returned than requested." << TestLog::EndMessage;
 140                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Too many configs returned");
 141                         }
 142
 143                         if (numOverwritten > deMax32(numConfigReturned, 0))
 144                         {
 145                                 log << TestLog::Message << "Fail, buffer overflow detected." << TestLog::EndMessage;
 146                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Buffer overflow");
 147                         }
 148                         else if (numOverwritten != numConfigReturned)
 149                         {
 150                                 log << TestLog::Message << "Fail, reported number of returned configs differs from number of values written." << TestLog::EndMessage;
 151                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Incorrect size");
 152                         }
 153                 }
 154         }
 155
 156         IterateResult iterate (void)
 157         {
 158                 tcu::TestLog&   log             = m_testCtx.getLog();
 159                 EGLint                  numConfigAll;
 160
 161                 enableLogging(true);
 162
 163                 eglGetConfigs(m_display, 0, 0, &numConfigAll);
 164
 165                 log << TestLog::Message << numConfigAll << " configs available" << TestLog::EndMessage;
 166                 log << TestLog::Message << TestLog::EndMessage;
 167
 168                 if (numConfigAll > 0)
 169                 {
 170                         de::Random              rnd                                     (123);
 171
 172                         for (int i = 0; i < 5; i++)
 173                         {
 174                                 checkGetConfigsBounds(rnd, numConfigAll, rnd.getInt(0, numConfigAll));
 175                                 log << TestLog::Message << TestLog::EndMessage;
 176                         }
 177
 178                         checkGetConfigsBounds(rnd, numConfigAll, -1);
 179                 }
 180                 else
 181                 {
 182                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "No configs");
 183                 }
 184
 185                 enableLogging(false);
 186
 187                 return STOP;
 188         }
 189
 190 protected:
 191         EGLDisplay      m_display;
 192 };
 193
 194 class GetConfigAttribCase : public TestCase, protected eglu::CallLogWrapper
 195 {
 196 public:
 197         GetConfigAttribCase (EglTestContext& eglTestCtx, const char* name, const char* description);
 198
 199         void                    init            (void);
 200         void                    deinit          (void);
 201         IterateResult   iterate         (void);
 202
 203         EGLint                  getValue        (EGLConfig config, EGLenum attrib, bool logValue=true);
 204
 205         virtual void    executeTest     (EGLConfig config) = 0;
 206
 207 protected:
 208         EGLDisplay                                                              m_display;
 209
 210 private:
 211         std::vector<EGLConfig>                                  m_configs;
 212         std::vector<EGLConfig>::const_iterator  m_configsIter;
 213 };
 214
 215 GetConfigAttribCase::GetConfigAttribCase (EglTestContext& eglTestCtx, const char* name, const char* description)
 216         : TestCase                      (eglTestCtx, name, description)
 217         , CallLogWrapper        (eglTestCtx.getLibrary(), eglTestCtx.getTestContext().getLog())
 218         , m_display                     (EGL_NO_DISPLAY)
 219 {
 220 }
 221
 222 void GetConfigAttribCase::init (void)
 223 {
 224         DE_ASSERT(m_display == EGL_NO_DISPLAY);
 225         m_display               = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
 226         m_configs               = eglu::getConfigs(m_eglTestCtx.getLibrary(), m_display);
 227         m_configsIter   = m_configs.begin();
 228
 229         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 230 }
 231
 232 void GetConfigAttribCase::deinit (void)
 233 {
 234         m_eglTestCtx.getLibrary().terminate(m_display);
 235         m_display = EGL_NO_DISPLAY;
 236 }
 237
 238 tcu::TestNode::IterateResult GetConfigAttribCase::iterate (void)
 239 {
 240         tcu::TestLog&   log             = m_testCtx.getLog();
 241
 242         if (m_configsIter == m_configs.end())
 243         {
 244                 log << TestLog::Message << "No configs available." << TestLog::EndMessage;
 245                 return STOP;
 246         }
 247
 248         {
 249                 const EGLConfig config  = *m_configsIter;
 250                 EGLint                  id;
 251
 252                 eglGetConfigAttrib(m_display, config, EGL_CONFIG_ID, &id);
 253                 eglu::checkError(eglGetError(), DE_NULL, __FILE__, __LINE__);
 254                 log << TestLog::Message << "Config ID " << id << TestLog::EndMessage;
 255
 256                 executeTest(config);
 257         }
 258
 259         log << TestLog::Message << TestLog::EndMessage;
 260
 261         m_configsIter++;
 262
 263         if (m_configsIter == m_configs.end())
 264                 return STOP;
 265         else
 266                 return CONTINUE;
 267 }
 268
 269 EGLint GetConfigAttribCase::getValue (EGLConfig config, EGLenum attrib, bool logValue)
 270 {
 271         TestLog&        log             = m_testCtx.getLog();
 272         EGLint          value;
 273
 274         eglGetConfigAttrib(m_display, config, attrib, &value);
 275         eglu::checkError(eglGetError(), DE_NULL, __FILE__, __LINE__);
 276
 277         if (logValue)
 278                 logConfigAttribute(log, attrib, value);
 279
 280         return value;
 281 }
 282
 283 class GetConfigAttribSimpleCase : public GetConfigAttribCase
 284 {
 285 public:
 286         GetConfigAttribSimpleCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLenum attribute)
 287                 : GetConfigAttribCase(eglTestCtx, name, description)
 288                 , m_attrib(attribute)
 289         {
 290         }
 291
 292         void checkColorBufferType (EGLint value)
 293         {
 294                 const bool isRGBBuffer                  = value == EGL_RGB_BUFFER;
 295                 const bool isLuminanceBuffer    = value == EGL_LUMINANCE_BUFFER;
 296                 const bool isYuvBuffer                  = value == EGL_YUV_BUFFER_EXT;
 297                 const bool hasYuvSupport                = eglu::hasExtension(m_eglTestCtx.getLibrary(), m_display, "EGL_EXT_yuv_surface");
 298
 299                 if (!(isRGBBuffer || isLuminanceBuffer || (isYuvBuffer && hasYuvSupport)))
 300                 {
 301                         TestLog&        log     = m_testCtx.getLog();
 302
 303                         log << TestLog::Message << "Fail, invalid EGL_COLOR_BUFFER_TYPE value" << TestLog::EndMessage;
 304                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid value");
 305                 }
 306         }
 307
 308         void checkCaveat (EGLint value)
 309         {
 310                 if (!(value == EGL_NONE || value == EGL_SLOW_CONFIG || value == EGL_NON_CONFORMANT_CONFIG))
 311                 {
 312                         TestLog&        log     = m_testCtx.getLog();
 313
 314                         log << TestLog::Message << "Fail, invalid EGL_CONFIG_CAVEAT value" << TestLog::EndMessage;
 315                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid value");
 316                 }
 317         }
 318
 319         void checkTransparentType (EGLint value)
 320         {
 321                 if (!(value == EGL_NONE || value == EGL_TRANSPARENT_RGB))
 322                 {
 323                         TestLog&        log     = m_testCtx.getLog();
 324
 325                         log << TestLog::Message << "Fail, invalid EGL_TRANSPARENT_TYPE value" << TestLog::EndMessage;
 326                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid value");
 327                 }
 328         }
 329
 330         void checkBoolean (EGLenum attrib, EGLint value)
 331         {
 332                 if (!(value == EGL_FALSE || value == EGL_TRUE))
 333                 {
 334                         TestLog&        log     = m_testCtx.getLog();
 335
 336                         log << TestLog::Message << "Fail, " << eglu::getConfigAttribStr(attrib) << " should be a boolean value." << TestLog::EndMessage;
 337                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid value");
 338                 }
 339         }
 340
 341         void checkInteger (EGLenum attrib, EGLint value)
 342         {
 343                 if (attrib == EGL_NATIVE_VISUAL_ID || attrib == EGL_NATIVE_VISUAL_TYPE) // Implementation-defined
 344                         return;
 345
 346                 if (attrib == EGL_CONFIG_ID && value < 1)
 347                 {
 348                         TestLog&        log     = m_testCtx.getLog();
 349
 350                         log << TestLog::Message << "Fail, config IDs should be positive integer values beginning from 1." << TestLog::EndMessage;
 351                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid value");
 352                 }
 353         }
 354
 355         void checkSurfaceTypeMask (EGLint value)
 356         {
 357                 const EGLint    wantedBits      = EGL_WINDOW_BIT | EGL_PIXMAP_BIT | EGL_PBUFFER_BIT;
 358
 359                 if ((value & wantedBits) == 0)
 360                 {
 361                         TestLog&        log     = m_testCtx.getLog();
 362
 363                         log << TestLog::Message << "Fail, config does not actually support creation of any surface type?" << TestLog::EndMessage;
 364                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid value");
 365                 }
 366         }
 367
 368         void checkAttribute (EGLenum attrib, EGLint value)
 369         {
 370                 switch (attrib)
 371                 {
 372                         case EGL_COLOR_BUFFER_TYPE:
 373                                 checkColorBufferType(value);
 374                                 break;
 375                         case EGL_CONFIG_CAVEAT:
 376                                 checkCaveat(value);
 377                                 break;
 378                         case EGL_TRANSPARENT_TYPE:
 379                                 checkTransparentType(value);
 380                                 break;
 381                         case EGL_CONFORMANT:
 382                         case EGL_RENDERABLE_TYPE:
 383                                 // Just print what we know
 384                                 break;
 385                         case EGL_SURFACE_TYPE:
 386                                 checkSurfaceTypeMask(value);
 387                                 break;
 388                         case EGL_BIND_TO_TEXTURE_RGB:
 389                         case EGL_BIND_TO_TEXTURE_RGBA:
 390                         case EGL_NATIVE_RENDERABLE:
 391                                 checkBoolean(attrib, value);
 392                                 break;
 393                         default:
 394                                 checkInteger(attrib, value);
 395                 }
 396         }
 397
 398         void executeTest (EGLConfig config)
 399         {
 400                 TestLog&                        log             = m_testCtx.getLog();
 401                 eglu::Version           version = eglu::getVersion(m_eglTestCtx.getLibrary(), m_display);
 402
 403                 if (!isAttributePresent(version, m_attrib))
 404                 {
 405                         log << TestLog::Message << eglu::getConfigAttribStr(m_attrib) << " not supported by this EGL version";
 406                 }
 407                 else
 408                 {
 409                         EGLint                  value;
 410
 411                         enableLogging(true);
 412
 413                         eglGetConfigAttrib(m_display, config, m_attrib, &value);
 414                         eglu::checkError(eglGetError(), DE_NULL, __FILE__, __LINE__);
 415
 416                         logConfigAttribute(log, m_attrib, value);
 417                         checkAttribute(m_attrib, value);
 418
 419                         enableLogging(false);
 420                 }
 421         }
 422
 423 private:
 424         EGLenum m_attrib;
 425 };
 426
 427 class GetConfigAttribBufferSizeCase : public GetConfigAttribCase
 428 {
 429 public:
 430         GetConfigAttribBufferSizeCase (EglTestContext& eglTestCtx, const char* name, const char* description)
 431                 : GetConfigAttribCase(eglTestCtx, name, description)
 432         {
 433         }
 434
 435         void executeTest (EGLConfig config)
 436         {
 437                 TestLog&                log                             = m_testCtx.getLog();
 438
 439                 const EGLint    colorBufferType = getValue(config, EGL_COLOR_BUFFER_TYPE);
 440
 441                 const EGLint    bufferSize              = getValue(config, EGL_BUFFER_SIZE);
 442                 const EGLint    redSize                 = getValue(config, EGL_RED_SIZE);
 443                 const EGLint    greenSize               = getValue(config, EGL_GREEN_SIZE);
 444                 const EGLint    blueSize                = getValue(config, EGL_BLUE_SIZE);
 445                 const EGLint    luminanceSize   = getValue(config, EGL_LUMINANCE_SIZE);
 446                 const EGLint    alphaSize               = getValue(config, EGL_ALPHA_SIZE);
 447
 448                 if (alphaSize < 0)
 449                 {
 450                         log << TestLog::Message << "Fail, alpha size must be zero or positive." << TestLog::EndMessage;
 451                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid alpha size");
 452                 }
 453
 454                 if (colorBufferType == EGL_RGB_BUFFER)
 455                 {
 456                         if (luminanceSize != 0)
 457                         {
 458                                 log << TestLog::Message << "Fail, luminance size must be zero for an RGB buffer." << TestLog::EndMessage;
 459                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid luminance size");
 460                         }
 461
 462                         if (redSize <= 0 || greenSize <= 0  || blueSize <= 0)
 463                         {
 464                                 log << TestLog::Message << "Fail, RGB component sizes must be positive for an RGB buffer." << TestLog::EndMessage;
 465                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid color component size");
 466                         }
 467
 468                         if (bufferSize != (redSize + greenSize + blueSize + alphaSize))
 469                         {
 470                                 log << TestLog::Message << "Fail, buffer size must be equal to the sum of RGB component sizes and alpha size." << TestLog::EndMessage;
 471                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid buffer size");
 472                         }
 473                 }
 474                 else if (colorBufferType == EGL_LUMINANCE_BUFFER)
 475                 {
 476                         if (luminanceSize <= 0)
 477                         {
 478                                 log << TestLog::Message << "Fail, luminance size must be positive for a luminance buffer." << TestLog::EndMessage;
 479                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid luminance size");
 480                         }
 481
 482                         if (redSize != 0 || greenSize != 0  || blueSize != 0)
 483                         {
 484                                 log << TestLog::Message << "Fail, RGB component sizes must be zero for a luminance buffer." << TestLog::EndMessage;
 485                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid color component size");
 486                         }
 487
 488                         if (bufferSize != (luminanceSize + alphaSize))
 489                         {
 490                                 log << TestLog::Message << "Fail, buffer size must be equal to the sum of luminance size and alpha size." << TestLog::EndMessage;
 491                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid buffer size");
 492                         }
 493                 }
 494         }
 495 };
 496
 497 class GetConfigAttribTransparentValueCase : public GetConfigAttribCase
 498 {
 499 public:
 500         GetConfigAttribTransparentValueCase (EglTestContext& eglTestCtx, const char* name, const char* description)
 501                 : GetConfigAttribCase(eglTestCtx, name, description)
 502         {
 503         }
 504
 505         void executeTest (EGLConfig config)
 506         {
 507                 TestLog&                log     = m_testCtx.getLog();
 508
 509                 const EGLint    transparentType = getValue(config, EGL_TRANSPARENT_TYPE);
 510                 const EGLint    redValue                = getValue(config, EGL_TRANSPARENT_RED_VALUE);
 511                 const EGLint    greenValue              = getValue(config, EGL_TRANSPARENT_GREEN_VALUE);
 512                 const EGLint    blueValue               = getValue(config, EGL_TRANSPARENT_BLUE_VALUE);
 513
 514                 const EGLint    redSize                 = getValue(config, EGL_RED_SIZE);
 515                 const EGLint    greenSize               = getValue(config, EGL_GREEN_SIZE);
 516                 const EGLint    blueSize                = getValue(config, EGL_BLUE_SIZE);
 517
 518                 if (transparentType == EGL_TRANSPARENT_RGB)
 519                 {
 520                         if (   (redValue        < 0     || redValue             >= (1 << redSize))
 521                                 || (greenValue  < 0     || greenValue   >= (1 << greenSize))
 522                                 || (blueValue   < 0     || blueValue    >= (1 << blueSize))     )
 523                         {
 524                                 log << TestLog::Message << "Fail, transparent color values must lie between 0 and the maximum component value." << TestLog::EndMessage;
 525                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid transparent color value");
 526                         }
 527                 }
 528         }
 529 };
 530
 531 QueryConfigTests::QueryConfigTests (EglTestContext& eglTestCtx)
 532         : TestCaseGroup(eglTestCtx, "query_config", "Surface config query tests")
 533 {
 534 }
 535
 536 QueryConfigTests::~QueryConfigTests (void)
 537 {
 538 }
 539
 540 void QueryConfigTests::init (void)
 541 {
 542         // eglGetGonfigs
 543         {
 544                 tcu::TestCaseGroup* getConfigsGroup = new tcu::TestCaseGroup(m_testCtx, "get_configs", "eglGetConfigs tests");
 545                 addChild(getConfigsGroup);
 546
 547                 getConfigsGroup->addChild(new GetConfigsBoundsCase(m_eglTestCtx, "get_configs_bounds", "eglGetConfigs bounds checking test"));
 548         }
 549
 550         // eglGetConfigAttrib
 551         {
 552                 static const struct
 553                 {
 554                         EGLenum                 attribute;
 555                         const char*             testName;
 556                 } attributes[] =
 557                 {
 558                         { EGL_BUFFER_SIZE,                              "buffer_size"                           },
 559                         { EGL_RED_SIZE,                                 "red_size"                                      },
 560                         { EGL_GREEN_SIZE,                               "green_size"                            },
 561                         { EGL_BLUE_SIZE,                                "blue_size"                                     },
 562                         { EGL_LUMINANCE_SIZE,                   "luminance_size"                        },
 563                         { EGL_ALPHA_SIZE,                               "alpha_size"                            },
 564                         { EGL_ALPHA_MASK_SIZE,                  "alpha_mask_size"                       },
 565                         { EGL_BIND_TO_TEXTURE_RGB,              "bind_to_texture_rgb"           },
 566                         { EGL_BIND_TO_TEXTURE_RGBA,             "bind_to_texture_rgba"          },
 567                         { EGL_COLOR_BUFFER_TYPE,                "color_buffer_type"                     },
 568                         { EGL_CONFIG_CAVEAT,                    "config_caveat"                         },
 569                         { EGL_CONFIG_ID,                                "config_id"                                     },
 570                         { EGL_CONFORMANT,                               "conformant"                            },
 571                         { EGL_DEPTH_SIZE,                               "depth_size"                            },
 572                         { EGL_LEVEL,                                    "level"                                         },
 573                         { EGL_MAX_SWAP_INTERVAL,                "max_swap_interval"                     },
 574                         { EGL_MIN_SWAP_INTERVAL,                "min_swap_interval"                     },
 575                         { EGL_NATIVE_RENDERABLE,                "native_renderable"                     },
 576                         { EGL_NATIVE_VISUAL_TYPE,               "native_visual_type"            },
 577                         { EGL_RENDERABLE_TYPE,                  "renderable_type"                       },
 578                         { EGL_SAMPLE_BUFFERS,                   "sample_buffers"                        },
 579                         { EGL_SAMPLES,                                  "samples"                                       },
 580                         { EGL_STENCIL_SIZE,                             "stencil_size"                          },
 581                         { EGL_SURFACE_TYPE,                             "surface_type"                          },
 582                         { EGL_TRANSPARENT_TYPE,                 "transparent_type"                      },
 583                         { EGL_TRANSPARENT_RED_VALUE,    "transparent_red_value"         },
 584                         { EGL_TRANSPARENT_GREEN_VALUE,  "transparent_green_value"       },
 585                         { EGL_TRANSPARENT_BLUE_VALUE,   "transparent_blue_value"        }
 586                 };
 587
 588                 tcu::TestCaseGroup* simpleGroup = new tcu::TestCaseGroup(m_testCtx, "get_config_attrib", "eglGetConfigAttrib() tests");
 589                 addChild(simpleGroup);
 590
 591                 for (int ndx = 0; ndx < (int)DE_LENGTH_OF_ARRAY(attributes); ndx++)
 592                 {
 593                         simpleGroup->addChild(new GetConfigAttribSimpleCase(m_eglTestCtx, attributes[ndx].testName, "Simple attribute query case", attributes[ndx].attribute));
 594                 }
 595         }
 596
 597         // Attribute constraints
 598         {
 599                 tcu::TestCaseGroup* constraintsGroup = new tcu::TestCaseGroup(m_testCtx, "constraints", "Attribute constraint tests");
 600                 addChild(constraintsGroup);
 601
 602                 constraintsGroup->addChild(new GetConfigAttribBufferSizeCase(m_eglTestCtx,                      "color_buffer_size",    "Color buffer component sizes"));
 603                 constraintsGroup->addChild(new GetConfigAttribTransparentValueCase(m_eglTestCtx,        "transparent_value",    "Transparent color value"));
 604         }
 605 }
 606
 607 } // egl
 608 } // deqp