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 Choose config tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "teglChooseConfigTests.hpp" 25 #include "teglChooseConfigReference.hpp" 26 #include "tcuTestLog.hpp" 27 #include "egluStrUtil.hpp" 28 #include "egluUtil.hpp" 29 #include "eglwLibrary.hpp" 30 #include "eglwEnums.hpp" 31 #include "deRandom.hpp" 32 #include "deStringUtil.hpp" 33 #include "deUniquePtr.hpp" 34 #include "deSTLUtil.hpp" 35 36 #include <vector> 37 #include <algorithm> 38 #include <string> 39 #include <set> 40 #include <map> 41 42 namespace deqp 43 { 44 namespace egl 45 { 46 47 using std::set; 48 using std::vector; 49 using std::pair; 50 using std::string; 51 using tcu::TestLog; 52 using eglu::ConfigInfo; 53 using namespace eglw; 54 55 namespace 56 { 57 58 string configListToString (const Library& egl, const EGLDisplay& display, const vector<EGLConfig>& configs) 59 { 60 string str = ""; 61 for (vector<EGLConfig>::const_iterator cfgIter = configs.begin(); cfgIter != configs.end(); cfgIter++) 62 { 63 EGLConfig config = *cfgIter; 64 EGLint configId = eglu::getConfigID(egl, display, config); 65 66 if (str.length() != 0) 67 str += " "; 68 69 str += de::toString(configId); 70 } 71 return str; 72 } 73 74 void logConfigAttrib (TestLog& log, EGLenum attrib, EGLint value) 75 { 76 const std::string attribStr = eglu::getConfigAttribName(attrib); 77 78 if (value == EGL_DONT_CARE) 79 { 80 log << TestLog::Message << " " << attribStr << ": EGL_DONT_CARE" << TestLog::EndMessage; 81 return; 82 } 83 84 log << TestLog::Message << " " << attribStr << ": " << eglu::getConfigAttribValueStr(attrib, value) << TestLog::EndMessage; 85 } 86 87 bool configListEqual (const Library& egl, const EGLDisplay& display, const vector<EGLConfig>& as, const vector<EGLConfig>& bs) 88 { 89 if (as.size() != bs.size()) 90 return false; 91 92 for (int configNdx = 0; configNdx < (int)as.size(); configNdx++) 93 { 94 if (as[configNdx] != bs[configNdx]) 95 { 96 // Allow lists to differ if both configs are non-conformant 97 const EGLint aCaveat = eglu::getConfigAttribInt(egl, display, as[configNdx], EGL_CONFIG_CAVEAT); 98 const EGLint bCaveat = eglu::getConfigAttribInt(egl, display, bs[configNdx], EGL_CONFIG_CAVEAT); 99 100 if (aCaveat != EGL_NON_CONFORMANT_CONFIG || bCaveat != EGL_NON_CONFORMANT_CONFIG) 101 return false; 102 } 103 } 104 105 return true; 106 } 107 108 } // anonymous 109 110 class ChooseConfigCase : public TestCase 111 { 112 public: 113 ChooseConfigCase (EglTestContext& eglTestCtx, const char* name, const char* description, bool checkOrder, const EGLint* attributes) 114 : TestCase (eglTestCtx, name, description) 115 , m_checkOrder (checkOrder) 116 , m_display (EGL_NO_DISPLAY) 117 { 118 // Parse attributes 119 while (attributes[0] != EGL_NONE) 120 { 121 m_attributes.push_back(std::make_pair((EGLenum)attributes[0], (EGLint)attributes[1])); 122 attributes += 2; 123 } 124 } 125 126 ChooseConfigCase (EglTestContext& eglTestCtx, const char* name, const char* description, bool checkOrder, const std::vector<std::pair<EGLenum, EGLint> >& attributes) 127 : TestCase (eglTestCtx, name, description) 128 , m_checkOrder (checkOrder) 129 , m_attributes (attributes) 130 , m_display (EGL_NO_DISPLAY) 131 { 132 } 133 134 void init (void) 135 { 136 DE_ASSERT(m_display == EGL_NO_DISPLAY); 137 m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay()); 138 } 139 140 void deinit (void) 141 { 142 m_eglTestCtx.getLibrary().terminate(m_display); 143 m_display = EGL_NO_DISPLAY; 144 } 145 146 IterateResult iterate (void) 147 { 148 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 149 executeTest(m_attributes, m_checkOrder); 150 return STOP; 151 } 152 153 protected: 154 ChooseConfigCase (EglTestContext& eglTestCtx, const char* name, const char* description, bool checkOrder) 155 : TestCase (eglTestCtx, name, description) 156 , m_checkOrder (checkOrder) 157 , m_display (EGL_NO_DISPLAY) 158 { 159 } 160 161 void executeTest (const std::vector<std::pair<EGLenum, EGLint> >& attributes, bool checkOrder) 162 { 163 const Library& egl = m_eglTestCtx.getLibrary(); 164 TestLog& log = m_testCtx.getLog(); 165 166 // Build attributes for EGL 167 vector<EGLint> attribList; 168 for (vector<pair<EGLenum, EGLint> >::const_iterator i = attributes.begin(); i != attributes.end(); i++) 169 { 170 attribList.push_back(i->first); 171 attribList.push_back(i->second); 172 } 173 attribList.push_back(EGL_NONE); 174 175 // Print attribList to log 176 log << TestLog::Message << "Attributes:" << TestLog::EndMessage; 177 for (vector<pair<EGLenum, EGLint> >::const_iterator i = attributes.begin(); i != attributes.end(); i++) 178 logConfigAttrib(log, i->first, i->second); 179 180 std::vector<EGLConfig> resultConfigs; 181 std::vector<EGLConfig> referenceConfigs; 182 183 // Query from EGL implementation 184 { 185 EGLint numConfigs = 0; 186 EGLU_CHECK_CALL(egl, chooseConfig(m_display, &attribList[0], DE_NULL, 0, &numConfigs)); 187 resultConfigs.resize(numConfigs); 188 189 if (numConfigs > 0) 190 EGLU_CHECK_CALL(egl, chooseConfig(m_display, &attribList[0], &resultConfigs[0], (EGLint)resultConfigs.size(), &numConfigs)); 191 } 192 193 // Build reference 194 chooseConfigReference(egl, m_display, referenceConfigs, attributes); 195 196 log << TestLog::Message << "Expected:\n " << configListToString(egl, m_display, referenceConfigs) << TestLog::EndMessage; 197 log << TestLog::Message << "Got:\n " << configListToString(egl, m_display, resultConfigs) << TestLog::EndMessage; 198 199 bool isSetMatch = (set<EGLConfig>(resultConfigs.begin(), resultConfigs.end()) == set<EGLConfig>(referenceConfigs.begin(), referenceConfigs.end())); 200 bool isExactMatch = configListEqual(egl, m_display, resultConfigs, referenceConfigs); 201 bool isMatch = isSetMatch && (checkOrder ? isExactMatch : true); 202 203 if (isMatch) 204 log << TestLog::Message << "Pass" << TestLog::EndMessage; 205 else if (!isSetMatch) 206 log << TestLog::Message << "Fail, configs don't match" << TestLog::EndMessage; 207 else if (!isExactMatch) 208 log << TestLog::Message << "Fail, got correct configs but in invalid order" << TestLog::EndMessage; 209 210 if (!isMatch) 211 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 212 } 213 214 void fillDontCare (std::vector<std::pair<EGLenum, EGLint> >& attributes) 215 { 216 static const EGLenum dontCareAttributes[] = 217 { 218 EGL_TRANSPARENT_TYPE, 219 EGL_COLOR_BUFFER_TYPE, 220 EGL_RENDERABLE_TYPE, 221 EGL_SURFACE_TYPE 222 }; 223 224 // Fill appropriate unused attributes with EGL_DONT_CARE 225 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(dontCareAttributes); ndx++) 226 { 227 bool found = false; 228 for (size_t findNdx = 0; findNdx < attributes.size(); findNdx++) 229 if (attributes[findNdx].first == dontCareAttributes[ndx]) found = true; 230 231 if (!found) attributes.push_back(std::make_pair(dontCareAttributes[ndx], EGL_DONT_CARE)); 232 } 233 } 234 235 const bool m_checkOrder; 236 vector<pair<EGLenum, EGLint> > m_attributes; 237 238 EGLDisplay m_display; 239 }; 240 241 class ChooseConfigSimpleCase : public ChooseConfigCase 242 { 243 protected: 244 EGLint getValue (EGLenum name) 245 { 246 static const struct 247 { 248 EGLenum name; 249 EGLint value; 250 } attributes[] = 251 { 252 { EGL_BUFFER_SIZE, 0 }, 253 { EGL_RED_SIZE, 0 }, 254 { EGL_GREEN_SIZE, 0 }, 255 { EGL_BLUE_SIZE, 0 }, 256 { EGL_LUMINANCE_SIZE, 0 }, 257 { EGL_ALPHA_SIZE, 0 }, 258 { EGL_ALPHA_MASK_SIZE, 0 }, 259 { EGL_BIND_TO_TEXTURE_RGB, EGL_DONT_CARE }, 260 { EGL_BIND_TO_TEXTURE_RGBA, EGL_DONT_CARE }, 261 { EGL_COLOR_BUFFER_TYPE, EGL_DONT_CARE }, 262 { EGL_CONFIG_CAVEAT, EGL_DONT_CARE }, 263 //{ EGL_CONFIG_ID, EGL_DONT_CARE }, 264 { EGL_DEPTH_SIZE, 0 }, 265 { EGL_LEVEL, 0 }, 266 { EGL_MAX_SWAP_INTERVAL, EGL_DONT_CARE }, 267 { EGL_MIN_SWAP_INTERVAL, EGL_DONT_CARE }, 268 { EGL_NATIVE_RENDERABLE, EGL_DONT_CARE }, 269 { EGL_NATIVE_VISUAL_TYPE, EGL_DONT_CARE }, 270 { EGL_SAMPLE_BUFFERS, 0 }, 271 { EGL_SAMPLES, 0 }, 272 { EGL_STENCIL_SIZE, 0 }, 273 { EGL_TRANSPARENT_TYPE, EGL_TRANSPARENT_RGB }, 274 { EGL_TRANSPARENT_RED_VALUE, 0 }, 275 { EGL_TRANSPARENT_GREEN_VALUE, 0 }, 276 { EGL_TRANSPARENT_BLUE_VALUE, 0 }, 277 { EGL_CONFORMANT, EGL_OPENGL_ES_BIT }, 278 { EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT }, 279 { EGL_SURFACE_TYPE, EGL_WINDOW_BIT } 280 //{ EGL_CONFORMANT, EGL_OPENGL_BIT | EGL_OPENGL_ES_BIT | EGL_OPENGL_ES2_BIT | EGL_OPENVG_BIT }, 281 //{ EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT | EGL_OPENGL_ES_BIT | EGL_OPENGL_ES2_BIT | EGL_OPENVG_BIT }, 282 //{ EGL_SURFACE_TYPE, EGL_WINDOW_BIT 283 // | EGL_PIXMAP_BIT 284 // | EGL_PBUFFER_BIT 285 // | EGL_MULTISAMPLE_RESOLVE_BOX_BIT 286 // | EGL_VG_ALPHA_FORMAT_PRE_BIT 287 // | EGL_SWAP_BEHAVIOR_PRESERVED_BIT 288 // | EGL_VG_COLORSPACE_LINEAR_BIT 289 // } 290 }; 291 292 if (name == EGL_CONFIG_ID) 293 { 294 de::Random rnd(0); 295 vector<EGLConfig> configs = eglu::getConfigs(m_eglTestCtx.getLibrary(), m_display); 296 return eglu::getConfigID(m_eglTestCtx.getLibrary(), m_display, configs[rnd.getInt(0, (int)configs.size()-1)]); 297 } 298 else 299 { 300 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(attributes); ndx++) 301 { 302 if (attributes[ndx].name == name) 303 return attributes[ndx].value; 304 } 305 } 306 307 DE_ASSERT(DE_FALSE); 308 return EGL_NONE; 309 } 310 public: 311 ChooseConfigSimpleCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLenum attribute, bool checkOrder) 312 : ChooseConfigCase(eglTestCtx, name, description, checkOrder) 313 , m_attribute(attribute) 314 { 315 } 316 317 TestCase::IterateResult iterate (void) 318 { 319 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 320 321 std::vector<std::pair<EGLenum, EGLint> > attributes; 322 attributes.push_back(std::pair<EGLenum, EGLint>(m_attribute, getValue(m_attribute))); 323 324 fillDontCare(attributes); 325 executeTest(attributes, m_checkOrder); 326 327 return STOP; 328 } 329 private: 330 EGLenum m_attribute; 331 }; 332 333 class ChooseConfigRandomCase : public ChooseConfigCase 334 { 335 public: 336 ChooseConfigRandomCase (EglTestContext& eglTestCtx, const char* name, const char* description, const set<EGLenum>& attribSet) 337 : ChooseConfigCase (eglTestCtx, name, description, true) 338 , m_attribSet (attribSet) 339 , m_numIters (10) 340 , m_iterNdx (0) 341 { 342 } 343 344 void init (void) 345 { 346 ChooseConfigCase::init(); 347 m_iterNdx = 0; 348 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 349 } 350 351 TestCase::IterateResult iterate (void) 352 { 353 m_testCtx.getLog() << TestLog::Message << "Iteration :" << m_iterNdx << TestLog::EndMessage; 354 m_iterNdx += 1; 355 356 // Build random list of attributes 357 de::Random rnd(m_iterNdx); 358 const int numAttribs = rnd.getInt(0, (int)m_attribSet.size()*2); 359 360 std::vector<std::pair<EGLenum, EGLint> > attributes = genRandomAttributes(m_attribSet, numAttribs, rnd); 361 362 fillDontCare(attributes); 363 executeTest(attributes, m_checkOrder); 364 365 return m_iterNdx < m_numIters ? CONTINUE : STOP; 366 } 367 368 template <int MinVal, int MaxVal> static EGLint getInt (de::Random& rnd) 369 { 370 return rnd.getInt(MinVal, MaxVal); 371 } 372 373 static EGLint getBool (de::Random& rnd) 374 { 375 return rnd.getBool() ? EGL_TRUE : EGL_FALSE; 376 } 377 378 static EGLint getBufferType (de::Random& rnd) 379 { 380 static const EGLint types[] = { EGL_RGB_BUFFER, EGL_LUMINANCE_BUFFER }; 381 return rnd.choose<EGLint>(types, types+DE_LENGTH_OF_ARRAY(types)); 382 } 383 384 static EGLint getConfigCaveat (de::Random& rnd) 385 { 386 static const EGLint caveats[] = { EGL_SLOW_CONFIG, EGL_NON_CONFORMANT_CONFIG }; 387 return rnd.choose<EGLint>(caveats, caveats+DE_LENGTH_OF_ARRAY(caveats)); 388 } 389 390 static EGLint getApiBits (de::Random& rnd) 391 { 392 EGLint api = 0; 393 api |= rnd.getBool() ? EGL_OPENGL_BIT : 0; 394 api |= rnd.getBool() ? EGL_OPENGL_ES_BIT : 0; 395 api |= rnd.getBool() ? EGL_OPENGL_ES2_BIT : 0; 396 api |= rnd.getBool() ? EGL_OPENVG_BIT : 0; 397 return api; 398 } 399 400 static EGLint getSurfaceType (de::Random& rnd) 401 { 402 EGLint bits = 0; 403 bits |= rnd.getBool() ? EGL_WINDOW_BIT : 0; 404 bits |= rnd.getBool() ? EGL_PIXMAP_BIT : 0; 405 bits |= rnd.getBool() ? EGL_PBUFFER_BIT : 0; 406 return bits; 407 } 408 409 struct AttribSpec 410 { 411 EGLenum attribute; 412 EGLint (*getValue)(de::Random& rnd); 413 }; 414 415 std::vector<std::pair<EGLenum, EGLint> > genRandomAttributes (const std::set<EGLenum>& attribSet, int numAttribs, de::Random& rnd) 416 { 417 static const struct AttribSpec attributes[] = 418 { 419 { EGL_BUFFER_SIZE, ChooseConfigRandomCase::getInt<0, 32>, }, 420 { EGL_RED_SIZE, ChooseConfigRandomCase::getInt<0, 8>, }, 421 { EGL_GREEN_SIZE, ChooseConfigRandomCase::getInt<0, 8>, }, 422 { EGL_BLUE_SIZE, ChooseConfigRandomCase::getInt<0, 8>, }, 423 { EGL_LUMINANCE_SIZE, ChooseConfigRandomCase::getInt<0, 1>, }, 424 { EGL_ALPHA_SIZE, ChooseConfigRandomCase::getInt<0, 8>, }, 425 { EGL_ALPHA_MASK_SIZE, ChooseConfigRandomCase::getInt<0, 1>, }, 426 { EGL_BIND_TO_TEXTURE_RGB, ChooseConfigRandomCase::getBool, }, 427 { EGL_BIND_TO_TEXTURE_RGBA, ChooseConfigRandomCase::getBool, }, 428 { EGL_COLOR_BUFFER_TYPE, ChooseConfigRandomCase::getBufferType, }, 429 { EGL_CONFIG_CAVEAT, ChooseConfigRandomCase::getConfigCaveat, }, 430 // { EGL_CONFIG_ID, 0/*special*/, }, 431 { EGL_CONFORMANT, ChooseConfigRandomCase::getApiBits, }, 432 { EGL_DEPTH_SIZE, ChooseConfigRandomCase::getInt<0, 32>, }, 433 { EGL_LEVEL, ChooseConfigRandomCase::getInt<0, 1>, }, 434 // { EGL_MATCH_NATIVE_PIXMAP, EGL_NONE, }, 435 { EGL_MAX_SWAP_INTERVAL, ChooseConfigRandomCase::getInt<0, 2>, }, 436 { EGL_MIN_SWAP_INTERVAL, ChooseConfigRandomCase::getInt<0, 1>, }, 437 { EGL_NATIVE_RENDERABLE, ChooseConfigRandomCase::getBool, }, 438 // { EGL_NATIVE_VISUAL_TYPE, EGL_DONT_CARE, }, 439 { EGL_RENDERABLE_TYPE, ChooseConfigRandomCase::getApiBits, }, 440 { EGL_SAMPLE_BUFFERS, ChooseConfigRandomCase::getInt<0, 1>, }, 441 { EGL_SAMPLES, ChooseConfigRandomCase::getInt<0, 1>, }, 442 { EGL_STENCIL_SIZE, ChooseConfigRandomCase::getInt<0, 1>, }, 443 { EGL_SURFACE_TYPE, ChooseConfigRandomCase::getSurfaceType, }, 444 // { EGL_TRANSPARENT_TYPE, EGL_TRANSPARENT_RGB,}, 445 // { EGL_TRANSPARENT_RED_VALUE, ChooseConfigRandomCase::getInt<0, 255>, }, 446 // { EGL_TRANSPARENT_GREEN_VALUE, ChooseConfigRandomCase::getInt<0, 255>, }, 447 // { EGL_TRANSPARENT_BLUE_VALUE, ChooseConfigRandomCase::getInt<0, 255>, } 448 }; 449 450 std::vector<std::pair<EGLenum, EGLint> > out; 451 452 // Build list to select from 453 std::vector<AttribSpec> candidates; 454 for (int ndx = 0; ndx < (int)DE_LENGTH_OF_ARRAY(attributes); ndx++) 455 { 456 if (attribSet.find(attributes[ndx].attribute) != attribSet.end()) 457 candidates.push_back(attributes[ndx]); 458 } 459 460 for (int attribNdx = 0; attribNdx < numAttribs; attribNdx++) 461 { 462 AttribSpec spec = rnd.choose<AttribSpec>(candidates.begin(), candidates.end()); 463 out.push_back(std::make_pair(spec.attribute, spec.getValue(rnd))); 464 } 465 466 return out; 467 } 468 private: 469 std::set<EGLenum> m_attribSet; 470 int m_numIters; 471 int m_iterNdx; 472 }; 473 474 class ColorComponentTypeCase : public ChooseConfigCase 475 { 476 477 public: 478 ColorComponentTypeCase (EglTestContext& eglTestCtx, const char* name, EGLenum value) 479 : ChooseConfigCase (eglTestCtx, name, "", true /* sorting order is validated */) 480 , m_value (value) 481 { 482 } 483 484 TestCase::IterateResult iterate (void) 485 { 486 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 487 488 { 489 const std::vector<std::string> extensions = eglu::getDisplayExtensions(m_eglTestCtx.getLibrary(), m_display); 490 491 if (!de::contains(extensions.begin(), extensions.end(), "EGL_EXT_pixel_format_float")) 492 TCU_THROW(NotSupportedError, "EGL_EXT_pixel_format_float is not supported"); 493 } 494 495 { 496 std::vector<std::pair<EGLenum, EGLint> > attributes; 497 498 attributes.push_back(std::pair<EGLenum, EGLint>(EGL_COLOR_COMPONENT_TYPE_EXT, m_value)); 499 fillDontCare(attributes); 500 501 executeTest(attributes, m_checkOrder); 502 } 503 504 return STOP; 505 } 506 private: 507 const EGLenum m_value; 508 }; 509 510 ChooseConfigTests::ChooseConfigTests (EglTestContext& eglTestCtx) 511 : TestCaseGroup(eglTestCtx, "choose_config", "eglChooseConfig() tests") 512 { 513 } 514 515 ChooseConfigTests::~ChooseConfigTests (void) 516 { 517 } 518 519 namespace 520 { 521 522 template <typename T, size_t N> 523 std::set<T> toSet (const T (&arr)[N]) 524 { 525 std::set<T> set; 526 for (size_t i = 0; i < N; i++) 527 set.insert(arr[i]); 528 return set; 529 } 530 531 } // anonymous 532 533 void ChooseConfigTests::init (void) 534 { 535 // Single attributes 536 { 537 static const struct 538 { 539 EGLenum attribute; 540 const char* testName; 541 } attributes[] = 542 { 543 { EGL_BUFFER_SIZE, "buffer_size" }, 544 { EGL_RED_SIZE, "red_size" }, 545 { EGL_GREEN_SIZE, "green_size" }, 546 { EGL_BLUE_SIZE, "blue_size" }, 547 { EGL_LUMINANCE_SIZE, "luminance_size" }, 548 { EGL_ALPHA_SIZE, "alpha_size" }, 549 { EGL_ALPHA_MASK_SIZE, "alpha_mask_size" }, 550 { EGL_BIND_TO_TEXTURE_RGB, "bind_to_texture_rgb" }, 551 { EGL_BIND_TO_TEXTURE_RGBA, "bind_to_texture_rgba" }, 552 { EGL_COLOR_BUFFER_TYPE, "color_buffer_type" }, 553 { EGL_CONFIG_CAVEAT, "config_caveat" }, 554 { EGL_CONFIG_ID, "config_id" }, 555 { EGL_CONFORMANT, "conformant" }, 556 { EGL_DEPTH_SIZE, "depth_size" }, 557 { EGL_LEVEL, "level" }, 558 { EGL_MAX_SWAP_INTERVAL, "max_swap_interval" }, 559 { EGL_MIN_SWAP_INTERVAL, "min_swap_interval" }, 560 { EGL_NATIVE_RENDERABLE, "native_renderable" }, 561 { EGL_NATIVE_VISUAL_TYPE, "native_visual_type" }, 562 { EGL_RENDERABLE_TYPE, "renderable_type" }, 563 { EGL_SAMPLE_BUFFERS, "sample_buffers" }, 564 { EGL_SAMPLES, "samples" }, 565 { EGL_STENCIL_SIZE, "stencil_size" }, 566 { EGL_SURFACE_TYPE, "surface_type" }, 567 { EGL_TRANSPARENT_TYPE, "transparent_type" }, 568 { EGL_TRANSPARENT_RED_VALUE, "transparent_red_value" }, 569 { EGL_TRANSPARENT_GREEN_VALUE, "transparent_green_value" }, 570 { EGL_TRANSPARENT_BLUE_VALUE, "transparent_blue_value" } 571 }; 572 573 tcu::TestCaseGroup* simpleGroup = new tcu::TestCaseGroup(m_testCtx, "simple", "Simple tests"); 574 addChild(simpleGroup); 575 576 tcu::TestCaseGroup* selectionGroup = new tcu::TestCaseGroup(m_testCtx, "selection_only", "Selection tests, order ignored"); 577 simpleGroup->addChild(selectionGroup); 578 579 tcu::TestCaseGroup* sortGroup = new tcu::TestCaseGroup(m_testCtx, "selection_and_sort", "Selection and ordering tests"); 580 simpleGroup->addChild(sortGroup); 581 582 for (int ndx = 0; ndx < (int)DE_LENGTH_OF_ARRAY(attributes); ndx++) 583 { 584 selectionGroup->addChild(new ChooseConfigSimpleCase(m_eglTestCtx, attributes[ndx].testName, "Simple config selection case", attributes[ndx].attribute, false)); 585 sortGroup->addChild(new ChooseConfigSimpleCase(m_eglTestCtx, attributes[ndx].testName, "Simple config selection and sort case", attributes[ndx].attribute, true)); 586 } 587 } 588 589 // Random 590 { 591 tcu::TestCaseGroup* randomGroup = new tcu::TestCaseGroup(m_testCtx, "random", "Random eglChooseConfig() usage"); 592 addChild(randomGroup); 593 594 static const EGLenum rgbaSizes[] = 595 { 596 EGL_RED_SIZE, 597 EGL_GREEN_SIZE, 598 EGL_BLUE_SIZE, 599 EGL_ALPHA_SIZE 600 }; 601 randomGroup->addChild(new ChooseConfigRandomCase(m_eglTestCtx, "color_sizes", "Random color size rules", toSet(rgbaSizes))); 602 603 static const EGLenum colorDepthStencilSizes[] = 604 { 605 EGL_RED_SIZE, 606 EGL_GREEN_SIZE, 607 EGL_BLUE_SIZE, 608 EGL_ALPHA_SIZE, 609 EGL_DEPTH_SIZE, 610 EGL_STENCIL_SIZE 611 }; 612 randomGroup->addChild(new ChooseConfigRandomCase(m_eglTestCtx, "color_depth_stencil_sizes", "Random color, depth and stencil size rules", toSet(colorDepthStencilSizes))); 613 614 static const EGLenum bufferSizes[] = 615 { 616 EGL_BUFFER_SIZE, 617 EGL_LUMINANCE_SIZE, 618 EGL_ALPHA_MASK_SIZE, 619 EGL_DEPTH_SIZE, 620 EGL_STENCIL_SIZE 621 }; 622 randomGroup->addChild(new ChooseConfigRandomCase(m_eglTestCtx, "buffer_sizes", "Various buffer size rules", toSet(bufferSizes))); 623 624 static const EGLenum surfaceType[] = 625 { 626 EGL_NATIVE_RENDERABLE, 627 EGL_SURFACE_TYPE 628 }; 629 randomGroup->addChild(new ChooseConfigRandomCase(m_eglTestCtx, "surface_type", "Surface type rules", toSet(surfaceType))); 630 631 static const EGLenum sampleBuffers[] = 632 { 633 EGL_SAMPLE_BUFFERS, 634 EGL_SAMPLES 635 }; 636 randomGroup->addChild(new ChooseConfigRandomCase(m_eglTestCtx, "sample_buffers", "Sample buffer rules", toSet(sampleBuffers))); 637 638 // \note Not every attribute is supported at the moment 639 static const EGLenum allAttribs[] = 640 { 641 EGL_BUFFER_SIZE, 642 EGL_RED_SIZE, 643 EGL_GREEN_SIZE, 644 EGL_BLUE_SIZE, 645 EGL_ALPHA_SIZE, 646 EGL_ALPHA_MASK_SIZE, 647 EGL_BIND_TO_TEXTURE_RGB, 648 EGL_BIND_TO_TEXTURE_RGBA, 649 EGL_COLOR_BUFFER_TYPE, 650 EGL_CONFIG_CAVEAT, 651 EGL_CONFIG_ID, 652 EGL_CONFORMANT, 653 EGL_DEPTH_SIZE, 654 EGL_LEVEL, 655 // EGL_MATCH_NATIVE_PIXMAP, 656 EGL_MAX_SWAP_INTERVAL, 657 EGL_MIN_SWAP_INTERVAL, 658 EGL_NATIVE_RENDERABLE, 659 EGL_NATIVE_VISUAL_TYPE, 660 EGL_RENDERABLE_TYPE, 661 EGL_SAMPLE_BUFFERS, 662 EGL_SAMPLES, 663 EGL_STENCIL_SIZE, 664 EGL_SURFACE_TYPE, 665 EGL_TRANSPARENT_TYPE, 666 // EGL_TRANSPARENT_RED_VALUE, 667 // EGL_TRANSPARENT_GREEN_VALUE, 668 // EGL_TRANSPARENT_BLUE_VALUE 669 }; 670 randomGroup->addChild(new ChooseConfigRandomCase(m_eglTestCtx, "all", "All attributes", toSet(allAttribs))); 671 } 672 673 // EGL_EXT_pixel_format_float 674 { 675 de::MovePtr<tcu::TestCaseGroup> colorComponentTypeGroup (new tcu::TestCaseGroup(m_testCtx, "color_component_type_ext", "EGL_EXT_pixel_format_float tests")); 676 677 colorComponentTypeGroup->addChild(new ColorComponentTypeCase(m_eglTestCtx, "dont_care", EGL_DONT_CARE)); 678 colorComponentTypeGroup->addChild(new ColorComponentTypeCase(m_eglTestCtx, "fixed", EGL_COLOR_COMPONENT_TYPE_FIXED_EXT)); 679 colorComponentTypeGroup->addChild(new ColorComponentTypeCase(m_eglTestCtx, "float", EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT)); 680 681 addChild(colorComponentTypeGroup.release()); 682 } 683 } 684 685 } // egl 686 } // deqp 687
