1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program EGL Module
3 * ---------------------------------------
5 * Copyright 2014 The Android Open Source Project
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 * \brief EGL image tests.
22 *//*--------------------------------------------------------------------*/
24 #include "teglImageTests.hpp"
26 #include "teglImageUtil.hpp"
27 #include "teglAndroidUtil.hpp"
28 #include "teglImageFormatTests.hpp"
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"
38 #include "eglwLibrary.hpp"
39 #include "eglwEnums.hpp"
41 #include "gluDefs.hpp"
42 #include "gluCallLogWrapper.hpp"
43 #include "gluObjectWrapper.hpp"
44 #include "gluStrUtil.hpp"
46 #include "glwDefs.hpp"
47 #include "glwEnums.hpp"
49 #include "tcuTestLog.hpp"
50 #include "tcuCommandLine.hpp"
52 #include "deUniquePtr.hpp"
65 using std::ostringstream;
70 using glu::ContextType;
72 using eglu::AttribMap;
73 using eglu::NativeWindow;
74 using eglu::NativePixmap;
75 using eglu::UniqueImage;
76 using eglu::UniqueSurface;
77 using eglu::ScopedCurrentContext;
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())
93 template <typename RetVal>
94 RetVal checkCallError (EglTestContext& eglTestCtx, const char* call, RetVal returnValue, EGLint expectError)
96 tcu::TestContext& testCtx = eglTestCtx.getTestContext();
97 TestLog& log = testCtx.getLog();
100 log << TestLog::Message << call << TestLog::EndMessage;
102 error = eglTestCtx.getLibrary().getError();
104 if (error != expectError)
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;
109 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
110 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid error code");
116 template <typename RetVal>
117 void checkCallReturn (EglTestContext& eglTestCtx, const char* call, RetVal returnValue, RetVal expectReturnValue, EGLint expectError)
119 tcu::TestContext& testCtx = eglTestCtx.getTestContext();
120 TestLog& log = testCtx.getLog();
123 log << TestLog::Message << call << TestLog::EndMessage;
125 error = eglTestCtx.getLibrary().getError();
127 if (returnValue != expectReturnValue)
129 log << TestLog::Message << " Fail: Return value mismatch! Expected " << expectReturnValue << ", got " << returnValue << TestLog::EndMessage;
131 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
132 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid return value");
135 if (error != expectError)
137 log << TestLog::Message << " Fail: Error code mismatch! Expected " << eglu::getErrorStr(expectError) << ", got " << eglu::getErrorStr(error) << TestLog::EndMessage;
139 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
140 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid error code");
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))
148 class ImageTestCase : public TestCase, public glu::CallLogWrapper
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())
155 , m_display (EGL_NO_DISPLAY)
161 DE_ASSERT(m_display == EGL_NO_DISPLAY);
162 m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
164 const char* extensions[] = { "GL_OES_EGL_image" };
165 m_eglTestCtx.initGLFunctions(&m_gl, m_api, DE_LENGTH_OF_ARRAY(extensions), &extensions[0]);
170 m_eglTestCtx.getLibrary().terminate(m_display);
171 m_display = EGL_NO_DISPLAY;
174 bool isGLRedSupported (void)
176 return m_api.getMajorVersion() >= 3 || glu::hasExtension(m_gl, m_api, "GL_EXT_texture_rg");
182 EGLDisplay m_display;
185 class InvalidCreateImage : public ImageTestCase
188 InvalidCreateImage (EglTestContext& eglTestCtx)
189 : ImageTestCase(eglTestCtx, ApiType::es(2, 0), "invalid_create_image", "eglCreateImageKHR() with invalid arguments")
193 void checkCreate (const char* desc, EGLDisplay dpy, const char* dpyStr, EGLContext context, const char* ctxStr, EGLenum source, const char* srcStr, EGLint expectError);
195 IterateResult iterate (void)
197 const Library& egl = m_eglTestCtx.getLibrary();
199 if (eglu::getVersion(egl, m_display) < eglu::Version(1, 5) &&
200 !eglu::hasExtension(egl, m_display, "EGL_KHR_image") &&
201 !eglu::hasExtension(egl, m_display, "EGL_KHR_image_base"))
203 TCU_THROW(NotSupportedError, "EGLimages not supported");
206 #define CHECK_CREATE(MSG, DPY, CONTEXT, SOURCE, ERR) checkCreate(MSG, DPY, #DPY, CONTEXT, #CONTEXT, SOURCE, #SOURCE, ERR)
207 CHECK_CREATE("Testing bad display (-1)...", (EGLDisplay)-1, EGL_NO_CONTEXT, EGL_NONE, EGL_BAD_DISPLAY);
208 CHECK_CREATE("Testing bad context (-1)...", m_display, (EGLContext)-1, EGL_NONE, EGL_BAD_CONTEXT);
209 CHECK_CREATE("Testing bad source (-1)...", m_display, EGL_NO_CONTEXT, (EGLenum)-1, EGL_BAD_PARAMETER);
212 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
218 void InvalidCreateImage::checkCreate (const char* msg, EGLDisplay dpy, const char* dpyStr, EGLContext context, const char* ctxStr, EGLenum source, const char* srcStr, EGLint expectError)
220 m_testCtx.getLog() << TestLog::Message << msg << TestLog::EndMessage;
222 const Library& egl = m_eglTestCtx.getLibrary();
223 const EGLImageKHR image = egl.createImageKHR(dpy, context, source, 0, DE_NULL);
226 call << "eglCreateImage(" << dpyStr << ", " << ctxStr << ", " << srcStr << ", 0, DE_NULL)";
227 checkCallReturn(m_eglTestCtx, call.str().c_str(), image, EGL_NO_IMAGE_KHR, expectError);
231 EGLConfig chooseConfig (const Library& egl, EGLDisplay display, ApiType apiType)
234 vector<EGLConfig> configs;
235 // Prefer configs in order: pbuffer, window, pixmap
236 static const EGLenum s_surfaceTypes[] = { EGL_PBUFFER_BIT, EGL_WINDOW_BIT, EGL_PIXMAP_BIT };
238 attribs[EGL_RENDERABLE_TYPE] = eglu::apiRenderableType(apiType);
240 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_surfaceTypes); ++ndx)
242 attribs[EGL_SURFACE_TYPE] = s_surfaceTypes[ndx];
243 configs = eglu::chooseConfigs(egl, display, attribs);
245 if (!configs.empty())
246 return configs.front();
249 TCU_THROW(NotSupportedError, "No compatible EGL configs found");
256 Context (EglTestContext& eglTestCtx, EGLDisplay display, ContextType ctxType, int width, int height)
257 : m_eglTestCtx (eglTestCtx)
258 , m_display (display)
259 , m_config (chooseConfig(eglTestCtx.getLibrary(), display, ctxType.getAPI()))
260 , m_context (m_eglTestCtx.getLibrary(), m_display, eglu::createGLContext(eglTestCtx.getLibrary(), m_display, m_config, ctxType))
261 , m_surface (createSurface(eglTestCtx, m_display, m_config, width, height))
262 , m_current (eglTestCtx.getLibrary(), m_display, m_surface->get(), m_surface->get(), *m_context)
264 m_eglTestCtx.initGLFunctions(&m_gl, ctxType.getAPI());
267 EGLConfig getConfig (void) const { return m_config; }
268 EGLDisplay getEglDisplay (void) const { return m_display; }
269 EGLContext getEglContext (void) const { return *m_context; }
270 const glw::Functions& gl (void) const { return m_gl; }
273 EglTestContext& m_eglTestCtx;
274 EGLDisplay m_display;
276 eglu::UniqueContext m_context;
277 UniquePtr<ManagedSurface> m_surface;
278 ScopedCurrentContext m_current;
281 Context (const Context&);
282 Context& operator= (const Context&);
285 class CreateImageGLES2 : public ImageTestCase
288 static const char* getTargetName (EGLint target)
292 case EGL_GL_TEXTURE_2D_KHR: return "tex2d";
293 case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR: return "cubemap_pos_x";
294 case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR: return "cubemap_neg_x";
295 case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR: return "cubemap_pos_y";
296 case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR: return "cubemap_neg_y";
297 case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR: return "cubemap_pos_z";
298 case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR: return "cubemap_neg_z";
299 case EGL_GL_RENDERBUFFER_KHR: return "renderbuffer";
300 case EGL_NATIVE_BUFFER_ANDROID: return "android_native";
301 default: DE_ASSERT(DE_FALSE); return "";
305 static const char* getStorageName (GLenum storage)
309 case GL_RED: return "red";
310 case GL_RG: return "rg";
311 case GL_LUMINANCE: return "luminance";
312 case GL_LUMINANCE_ALPHA: return "luminance_alpha";
313 case GL_RGB: return "rgb";
314 case GL_RGBA: return "rgba";
315 case GL_DEPTH_COMPONENT16: return "depth_component_16";
316 case GL_RGBA4: return "rgba4";
317 case GL_RGB5_A1: return "rgb5_a1";
318 case GL_RGB565: return "rgb565";
319 case GL_RGB8: return "rgb8";
320 case GL_RGBA8: return "rgba8";
321 case GL_STENCIL_INDEX8: return "stencil_index8";
328 MovePtr<ImageSource> getImageSource (EGLint target, GLenum internalFormat, GLenum format, GLenum type, bool useTexLevel0)
332 case EGL_GL_TEXTURE_2D_KHR:
333 case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR:
334 case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR:
335 case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR:
336 case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR:
337 case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR:
338 case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR:
339 DE_ASSERT(format != 0u && type != 0u);
340 return createTextureImageSource(target, internalFormat, format, type, useTexLevel0);
342 case EGL_GL_RENDERBUFFER_KHR:
343 DE_ASSERT(format == 0u && type == 0u);
344 return createRenderbufferImageSource(internalFormat);
346 case EGL_NATIVE_BUFFER_ANDROID:
347 DE_ASSERT(format == 0u && type == 0u);
348 return createAndroidNativeImageSource(internalFormat);
351 DE_FATAL("Impossible");
352 return MovePtr<ImageSource>();
356 CreateImageGLES2 (EglTestContext& eglTestCtx, EGLint target, GLenum internalFormat, GLenum format, GLenum type, bool useTexLevel0 = false)
357 : ImageTestCase (eglTestCtx, ApiType::es(2, 0), string("create_image_gles2_") + getTargetName(target) + "_" + getStorageName(internalFormat) + (useTexLevel0 ? "_level0_only" : ""), "Create EGLImage from GLES2 object")
358 , m_source (getImageSource(target, internalFormat, format, type, useTexLevel0))
359 , m_internalFormat (internalFormat)
363 IterateResult iterate (void)
365 const Library& egl = m_eglTestCtx.getLibrary();
366 const EGLDisplay dpy = m_display;
368 if (eglu::getVersion(egl, dpy) < eglu::Version(1, 5))
369 CHECK_EXTENSION(dpy, m_source->getRequiredExtension());
371 // Initialize result.
372 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
374 // Create GLES2 context
375 TestLog& log = m_testCtx.getLog();
376 const ContextType contextType (ApiType::es(2, 0));
377 Context context (m_eglTestCtx, dpy, contextType, 64, 64);
378 const EGLContext eglContext = context.getEglContext();
380 if ((m_internalFormat == GL_RED || m_internalFormat == GL_RG) && !isGLRedSupported())
381 TCU_THROW(NotSupportedError, "Unsupported extension: GL_EXT_texture_rg");
383 log << TestLog::Message << "Using EGL config " << eglu::getConfigID(egl, dpy, context.getConfig()) << TestLog::EndMessage;
385 UniquePtr<ClientBuffer> clientBuffer (m_source->createBuffer(context.gl()));
386 const EGLImageKHR image = m_source->createImage(egl, dpy, eglContext, clientBuffer->get());
388 if (image == EGL_NO_IMAGE_KHR)
390 log << TestLog::Message << " Fail: Got EGL_NO_IMAGE_KHR!" << TestLog::EndMessage;
392 if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
393 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got EGL_NO_IMAGE_KHR");
397 CHECK_EXT_CALL_RET(egl.destroyImageKHR(context.getEglDisplay(), image), (EGLBoolean)EGL_TRUE, EGL_SUCCESS);
403 const UniquePtr<ImageSource> m_source;
404 const GLenum m_internalFormat;
407 class ImageTargetGLES2 : public ImageTestCase
410 static const char* getTargetName (GLenum target)
414 case GL_TEXTURE_2D: return "tex2d";
415 case GL_RENDERBUFFER: return "renderbuffer";
422 ImageTargetGLES2 (EglTestContext& eglTestCtx, GLenum target)
423 : ImageTestCase (eglTestCtx, ApiType::es(2, 0), string("image_target_gles2_") + getTargetName(target), "Use EGLImage as GLES2 object")
428 IterateResult iterate (void)
430 const Library& egl = m_eglTestCtx.getLibrary();
431 TestLog& log = m_testCtx.getLog();
433 // \todo [2011-07-21 pyry] Try all possible EGLImage sources
434 CHECK_EXTENSION(m_display, "EGL_KHR_gl_texture_2D_image");
436 // Initialize result.
437 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
439 // Create GLES2 context
441 Context context(m_eglTestCtx, m_display, ContextType(ApiType::es(2, 0)), 64, 64);
442 log << TestLog::Message << "Using EGL config " << eglu::getConfigID(m_eglTestCtx.getLibrary(), context.getEglDisplay(), context.getConfig()) << TestLog::EndMessage;
444 // Check for OES_EGL_image
446 const char* glExt = (const char*)glGetString(GL_EXTENSIONS);
448 if (string(glExt).find("GL_OES_EGL_image") == string::npos)
449 throw tcu::NotSupportedError("Extension not supported", "GL_OES_EGL_image", __FILE__, __LINE__);
451 TCU_CHECK(m_gl.eglImageTargetTexture2DOES);
452 TCU_CHECK(m_gl.eglImageTargetRenderbufferStorageOES);
455 // Create GL_TEXTURE_2D and EGLImage from it.
456 log << TestLog::Message << "Creating EGLImage using GL_TEXTURE_2D with GL_RGBA storage" << TestLog::EndMessage;
459 GLU_CHECK_CALL(glBindTexture(GL_TEXTURE_2D, srcTex));
460 GLU_CHECK_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL));
461 GLU_CHECK_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
464 EGLint attribs[] = { EGL_GL_TEXTURE_LEVEL_KHR, 0, EGL_NONE };
465 EGLImageKHR image = CHECK_EXT_CALL_ERR(egl.createImageKHR(context.getEglDisplay(), context.getEglContext(), EGL_GL_TEXTURE_2D_KHR, (EGLClientBuffer)(deUintptr)srcTex, attribs), EGL_SUCCESS);
466 if (image == EGL_NO_IMAGE_KHR)
468 log << TestLog::Message << " Fail: Got EGL_NO_IMAGE_KHR!" << TestLog::EndMessage;
470 if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
471 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got EGL_NO_IMAGE_KHR");
474 // Create texture or renderbuffer
475 if (m_target == GL_TEXTURE_2D)
477 log << TestLog::Message << "Creating GL_TEXTURE_2D from EGLimage" << TestLog::EndMessage;
480 GLU_CHECK_CALL(glBindTexture(GL_TEXTURE_2D, dstTex));
481 GLU_CHECK_CALL(glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image));
482 GLU_CHECK_CALL(glDeleteTextures(1, &dstTex));
486 DE_ASSERT(m_target == GL_RENDERBUFFER);
488 log << TestLog::Message << "Creating GL_RENDERBUFFER from EGLimage" << TestLog::EndMessage;
491 GLU_CHECK_CALL(glBindRenderbuffer(GL_RENDERBUFFER, dstRbo));
492 GLU_CHECK_CALL(glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER, (GLeglImageOES)image));
493 GLU_CHECK_CALL(glDeleteRenderbuffers(1, &dstRbo));
497 CHECK_EXT_CALL_RET(egl.destroyImageKHR(context.getEglDisplay(), image), (EGLBoolean)EGL_TRUE, EGL_SUCCESS);
499 // Destroy source texture object
500 GLU_CHECK_CALL(glDeleteTextures(1, &srcTex));
509 class ApiTests : public TestCaseGroup
512 ApiTests (EglTestContext& eglTestCtx, const string& name, const string& desc) : TestCaseGroup(eglTestCtx, name.c_str(), desc.c_str()) {}
516 addChild(new Image::InvalidCreateImage(m_eglTestCtx));
518 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_RED, GL_RED, GL_UNSIGNED_BYTE, false));
519 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_RG, GL_RG, GL_UNSIGNED_BYTE, false));
521 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE));
522 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE));
524 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE));
525 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
526 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_2D_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, true));
528 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE));
529 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
530 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, true));
532 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
533 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
534 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
535 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
536 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE));
538 static const GLenum rboStorages[] =
540 GL_DEPTH_COMPONENT16,
546 for (int storageNdx = 0; storageNdx < DE_LENGTH_OF_ARRAY(rboStorages); storageNdx++)
547 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_GL_RENDERBUFFER_KHR, rboStorages[storageNdx], (GLenum)0, (GLenum)0));
549 static const GLenum androidFormats[] =
558 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(androidFormats); ++formatNdx)
559 addChild(new Image::CreateImageGLES2(m_eglTestCtx, EGL_NATIVE_BUFFER_ANDROID, androidFormats[formatNdx], (GLenum)0, (GLenum)0));
561 addChild(new Image::ImageTargetGLES2(m_eglTestCtx, GL_TEXTURE_2D));
562 addChild(new Image::ImageTargetGLES2(m_eglTestCtx, GL_RENDERBUFFER));
568 ImageTests::ImageTests (EglTestContext& eglTestCtx)
569 : TestCaseGroup(eglTestCtx, "image", "EGLImage Tests")
573 ImageTests::~ImageTests (void)
577 void ImageTests::init (void)
579 addChild(new Image::ApiTests(m_eglTestCtx, "api", "EGLImage API tests"));
580 addChild(Image::createSimpleCreationTests(m_eglTestCtx, "create", "EGLImage creation tests"));
581 addChild(Image::createModifyTests(m_eglTestCtx, "modify", "EGLImage modifying tests"));
582 addChild(Image::createMultiContextRenderTests(m_eglTestCtx, "render_multiple_contexts", "EGLImage render tests on multiple contexts"));