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 Test for mapping client color values to native surface colors
22 *//*--------------------------------------------------------------------*/
24 #include "teglNativeColorMappingTests.hpp"
26 #include "teglSimpleConfigCase.hpp"
28 #include "tcuTexture.hpp"
30 #include "egluNativeDisplay.hpp"
31 #include "egluNativeWindow.hpp"
32 #include "egluNativePixmap.hpp"
33 #include "egluUnique.hpp"
34 #include "egluUtil.hpp"
36 #include "eglwLibrary.hpp"
37 #include "eglwEnums.hpp"
39 #include "gluDefs.hpp"
40 #include "glwFunctions.hpp"
41 #include "glwEnums.hpp"
43 #include "tcuImageCompare.hpp"
44 #include "tcuTestLog.hpp"
45 #include "tcuTexture.hpp"
46 #include "tcuTextureUtil.hpp"
48 #include "deUniquePtr.hpp"
49 #include "deStringUtil.hpp"
51 #include "deThread.hpp"
70 EGLContext createGLES2Context (const Library& egl, EGLDisplay display, EGLConfig config)
72 EGLContext context = EGL_NO_CONTEXT;
73 const EGLint attribList[] =
75 EGL_CONTEXT_CLIENT_VERSION, 2,
79 EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API));
81 context = egl.createContext(display, config, EGL_NO_CONTEXT, attribList);
82 EGLU_CHECK_MSG(egl, "eglCreateContext() failed");
88 deUint32 createGLES2Program (const glw::Functions& gl, TestLog& log)
90 const char* const vertexShaderSource =
91 "attribute highp vec2 a_pos;\n"
94 "\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
97 const char* const fragmentShaderSource =
98 "uniform mediump vec4 u_color;\n"
101 "\tgl_FragColor = u_color;\n"
104 deUint32 program = 0;
105 deUint32 vertexShader = 0;
106 deUint32 fragmentShader = 0;
108 deInt32 vertexCompileStatus;
109 string vertexInfoLog;
110 deInt32 fragmentCompileStatus;
111 string fragmentInfoLog;
113 string programInfoLog;
117 program = gl.createProgram();
118 vertexShader = gl.createShader(GL_VERTEX_SHADER);
119 fragmentShader = gl.createShader(GL_FRAGMENT_SHADER);
121 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create shaders and program");
123 gl.shaderSource(vertexShader, 1, &vertexShaderSource, DE_NULL);
124 gl.compileShader(vertexShader);
125 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to setup vertex shader");
127 gl.shaderSource(fragmentShader, 1, &fragmentShaderSource, DE_NULL);
128 gl.compileShader(fragmentShader);
129 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to setup fragment shader");
132 deInt32 infoLogLength = 0;
134 gl.getShaderiv(vertexShader, GL_COMPILE_STATUS, &vertexCompileStatus);
135 gl.getShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &infoLogLength);
137 vertexInfoLog.resize(infoLogLength, '\0');
139 gl.getShaderInfoLog(vertexShader, (glw::GLsizei)vertexInfoLog.length(), &infoLogLength, &(vertexInfoLog[0]));
140 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to get vertex shader compile info");
142 vertexInfoLog.resize(infoLogLength);
146 deInt32 infoLogLength = 0;
148 gl.getShaderiv(fragmentShader, GL_COMPILE_STATUS, &fragmentCompileStatus);
149 gl.getShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &infoLogLength);
151 fragmentInfoLog.resize(infoLogLength, '\0');
153 gl.getShaderInfoLog(fragmentShader, (glw::GLsizei)fragmentInfoLog.length(), &infoLogLength, &(fragmentInfoLog[0]));
154 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to get fragment shader compile info");
156 fragmentInfoLog.resize(infoLogLength);
159 gl.attachShader(program, vertexShader);
160 gl.attachShader(program, fragmentShader);
161 gl.linkProgram(program);
162 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to setup program");
165 deInt32 infoLogLength = 0;
167 gl.getProgramiv(program, GL_LINK_STATUS, &linkStatus);
168 gl.getProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength);
170 programInfoLog.resize(infoLogLength, '\0');
172 gl.getProgramInfoLog(program, (glw::GLsizei)programInfoLog.length(), &infoLogLength, &(programInfoLog[0]));
173 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to get program link info");
175 programInfoLog.resize(infoLogLength);
178 if (linkStatus == 0 || vertexCompileStatus == 0 || fragmentCompileStatus == 0)
181 log.startShaderProgram(linkStatus != 0, programInfoLog.c_str());
183 log << TestLog::Shader(QP_SHADER_TYPE_VERTEX, vertexShaderSource, vertexCompileStatus != 0, vertexInfoLog);
184 log << TestLog::Shader(QP_SHADER_TYPE_FRAGMENT, fragmentShaderSource, fragmentCompileStatus != 0, fragmentInfoLog);
186 log.endShaderProgram();
189 gl.deleteShader(vertexShader);
190 gl.deleteShader(fragmentShader);
191 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to delete shaders");
193 TCU_CHECK(linkStatus != 0 && vertexCompileStatus != 0 && fragmentCompileStatus != 0);
198 gl.deleteProgram(program);
201 gl.deleteShader(vertexShader);
204 gl.deleteShader(fragmentShader);
212 void clear (const glw::Functions& gl, const tcu::Vec4& color)
214 gl.clearColor(color.x(), color.y(), color.z(), color.w());
215 gl.clear(GL_COLOR_BUFFER_BIT);
216 GLU_EXPECT_NO_ERROR(gl.getError(), "Color clear failed");
219 void render (const glw::Functions& gl, deUint32 program, const tcu::Vec4& color)
221 const float positions[] =
232 deUint32 posLocation;
233 deUint32 colorLocation;
235 gl.useProgram(program);
236 posLocation = gl.getAttribLocation(program, "a_pos");
237 gl.enableVertexAttribArray(posLocation);
238 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to setup shader program for rendering");
240 colorLocation = gl.getUniformLocation(program, "u_color");
241 gl.uniform4fv(colorLocation, 1, color.getPtr());
243 gl.vertexAttribPointer(posLocation, 2, GL_FLOAT, GL_FALSE, 0, positions);
244 gl.drawArrays(GL_TRIANGLES, 0, 6);
245 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to render");
248 bool validate (TestLog& log, const Library& egl, EGLDisplay display, EGLConfig config, const tcu::TextureLevel& result, const tcu::Vec4& color)
250 const tcu::UVec4 eglBitDepth((deUint32)eglu::getConfigAttribInt(egl, display, config, EGL_RED_SIZE),
251 (deUint32)eglu::getConfigAttribInt(egl, display, config, EGL_GREEN_SIZE),
252 (deUint32)eglu::getConfigAttribInt(egl, display, config, EGL_BLUE_SIZE),
253 (deUint32)eglu::getConfigAttribInt(egl, display, config, EGL_ALPHA_SIZE));
255 const tcu::UVec4 nativeBitDepth(tcu::getTextureFormatBitDepth(result.getFormat()).asUint());
256 const tcu::UVec4 bitDepth(deMinu32(nativeBitDepth.x(), eglBitDepth.x()),
257 deMinu32(nativeBitDepth.y(), eglBitDepth.y()),
258 deMinu32(nativeBitDepth.z(), eglBitDepth.z()),
259 deMinu32(nativeBitDepth.w(), eglBitDepth.w()));
261 const tcu::UVec4 uColor = tcu::UVec4((deUint32)((float)((1u << bitDepth.x()) - 1u) * color.x()),
262 (deUint32)((float)((1u << bitDepth.y()) - 1u) * color.y()),
263 (deUint32)((float)((1u << bitDepth.z()) - 1u) * color.z()),
264 (deUint32)((float)((1u << bitDepth.w()) - 1u) * color.w()));
266 tcu::TextureLevel reference(result.getFormat(), result.getWidth(), result.getHeight());
268 for (int y = 0; y < result.getHeight(); y++)
270 for (int x = 0; x < result.getWidth(); x++)
271 reference.getAccess().setPixel(uColor, x, y);
274 return tcu::intThresholdCompare(log, "Result compare", "Compare results", reference.getAccess(), result.getAccess(), tcu::UVec4(1u, 1u, 1u, (bitDepth.w() > 0 ? 1u : std::numeric_limits<deUint32>::max())), tcu::COMPARE_LOG_RESULT);
277 class NativeColorMappingCase : public SimpleConfigCase
282 NATIVETYPE_WINDOW = 0,
284 NATIVETYPE_PBUFFER_COPY_TO_PIXMAP
287 NativeColorMappingCase (EglTestContext& eglTestCtx, const char* name, const char* description, bool render, NativeType nativeType, const eglu::FilterList& filters);
288 ~NativeColorMappingCase (void);
291 void executeForConfig (EGLDisplay display, EGLConfig config);
293 NativeType m_nativeType;
297 NativeColorMappingCase::NativeColorMappingCase (EglTestContext& eglTestCtx, const char* name, const char* description, bool render, NativeType nativeType, const eglu::FilterList& filters)
298 : SimpleConfigCase (eglTestCtx, name, description, filters)
299 , m_nativeType (nativeType)
304 NativeColorMappingCase::~NativeColorMappingCase (void)
309 void logConfigInfo (TestLog& log, const Library& egl, EGLDisplay display, EGLConfig config, NativeColorMappingCase::NativeType nativeType, int waitFrames)
311 log << TestLog::Message << "EGL_RED_SIZE: " << eglu::getConfigAttribInt(egl, display, config, EGL_RED_SIZE) << TestLog::EndMessage;
312 log << TestLog::Message << "EGL_GREEN_SIZE: " << eglu::getConfigAttribInt(egl, display, config, EGL_GREEN_SIZE) << TestLog::EndMessage;
313 log << TestLog::Message << "EGL_BLUE_SIZE: " << eglu::getConfigAttribInt(egl, display, config, EGL_BLUE_SIZE) << TestLog::EndMessage;
314 log << TestLog::Message << "EGL_ALPHA_SIZE: " << eglu::getConfigAttribInt(egl, display, config, EGL_ALPHA_SIZE) << TestLog::EndMessage;
315 log << TestLog::Message << "EGL_DEPTH_SIZE: " << eglu::getConfigAttribInt(egl, display, config, EGL_DEPTH_SIZE) << TestLog::EndMessage;
316 log << TestLog::Message << "EGL_STENCIL_SIZE: " << eglu::getConfigAttribInt(egl, display, config, EGL_STENCIL_SIZE) << TestLog::EndMessage;
317 log << TestLog::Message << "EGL_SAMPLES: " << eglu::getConfigAttribInt(egl, display, config, EGL_SAMPLES) << TestLog::EndMessage;
319 if (nativeType == NativeColorMappingCase::NATIVETYPE_WINDOW)
320 log << TestLog::Message << "Waiting " << waitFrames * 16 << "ms after eglSwapBuffers() and glFinish() for frame to become visible" << TestLog::EndMessage;
323 bool testNativeWindow (TestLog& log, eglu::NativeDisplay& nativeDisplay, eglu::NativeWindow& nativeWindow, EGLDisplay display, EGLContext context, EGLConfig config, const glw::Functions& gl, bool renderColor, int waitFrames, size_t colorCount, const tcu::Vec4* colors)
325 const Library& egl = nativeDisplay.getLibrary();
326 eglu::UniqueSurface surface (egl, display, eglu::createWindowSurface(nativeDisplay, nativeWindow, display, config, DE_NULL));
327 tcu::TextureLevel result;
328 deUint32 program = 0;
333 EGLU_CHECK_CALL(egl, makeCurrent(display, *surface, *surface, context));
336 program = createGLES2Program(gl, log);
338 for (int colorNdx = 0; colorNdx < (int)colorCount; colorNdx++)
341 render(gl, program, colors[colorNdx]);
343 clear(gl, colors[colorNdx]);
345 EGLU_CHECK_CALL(egl, swapBuffers(display, *surface));
346 EGLU_CHECK_CALL(egl, waitClient());
347 deSleep(waitFrames*16);
348 nativeWindow.readScreenPixels(&result);
350 if (!validate(log, egl, display, config, result, colors[colorNdx]))
354 EGLU_CHECK_CALL(egl, makeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
359 gl.deleteProgram(program);
366 bool testNativePixmap (TestLog& log, eglu::NativeDisplay& nativeDisplay, eglu::NativePixmap& nativePixmap, EGLDisplay display, EGLContext context, EGLConfig config, const glw::Functions& gl, bool renderColor, size_t colorCount, const tcu::Vec4* colors)
368 const Library& egl = nativeDisplay.getLibrary();
369 eglu::UniqueSurface surface (egl, display, eglu::createPixmapSurface(nativeDisplay, nativePixmap, display, config, DE_NULL));
370 tcu::TextureLevel result;
371 deUint32 program = 0;
376 EGLU_CHECK_CALL(egl, makeCurrent(display, *surface, *surface, context));
379 program = createGLES2Program(gl, log);
381 for (int colorNdx = 0; colorNdx < (int)colorCount; colorNdx++)
384 render(gl, program, colors[colorNdx]);
386 clear(gl, colors[colorNdx]);
388 EGLU_CHECK_CALL(egl, waitClient());
389 nativePixmap.readPixels(&result);
391 if (!validate(log, egl, display, config, result, colors[colorNdx]))
395 EGLU_CHECK_CALL(egl, makeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
400 gl.deleteProgram(program);
407 bool testNativePixmapCopy (TestLog& log, const Library& egl, eglu::NativePixmap& nativePixmap, EGLDisplay display, EGLContext context, EGLConfig config, const glw::Functions& gl, bool renderColor, size_t colorCount, const tcu::Vec4* colors)
409 eglu::UniqueSurface surface (egl, display, egl.createPbufferSurface(display, config, DE_NULL));
410 tcu::TextureLevel result;
411 deUint32 program = 0;
416 EGLU_CHECK_CALL(egl, makeCurrent(display, *surface, *surface, context));
419 program = createGLES2Program(gl, log);
421 for (int colorNdx = 0; colorNdx < (int)colorCount; colorNdx++)
424 render(gl, program, colors[colorNdx]);
426 clear(gl, colors[colorNdx]);
428 EGLU_CHECK_CALL(egl, copyBuffers(display, *surface, nativePixmap.getLegacyNative()));
429 EGLU_CHECK_CALL(egl, waitClient());
430 nativePixmap.readPixels(&result);
432 if (!validate(log, egl, display, config, result, colors[colorNdx]))
436 EGLU_CHECK_CALL(egl, makeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
441 gl.deleteProgram(program);
448 void NativeColorMappingCase::executeForConfig (EGLDisplay display, EGLConfig config)
450 const int width = 128;
451 const int height = 128;
453 const tcu::Vec4 colors[] =
455 tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f),
456 tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f),
457 tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f),
458 tcu::Vec4(0.0f, 1.0f, 1.0f, 1.0f),
459 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f),
460 tcu::Vec4(1.0f, 0.0f, 1.0f, 1.0f),
461 tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f),
462 tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f),
464 tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f),
465 tcu::Vec4(0.0f, 0.0f, 0.5f, 1.0f),
466 tcu::Vec4(0.0f, 0.5f, 0.0f, 1.0f),
467 tcu::Vec4(0.0f, 0.5f, 0.5f, 1.0f),
468 tcu::Vec4(0.5f, 0.0f, 0.0f, 1.0f),
469 tcu::Vec4(0.5f, 0.0f, 0.5f, 1.0f),
470 tcu::Vec4(0.5f, 0.5f, 0.0f, 1.0f),
471 tcu::Vec4(0.5f, 0.5f, 0.5f, 1.0f)
474 const Library& egl = m_eglTestCtx.getLibrary();
475 const string configIdStr (de::toString(eglu::getConfigAttribInt(egl, display, config, EGL_CONFIG_ID)));
476 tcu::ScopedLogSection logSection (m_testCtx.getLog(), ("Config ID " + configIdStr).c_str(), ("Config ID " + configIdStr).c_str());
477 const int waitFrames = 5;
478 const eglu::NativeWindowFactory* windowFactory;
479 const eglu::NativePixmapFactory* pixmapFactory;
481 logConfigInfo(m_testCtx.getLog(), egl, display, config, m_nativeType, waitFrames);
485 windowFactory = &eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());
487 if ((windowFactory->getCapabilities() & eglu::NativeWindow::CAPABILITY_READ_SCREEN_PIXELS) == 0)
488 TCU_THROW(NotSupportedError, "Native window doesn't support readPixels()");
490 catch (const tcu::NotSupportedError&)
492 if (m_nativeType == NATIVETYPE_WINDOW)
495 windowFactory = DE_NULL;
500 pixmapFactory = &eglu::selectNativePixmapFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());
502 if (m_nativeType == NATIVETYPE_PIXMAP)
504 if ((pixmapFactory->getCapabilities() & eglu::NativePixmap::CAPABILITY_READ_PIXELS) == 0)
505 TCU_THROW(NotSupportedError, "Native pixmap doesn't support readPixels()");
507 else if (m_nativeType == NATIVETYPE_PBUFFER_COPY_TO_PIXMAP)
509 if ((pixmapFactory->getCapabilities() & eglu::NativePixmap::CAPABILITY_READ_PIXELS) == 0 ||
510 (pixmapFactory->getCapabilities() & eglu::NativePixmap::CAPABILITY_CREATE_SURFACE_LEGACY) == 0)
511 TCU_THROW(NotSupportedError, "Native pixmap doesn't support readPixels() or legacy create surface");
514 catch (const tcu::NotSupportedError&)
516 if (m_nativeType == NATIVETYPE_PIXMAP || m_nativeType == NATIVETYPE_PBUFFER_COPY_TO_PIXMAP)
519 pixmapFactory = DE_NULL;
522 DE_ASSERT(m_nativeType != NATIVETYPE_WINDOW || windowFactory);
523 DE_ASSERT((m_nativeType != NATIVETYPE_PIXMAP && m_nativeType != NATIVETYPE_PBUFFER_COPY_TO_PIXMAP) || pixmapFactory);
525 eglu::UniqueContext context (egl, display, createGLES2Context(egl, display, config));
528 m_eglTestCtx.initGLFunctions(&gl, glu::ApiType::es(2,0));
530 switch (m_nativeType)
532 case NATIVETYPE_WINDOW:
534 de::UniquePtr<eglu::NativeWindow> nativeWindow (windowFactory->createWindow(&m_eglTestCtx.getNativeDisplay(), display, config, DE_NULL, eglu::WindowParams(width, height, eglu::WindowParams::VISIBILITY_VISIBLE)));
536 if (!testNativeWindow(m_testCtx.getLog(), m_eglTestCtx.getNativeDisplay(), *nativeWindow, display, *context, config, gl, m_render, waitFrames, DE_LENGTH_OF_ARRAY(colors), colors))
537 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid color rendered");
541 case NATIVETYPE_PIXMAP:
543 de::UniquePtr<eglu::NativePixmap> nativePixmap (pixmapFactory->createPixmap(&m_eglTestCtx.getNativeDisplay(), display, config, DE_NULL, width, height));
545 if (!testNativePixmap(m_testCtx.getLog(), m_eglTestCtx.getNativeDisplay(), *nativePixmap, display, *context, config, gl, m_render, DE_LENGTH_OF_ARRAY(colors), colors))
546 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid color rendered");
550 case NATIVETYPE_PBUFFER_COPY_TO_PIXMAP:
552 de::UniquePtr<eglu::NativePixmap> nativePixmap (pixmapFactory->createPixmap(&m_eglTestCtx.getNativeDisplay(), display, config, DE_NULL, width, height));
554 if (!testNativePixmapCopy(m_testCtx.getLog(), egl, *nativePixmap, display, *context, config, gl, m_render, DE_LENGTH_OF_ARRAY(colors), colors))
555 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid color rendered");
564 template<deUint32 Type>
565 static bool surfaceType (const eglu::CandidateConfig& c)
567 return (c.surfaceType() & Type) == Type;
570 void addTestGroups (EglTestContext& eglTestCtx, TestCaseGroup* group, NativeColorMappingCase::NativeType type)
572 eglu::FilterList baseFilters;
576 case NativeColorMappingCase::NATIVETYPE_WINDOW:
577 baseFilters << surfaceType<EGL_WINDOW_BIT>;
580 case NativeColorMappingCase::NATIVETYPE_PIXMAP:
581 baseFilters << surfaceType<EGL_PIXMAP_BIT>;
584 case NativeColorMappingCase::NATIVETYPE_PBUFFER_COPY_TO_PIXMAP:
585 baseFilters << surfaceType<EGL_PBUFFER_BIT>;
592 vector<NamedFilterList> filterLists;
593 getDefaultFilterLists(filterLists, baseFilters);
595 for (vector<NamedFilterList>::iterator i = filterLists.begin(); i != filterLists.end(); i++)
597 group->addChild(new NativeColorMappingCase(eglTestCtx, (string(i->getName()) + "_clear").c_str(), i->getDescription(), false, type, *i));
598 group->addChild(new NativeColorMappingCase(eglTestCtx, (string(i->getName()) + "_render").c_str(), i->getDescription(), true, type, *i));
604 NativeColorMappingTests::NativeColorMappingTests (EglTestContext& eglTestCtx)
605 : TestCaseGroup(eglTestCtx, "native_color_mapping", "Tests for mapping client colors to native surface")
609 void NativeColorMappingTests::init (void)
612 TestCaseGroup* windowGroup = new TestCaseGroup(m_eglTestCtx, "native_window", "Tests for mapping client color to native window");
613 addTestGroups(m_eglTestCtx, windowGroup, NativeColorMappingCase::NATIVETYPE_WINDOW);
614 addChild(windowGroup);
618 TestCaseGroup* pixmapGroup = new TestCaseGroup(m_eglTestCtx, "native_pixmap", "Tests for mapping client color to native pixmap");
619 addTestGroups(m_eglTestCtx, pixmapGroup, NativeColorMappingCase::NATIVETYPE_PIXMAP);
620 addChild(pixmapGroup);
624 TestCaseGroup* pbufferGroup = new TestCaseGroup(m_eglTestCtx, "pbuffer_to_native_pixmap", "Tests for mapping client color to native pixmap with eglCopyBuffers()");
625 addTestGroups(m_eglTestCtx, pbufferGroup, NativeColorMappingCase::NATIVETYPE_PBUFFER_COPY_TO_PIXMAP);
626 addChild(pbufferGroup);