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 EGL image tests.
22 *//*--------------------------------------------------------------------*/
23
24#include "teglImageTests.hpp"
25
26#include "teglImageUtil.hpp"
27#include "teglAndroidUtil.hpp"
28#include "teglImageFormatTests.hpp"
29
30#include "egluNativeDisplay.hpp"
31#include "egluNativeWindow.hpp"
32#include "egluNativePixmap.hpp"
33#include "egluStrUtil.hpp"
34#include "egluUnique.hpp"
35#include "egluUtil.hpp"
36#include "egluGLUtil.hpp"
37
38#include "eglwLibrary.hpp"
39#include "eglwEnums.hpp"
40
41#include "gluDefs.hpp"
42#include "gluCallLogWrapper.hpp"
43#include "gluObjectWrapper.hpp"
44#include "gluStrUtil.hpp"
45
46#include "glwDefs.hpp"
47#include "glwEnums.hpp"
48
49#include "tcuTestLog.hpp"
50#include "tcuCommandLine.hpp"
51
52#include "deUniquePtr.hpp"
53
54#include <algorithm>
55#include <sstream>
56#include <string>
57#include <vector>
58#include <set>
59
60using tcu::TestLog;
61
62using std::string;
63using std::vector;
64using std::set;
65using std::ostringstream;
66
67using de::MovePtr;
68using de::UniquePtr;
69using glu::ApiType;
70using glu::ContextType;
71using glu::Texture;
72using eglu::AttribMap;
73using eglu::NativeWindow;
74using eglu::NativePixmap;
75using eglu::UniqueImage;
76using eglu::UniqueSurface;
77using eglu::ScopedCurrentContext;
78
79using namespace glw;
80using namespace eglw;
81
82namespace deqp
83{
84namespace egl
85{
86
87namespace Image
88{
89
90#define CHECK_EXTENSION(DPY, EXTNAME) \
91	TCU_CHECK_AND_THROW(NotSupportedError, eglu::hasExtension(m_eglTestCtx.getLibrary(), DPY, EXTNAME), (string("Unsupported extension: ") + EXTNAME).c_str())
92
93template <typename RetVal>
94RetVal checkCallError (EglTestContext& eglTestCtx, const char* call, RetVal returnValue, EGLint expectError)
95{
96	tcu::TestContext&	testCtx		= eglTestCtx.getTestContext();
97	TestLog&			log			= testCtx.getLog();
98	EGLint				error;
99
100	log << TestLog::Message << call << TestLog::EndMessage;
101
102	error = eglTestCtx.getLibrary().getError();
103
104	if (error != expectError)
105	{
106		log << TestLog::Message << "  Fail: Error code mismatch! Expected " << eglu::getErrorStr(expectError) << ", got " << eglu::getErrorStr(error) << TestLog::EndMessage;
107		log << TestLog::Message << "  " << returnValue << " was returned" << TestLog::EndMessage;
108
109		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
110			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid error code");
111	}
112
113	return returnValue;
114}
115
116template <typename RetVal>
117void checkCallReturn (EglTestContext& eglTestCtx, const char* call, RetVal returnValue, RetVal expectReturnValue, EGLint expectError)
118{
119	tcu::TestContext&	testCtx		= eglTestCtx.getTestContext();
120	TestLog&			log			= testCtx.getLog();
121	EGLint				error;
122
123	log << TestLog::Message << call << TestLog::EndMessage;
124
125	error = eglTestCtx.getLibrary().getError();
126
127	if (returnValue != expectReturnValue)
128	{
129		log << TestLog::Message << "  Fail: Return value mismatch! Expected " << expectReturnValue << ", got " << returnValue << TestLog::EndMessage;
130
131		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
132			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid return value");
133	}
134
135	if (error != expectError)
136	{
137		log << TestLog::Message << "  Fail: Error code mismatch! Expected " << eglu::getErrorStr(expectError) << ", got " << eglu::getErrorStr(error) << TestLog::EndMessage;
138
139		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
140			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid error code");
141	}
142}
143
144// \note These macros expect "EglTestContext m_eglTestCtx" to be defined.
145#define CHECK_EXT_CALL_RET(CALL, EXPECT_RETURN_VALUE, EXPECT_ERROR)	checkCallReturn(m_eglTestCtx, #CALL, CALL, (EXPECT_RETURN_VALUE), (EXPECT_ERROR))
146#define CHECK_EXT_CALL_ERR(CALL, EXPECT_ERROR)						checkCallError(m_eglTestCtx, #CALL, CALL, (EXPECT_ERROR))
147
148class ImageTestCase : public TestCase, public glu::CallLogWrapper
149{
150public:
151				ImageTestCase		(EglTestContext& eglTestCtx, ApiType api, const string& name, const string& desc)
152					: TestCase				(eglTestCtx, name.c_str(), desc.c_str())
153					, glu::CallLogWrapper	(m_gl, m_testCtx.getLog())
154					, m_api					(api)
155					, m_display				(EGL_NO_DISPLAY)
156	{
157	}
158
159	void		init				(void)
160	{
161		DE_ASSERT(m_display == EGL_NO_DISPLAY);
162		m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
163
164		const char* extensions[] = { "GL_OES_EGL_image" };
165		m_eglTestCtx.initGLFunctions(&m_gl, m_api, DE_LENGTH_OF_ARRAY(extensions), &extensions[0]);
166	}
167
168	void		deinit				(void)
169	{
170		m_eglTestCtx.getLibrary().terminate(m_display);
171		m_display = EGL_NO_DISPLAY;
172	}
173
174	bool		isGLRedSupported	(void)
175	{
176		return m_api.getMajorVersion() >= 3 || glu::hasExtension(m_gl, m_api, "GL_EXT_texture_rg");
177	}
178
179protected:
180	glw::Functions	m_gl;
181	ApiType			m_api;
182	EGLDisplay		m_display;
183};
184
185class InvalidCreateImage : public ImageTestCase
186{
187public:
188	InvalidCreateImage (EglTestContext& eglTestCtx)
189		: ImageTestCase(eglTestCtx, ApiType::es(2, 0), "invalid_create_image", "eglCreateImageKHR() with invalid arguments")
190	{
191	}
192
193	void checkCreate (const char* desc, EGLDisplay dpy, const char* dpyStr, EGLContext context, const char* ctxStr, EGLenum source, const char* srcStr, EGLint expectError);
194
195	IterateResult iterate (void)
196	{
197#define CHECK_CREATE(MSG, DPY, CONTEXT, SOURCE, ERR) checkCreate(MSG, DPY, #DPY, CONTEXT, #CONTEXT, SOURCE, #SOURCE, ERR)
198		CHECK_CREATE("Testing bad display (-1)...", (EGLDisplay)-1, EGL_NO_CONTEXT, EGL_NONE, EGL_BAD_DISPLAY);
199		CHECK_CREATE("Testing bad context (-1)...", m_display, (EGLContext)-1, EGL_NONE, EGL_BAD_CONTEXT);
200		CHECK_CREATE("Testing bad source (-1)...", m_display, EGL_NO_CONTEXT, (EGLenum)-1, EGL_BAD_PARAMETER);
201#undef CHECK_CREATE
202
203		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
204		return STOP;
205	}
206
207};
208
209void InvalidCreateImage::checkCreate (const char* msg, EGLDisplay dpy, const char* dpyStr, EGLContext context, const char* ctxStr, EGLenum source, const char* srcStr, EGLint expectError)
210{
211	m_testCtx.getLog() << TestLog::Message << msg << TestLog::EndMessage;
212	{
213		const Library&		egl		= m_eglTestCtx.getLibrary();
214		const EGLImageKHR	image	= egl.createImageKHR(dpy, context, source, 0, DE_NULL);
215		ostringstream		call;
216
217		call << "eglCreateImage(" << dpyStr << ", " << ctxStr << ", " << srcStr << ", 0, DE_NULL)";
218		checkCallReturn(m_eglTestCtx, call.str().c_str(), image, EGL_NO_IMAGE_KHR, expectError);
219	}
220}
221
222EGLConfig chooseConfig (const Library& egl, EGLDisplay display, ApiType apiType)
223{
224	AttribMap				attribs;
225	vector<EGLConfig>		configs;
226	// Prefer configs in order: pbuffer, window, pixmap
227	static const EGLenum	s_surfaceTypes[] = { EGL_PBUFFER_BIT, EGL_WINDOW_BIT, EGL_PIXMAP_BIT };
228
229	attribs[EGL_RENDERABLE_TYPE] = eglu::apiRenderableType(apiType);
230
231	for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_surfaceTypes); ++ndx)
232	{
233		attribs[EGL_SURFACE_TYPE] = s_surfaceTypes[ndx];
234		configs = eglu::chooseConfigs(egl, display, attribs);
235
236		if (!configs.empty())
237			return configs.front();
238	}
239
240	TCU_THROW(NotSupportedError, "No compatible EGL configs found");
241	return (EGLConfig)0;
242}
243
244class Context
245{
246public:
247								Context			(EglTestContext& eglTestCtx, EGLDisplay display, ContextType ctxType, int width, int height)
248									: m_eglTestCtx	(eglTestCtx)
249									, m_display		(display)
250									, m_config		(chooseConfig(eglTestCtx.getLibrary(), display, ctxType.getAPI()))
251									, m_context		(m_eglTestCtx.getLibrary(), m_display, eglu::createGLContext(eglTestCtx.getLibrary(), m_display, m_config, ctxType))
252									, m_surface		(createSurface(eglTestCtx, m_display, m_config, width, height))
253									, m_current		(eglTestCtx.getLibrary(), m_display, m_surface->get(), m_surface->get(), *m_context)
254	{
255		m_eglTestCtx.initGLFunctions(&m_gl, ctxType.getAPI());
256	}
257
258	EGLConfig					getConfig		(void) const { return m_config; }
259	EGLDisplay 					getEglDisplay	(void) const { return m_display; }
260	EGLContext 					getEglContext	(void) const { return *m_context; }
261	const glw::Functions&		gl				(void) const { return m_gl; }
262
263private:
264	EglTestContext&				m_eglTestCtx;
265	EGLDisplay					m_display;
266	EGLConfig					m_config;
267	eglu::UniqueContext			m_context;
268	UniquePtr<ManagedSurface>	m_surface;
269	ScopedCurrentContext		m_current;
270	glw::Functions				m_gl;
271
272								Context			(const Context&);
273	Context&					operator=		(const Context&);
274};
275
276class CreateImageGLES2 : public ImageTestCase
277{
278public:
279	static const char* getTargetName (EGLint target)
280	{
281		switch (target)
282		{
283			case EGL_GL_TEXTURE_2D_KHR:						return "tex2d";
284			case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR:	return "cubemap_pos_x";
285			case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR:	return "cubemap_neg_x";
286			case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR:	return "cubemap_pos_y";
287			case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR:	return "cubemap_neg_y";
288			case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR:	return "cubemap_pos_z";
289			case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR:	return "cubemap_neg_z";
290			case EGL_GL_RENDERBUFFER_KHR:					return "renderbuffer";
291			case EGL_NATIVE_BUFFER_ANDROID:					return "android_native";
292			default:		DE_ASSERT(DE_FALSE);			return "";
293		}
294	}
295
296	static const char* getStorageName (GLenum storage)
297	{
298		switch (storage)
299		{
300			case GL_RED:				return "red";
301			case GL_RG:					return "rg";
302			case GL_LUMINANCE:			return "luminance";
303			case GL_LUMINANCE_ALPHA:	return "luminance_alpha";
304			case GL_RGB:				return "rgb";
305			case GL_RGBA:				return "rgba";
306			case GL_DEPTH_COMPONENT16:	return "depth_component_16";
307			case GL_RGBA4:				return "rgba4";
308			case GL_RGB5_A1:			return "rgb5_a1";
309			case GL_RGB565:				return "rgb565";
310			case GL_RGB8:				return "rgb8";
311			case GL_RGBA8:				return "rgba8";
312			case GL_STENCIL_INDEX8:		return "stencil_index8";
313			default:
314				DE_ASSERT(DE_FALSE);
315				return "";
316		}
317	}
318
319	MovePtr<ImageSource> getImageSource (EGLint target, GLenum internalFormat, GLenum format, GLenum type, bool useTexLevel0)
320	{
321		switch (target)
322		{
323			case EGL_GL_TEXTURE_2D_KHR:
324			case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR:
325			case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR:
326			case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR:
327			case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR:
328			case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR:
329			case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR:
330				DE_ASSERT(format != 0u && type != 0u);
331				return createTextureImageSource(target, internalFormat, format, type, useTexLevel0);
332
333			case EGL_GL_RENDERBUFFER_KHR:
334				DE_ASSERT(format == 0u && type == 0u);
335				return createRenderbufferImageSource(internalFormat);
336
337			case EGL_NATIVE_BUFFER_ANDROID:
338				DE_ASSERT(format == 0u && type == 0u);
339				return createAndroidNativeImageSource(internalFormat);
340
341			default:
342				DE_FATAL("Impossible");
343				return MovePtr<ImageSource>();
344		}
345	}
346
347	CreateImageGLES2 (EglTestContext& eglTestCtx, EGLint target, GLenum internalFormat, GLenum format, GLenum type, bool useTexLevel0 = false)
348		: ImageTestCase		(eglTestCtx, ApiType::es(2, 0), string("create_image_gles2_") + getTargetName(target) + "_" + getStorageName(internalFormat) + (useTexLevel0 ? "_level0_only" : ""), "Create EGLImage from GLES2 object")
349		, m_source			(getImageSource(target, internalFormat, format, type, useTexLevel0))
350		, m_internalFormat	(internalFormat)
351	{
352	}
353
354	IterateResult iterate (void)
355	{
356		const Library&			egl				= m_eglTestCtx.getLibrary();
357		const EGLDisplay		dpy				= m_display;
358
359		if (eglu::getVersion(egl, dpy) < eglu::Version(1, 5))
360			CHECK_EXTENSION(dpy, m_source->getRequiredExtension());
361
362		// Initialize result.
363		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
364
365		// Create GLES2 context
366		TestLog&				log				= m_testCtx.getLog();
367		const ContextType		contextType		(ApiType::es(2, 0));
368		Context					context			(m_eglTestCtx, dpy, contextType, 64, 64);
369		const EGLContext		eglContext		= context.getEglContext();
370
371		if ((m_internalFormat == GL_RED || m_internalFormat == GL_RG) && !isGLRedSupported())
372			TCU_THROW(NotSupportedError, "Unsupported extension: GL_EXT_texture_rg");
373
374		log << TestLog::Message << "Using EGL config " << eglu::getConfigID(egl, dpy, context.getConfig()) << TestLog::EndMessage;
375
376		UniquePtr<ClientBuffer>	clientBuffer	(m_source->createBuffer(context.gl()));
377		const EGLImageKHR		image			= m_source->createImage(egl, dpy, eglContext, clientBuffer->get());
378
379		if (image == EGL_NO_IMAGE_KHR)
380		{
381			log << TestLog::Message << "  Fail: Got EGL_NO_IMAGE_KHR!" << TestLog::EndMessage;
382
383			if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
384				m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got EGL_NO_IMAGE_KHR");
385		}
386
387		// Destroy image
388		CHECK_EXT_CALL_RET(egl.destroyImageKHR(context.getEglDisplay(), image), (EGLBoolean)EGL_TRUE, EGL_SUCCESS);
389
390		return STOP;
391	}
392
393private:
394	const UniquePtr<ImageSource>	m_source;
395	const GLenum					m_internalFormat;
396};
397
398class ImageTargetGLES2 : public ImageTestCase
399{
400public:
401	static const char* getTargetName (GLenum target)
402	{
403		switch (target)
404		{
405			case GL_TEXTURE_2D:		return "tex2d";
406			case GL_RENDERBUFFER:	return "renderbuffer";
407			default:
408				DE_ASSERT(DE_FALSE);
409				return "";
410		}
411	}
412
413	ImageTargetGLES2 (EglTestContext& eglTestCtx, GLenum target)
414		: ImageTestCase	(eglTestCtx, ApiType::es(2, 0), string("image_target_gles2_") + getTargetName(target), "Use EGLImage as GLES2 object")
415		, m_target		(target)
416	{
417	}
418
419	IterateResult iterate (void)
420	{
421		const Library&	egl	= m_eglTestCtx.getLibrary();
422		TestLog&		log	= m_testCtx.getLog();
423
424		// \todo [2011-07-21 pyry] Try all possible EGLImage sources
425		CHECK_EXTENSION(m_display, "EGL_KHR_gl_texture_2D_image");
426
427		// Initialize result.
428		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
429
430		// Create GLES2 context
431
432		Context context(m_eglTestCtx, m_display, ContextType(ApiType::es(2, 0)), 64, 64);
433		log << TestLog::Message << "Using EGL config " << eglu::getConfigID(m_eglTestCtx.getLibrary(), context.getEglDisplay(), context.getConfig()) << TestLog::EndMessage;
434
435		// Check for OES_EGL_image
436		{
437			const char* glExt = (const char*)glGetString(GL_EXTENSIONS);
438
439			if (string(glExt).find("GL_OES_EGL_image") == string::npos)
440				throw tcu::NotSupportedError("Extension not supported", "GL_OES_EGL_image", __FILE__, __LINE__);
441
442			TCU_CHECK(m_gl.eglImageTargetTexture2DOES);
443			TCU_CHECK(m_gl.eglImageTargetRenderbufferStorageOES);
444		}
445
446		// Create GL_TEXTURE_2D and EGLImage from it.
447		log << TestLog::Message << "Creating EGLImage using GL_TEXTURE_2D with GL_RGBA storage" << TestLog::EndMessage;
448
449		deUint32 srcTex = 1;
450		GLU_CHECK_CALL(glBindTexture(GL_TEXTURE_2D, srcTex));
451		GLU_CHECK_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL));
452		GLU_CHECK_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
453
454		// Create EGL image
455		EGLint		attribs[]	= { EGL_GL_TEXTURE_LEVEL_KHR, 0, EGL_NONE };
456		EGLImageKHR	image		= CHECK_EXT_CALL_ERR(egl.createImageKHR(context.getEglDisplay(), context.getEglContext(), EGL_GL_TEXTURE_2D_KHR, (EGLClientBuffer)(deUintptr)srcTex, attribs), EGL_SUCCESS);
457		if (image == EGL_NO_IMAGE_KHR)
458		{
459			log << TestLog::Message << "  Fail: Got EGL_NO_IMAGE_KHR!" << TestLog::EndMessage;
460
461			if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
462				m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got EGL_NO_IMAGE_KHR");
463		}
464
465		// Create texture or renderbuffer
466		if (m_target == GL_TEXTURE_2D)
467		{
468			log << TestLog::Message << "Creating GL_TEXTURE_2D from EGLimage" << TestLog::EndMessage;
469
470			deUint32 dstTex = 2;
471			GLU_CHECK_CALL(glBindTexture(GL_TEXTURE_2D, dstTex));
472			GLU_CHECK_CALL(glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image));
473			GLU_CHECK_CALL(glDeleteTextures(1, &dstTex));
474		}
475		else
476		{
477			DE_ASSERT(m_target == GL_RENDERBUFFER);
478
479			log << TestLog::Message << "Creating GL_RENDERBUFFER from EGLimage" << TestLog::EndMessage;
480
481			deUint32 dstRbo = 2;
482			GLU_CHECK_CALL(glBindRenderbuffer(GL_RENDERBUFFER, dstRbo));
483			GLU_CHECK_CALL(glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER, (GLeglImageOES)image));
484			GLU_CHECK_CALL(glDeleteRenderbuffers(1, &dstRbo));
485		}
486
487		// Destroy image
488		CHECK_EXT_CALL_RET(egl.destroyImageKHR(context.getEglDisplay(), image), (EGLBoolean)EGL_TRUE, EGL_SUCCESS);
489
490		// Destroy source texture object
491		GLU_CHECK_CALL(glDeleteTextures(1, &srcTex));
492
493		return STOP;
494	}
495
496private:
497	GLenum	m_target;
498};
499
500class ApiTests : public TestCaseGroup
501{
502public:
503	ApiTests (EglTestContext& eglTestCtx, const string& name, const string& desc) : TestCaseGroup(eglTestCtx, name.c_str(), desc.c_str()) {}
504
505	void init (void)
506	{
507		addChild(new Image::InvalidCreateImage(m_eglTestCtx));
508
509		addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_RED, GL_RED, GL_UNSIGNED_BYTE, false));
510		addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_RG, GL_RG, GL_UNSIGNED_BYTE, false));
511
512		addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE));
513		addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE));
514
515		addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE));
516		addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
517		addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, true));
518
519		addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE));
520		addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
521		addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, true));
522
523		addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
524		addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
525		addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
526		addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
527		addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
528
529		static const GLenum rboStorages[] =
530		{
531			GL_DEPTH_COMPONENT16,
532			GL_RGBA4,
533			GL_RGB5_A1,
534			GL_RGB565,
535			GL_STENCIL_INDEX8
536		};
537		for (int storageNdx = 0; storageNdx < DE_LENGTH_OF_ARRAY(rboStorages); storageNdx++)
538			addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_RENDERBUFFER_KHR, rboStorages[storageNdx], (GLenum)0, (GLenum)0));
539
540		static const GLenum androidFormats[] =
541		{
542			GL_RGB565,
543			GL_RGB8,
544			GL_RGBA4,
545			GL_RGB5_A1,
546			GL_RGBA8,
547		};
548
549		for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(androidFormats); ++formatNdx)
550			addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_NATIVE_BUFFER_ANDROID, androidFormats[formatNdx], (GLenum)0, (GLenum)0));
551
552		addChild(new Image::ImageTargetGLES2(m_eglTestCtx, GL_TEXTURE_2D));
553		addChild(new Image::ImageTargetGLES2(m_eglTestCtx, GL_RENDERBUFFER));
554	}
555};
556
557} // Image
558
559ImageTests::ImageTests (EglTestContext& eglTestCtx)
560	: TestCaseGroup(eglTestCtx, "image", "EGLImage Tests")
561{
562}
563
564ImageTests::~ImageTests (void)
565{
566}
567
568void ImageTests::init (void)
569{
570	addChild(new Image::ApiTests(m_eglTestCtx, "api", "EGLImage API tests"));
571	addChild(Image::createSimpleCreationTests(m_eglTestCtx, "create", "EGLImage creation tests"));
572	addChild(Image::createModifyTests(m_eglTestCtx, "modify", "EGLImage modifying tests"));
573	addChild(Image::createMultiContextRenderTests(m_eglTestCtx, "render_multiple_contexts", "EGLImage render tests on multiple contexts"));
574}
575
576} // egl
577} // deqp
578