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