• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
logConfigAttribute(TestLog & log,EGLenum attrib,EGLint value)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 
isAttributePresent(const eglu::Version & version,EGLenum attribute)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:
GetConfigsBoundsCase(EglTestContext & eglTestCtx,const char * name,const char * description)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 
init(void)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 
deinit(void)97 	void deinit (void)
98 	{
99 		m_eglTestCtx.getLibrary().terminate(m_display);
100 		m_display = EGL_NO_DISPLAY;
101 	}
102 
checkGetConfigsBounds(de::Random & rnd,const int numConfigAll,const int numConfigRequested)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 
iterate(void)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 
GetConfigAttribCase(EglTestContext & eglTestCtx,const char * name,const char * description)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 
init(void)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 
deinit(void)232 void GetConfigAttribCase::deinit (void)
233 {
234 	m_eglTestCtx.getLibrary().terminate(m_display);
235 	m_display = EGL_NO_DISPLAY;
236 }
237 
iterate(void)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 
getValue(EGLConfig config,EGLenum attrib,bool logValue)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:
GetConfigAttribSimpleCase(EglTestContext & eglTestCtx,const char * name,const char * description,EGLenum attribute)286 	GetConfigAttribSimpleCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLenum attribute)
287 		: GetConfigAttribCase(eglTestCtx, name, description)
288 		, m_attrib(attribute)
289 	{
290 	}
291 
checkColorBufferType(EGLint value)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 
checkCaveat(EGLint value)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 
checkTransparentType(EGLint value)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 
checkBoolean(EGLenum attrib,EGLint value)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 
checkInteger(EGLenum attrib,EGLint value)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 
checkSurfaceTypeMask(EGLint value)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 
checkAttribute(EGLenum attrib,EGLint value)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 
executeTest(EGLConfig config)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:
GetConfigAttribBufferSizeCase(EglTestContext & eglTestCtx,const char * name,const char * description)430 	GetConfigAttribBufferSizeCase (EglTestContext& eglTestCtx, const char* name, const char* description)
431 		: GetConfigAttribCase(eglTestCtx, name, description)
432 	{
433 	}
434 
executeTest(EGLConfig config)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:
GetConfigAttribTransparentValueCase(EglTestContext & eglTestCtx,const char * name,const char * description)500 	GetConfigAttribTransparentValueCase (EglTestContext& eglTestCtx, const char* name, const char* description)
501 		: GetConfigAttribCase(eglTestCtx, name, description)
502 	{
503 	}
504 
executeTest(EGLConfig config)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 
QueryConfigTests(EglTestContext & eglTestCtx)531 QueryConfigTests::QueryConfigTests (EglTestContext& eglTestCtx)
532 	: TestCaseGroup(eglTestCtx, "query_config", "Surface config query tests")
533 {
534 }
535 
~QueryConfigTests(void)536 QueryConfigTests::~QueryConfigTests (void)
537 {
538 }
539 
init(void)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
609