modules/egl/teglPreservingSwapTests.cpp

   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 Test EGL_SWAP_BEHAVIOR_PRESERVED_BIT.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "teglPreservingSwapTests.hpp"
  25
  26 #include "tcuImageCompare.hpp"
  27 #include "tcuTestLog.hpp"
  28 #include "tcuSurface.hpp"
  29 #include "tcuTextureUtil.hpp"
  30
  31 #include "egluNativeWindow.hpp"
  32 #include "egluUtil.hpp"
  33
  34 #include "eglwLibrary.hpp"
  35 #include "eglwEnums.hpp"
  36
  37 #include "gluDefs.hpp"
  38 #include "gluRenderContext.hpp"
  39 #include "gluShaderProgram.hpp"
  40
  41 #include "glwDefs.hpp"
  42 #include "glwEnums.hpp"
  43 #include "glwFunctions.hpp"
  44
  45 #include "deRandom.hpp"
  46
  47 #include "deString.h"
  48
  49 #include <vector>
  50 #include <string>
  51
  52 using std::vector;
  53 using std::string;
  54
  55 using namespace eglw;
  56
  57 namespace deqp
  58 {
  59 namespace egl
  60 {
  61
  62 namespace
  63 {
  64 class GLES2Program;
  65 class ReferenceProgram;
  66
  67 class PreservingSwapTest : public TestCase
  68 {
  69 public:
  70         enum DrawType
  71         {
  72                 DRAWTYPE_NONE = 0,
  73                 DRAWTYPE_GLES2_CLEAR,
  74                 DRAWTYPE_GLES2_RENDER
  75         };
  76
  77                                         PreservingSwapTest      (EglTestContext& eglTestCtx, bool preserveColorbuffer, bool readPixelsBeforeSwap, DrawType preSwapDrawType, DrawType postSwapDrawType, const char* name, const char* description);
  78                                         ~PreservingSwapTest     (void);
  79
  80         void                    init                            (void);
  81         void                    deinit                          (void);
  82         IterateResult   iterate                         (void);
  83
  84 private:
  85         const int                                       m_seed;
  86         const bool                                      m_preserveColorbuffer;
  87         const bool                                      m_readPixelsBeforeSwap;
  88         const DrawType                          m_preSwapDrawType;
  89         const DrawType                          m_postSwapDrawType;
  90
  91         EGLDisplay                                      m_eglDisplay;
  92         eglu::NativeWindow*                     m_window;
  93         EGLSurface                                      m_eglSurface;
  94         EGLConfig                                       m_eglConfig;
  95         EGLContext                                      m_eglContext;
  96         glw::Functions                          m_gl;
  97
  98         GLES2Program*                           m_gles2Program;
  99         ReferenceProgram*                       m_refProgram;
 100
 101         void initEGLSurface     (EGLConfig config);
 102         void initEGLContext (EGLConfig config);
 103 };
 104
 105 class GLES2Program
 106 {
 107 public:
 108                                         GLES2Program    (const glw::Functions& gl);
 109                                         ~GLES2Program   (void);
 110
 111         void                    render                  (int width, int height, float x1, float y1, float x2, float y2, PreservingSwapTest::DrawType drawType);
 112
 113 private:
 114         const glw::Functions&   m_gl;
 115         glu::ShaderProgram              m_glProgram;
 116         glw::GLuint                             m_coordLoc;
 117         glw::GLuint                             m_colorLoc;
 118
 119         GLES2Program&                   operator=               (const GLES2Program&);
 120                                                         GLES2Program    (const GLES2Program&);
 121 };
 122
 123 static glu::ProgramSources getSources (void)
 124 {
 125         const char* const vertexShaderSource =
 126                 "attribute mediump vec4 a_pos;\n"
 127                 "attribute mediump vec4 a_color;\n"
 128                 "varying mediump vec4 v_color;\n"
 129                 "void main(void)\n"
 130                 "{\n"
 131                 "\tv_color = a_color;\n"
 132                 "\tgl_Position = a_pos;\n"
 133                 "}";
 134
 135         const char* const fragmentShaderSource =
 136                 "varying mediump vec4 v_color;\n"
 137                 "void main(void)\n"
 138                 "{\n"
 139                 "\tgl_FragColor = v_color;\n"
 140                 "}";
 141
 142         return glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource);
 143 }
 144
 145 GLES2Program::GLES2Program (const glw::Functions& gl)
 146         : m_gl                  (gl)
 147         , m_glProgram   (gl, getSources())
 148         , m_coordLoc    ((glw::GLuint)-1)
 149         , m_colorLoc    ((glw::GLuint)-1)
 150 {
 151         m_colorLoc = m_gl.getAttribLocation(m_glProgram.getProgram(), "a_color");
 152         m_coordLoc = m_gl.getAttribLocation(m_glProgram.getProgram(), "a_pos");
 153         GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to get attribute locations");
 154 }
 155
 156 GLES2Program::~GLES2Program (void)
 157 {
 158 }
 159
 160 void GLES2Program::render (int width, int height, float x1, float y1, float x2, float y2, PreservingSwapTest::DrawType drawType)
 161 {
 162         if (drawType == PreservingSwapTest::DRAWTYPE_GLES2_RENDER)
 163         {
 164                 const glw::GLfloat coords[] =
 165                 {
 166                         x1, y1, 0.0f, 1.0f,
 167                         x1, y2, 0.0f, 1.0f,
 168                         x2, y2, 0.0f, 1.0f,
 169
 170                         x2, y2, 0.0f, 1.0f,
 171                         x2, y1, 0.0f, 1.0f,
 172                         x1, y1, 0.0f, 1.0f
 173                 };
 174
 175                 const glw::GLubyte colors[] =
 176                 {
 177                         127,    127,    127,    255,
 178                         127,    127,    127,    255,
 179                         127,    127,    127,    255,
 180
 181                         127,    127,    127,    255,
 182                         127,    127,    127,    255,
 183                         127,    127,    127,    255
 184                 };
 185
 186                 m_gl.useProgram(m_glProgram.getProgram());
 187                 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgram() failed");
 188
 189                 m_gl.enableVertexAttribArray(m_coordLoc);
 190                 m_gl.enableVertexAttribArray(m_colorLoc);
 191                 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to enable attributes");
 192
 193                 m_gl.vertexAttribPointer(m_coordLoc, 4, GL_FLOAT, GL_FALSE, 0, coords);
 194                 m_gl.vertexAttribPointer(m_colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, colors);
 195                 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to set attribute pointers");
 196
 197                 m_gl.drawArrays(GL_TRIANGLES, 0, 6);
 198                 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glDrawArrays() failed");
 199
 200                 m_gl.disableVertexAttribArray(m_coordLoc);
 201                 m_gl.disableVertexAttribArray(m_colorLoc);
 202                 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Failed to disable attributes");
 203
 204                 m_gl.useProgram(0);
 205                 GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgram() failed");
 206         }
 207         else if (drawType == PreservingSwapTest::DRAWTYPE_GLES2_CLEAR)
 208         {
 209                 const int ox    = width/2;
 210                 const int oy    = height/2;
 211
 212                 const int px    = width;
 213                 const int py    = height;
 214
 215                 const int x1i   = (int)(((float)px/2.0f) * x1 + (float)ox);
 216                 const int y1i   = (int)(((float)py/2.0f) * y1 + (float)oy);
 217
 218                 const int x2i   = (int)(((float)px/2.0f) * x2 + (float)ox);
 219                 const int y2i   = (int)(((float)py/2.0f) * y2 + (float)oy);
 220
 221                 m_gl.enable(GL_SCISSOR_TEST);
 222                 m_gl.scissor(x1i, y1i, x2i-x1i, y2i-y1i);
 223                 m_gl.clearColor(0.5f, 0.5f, 0.5f, 1.0f);
 224                 m_gl.clear(GL_COLOR_BUFFER_BIT);
 225                 m_gl.disable(GL_SCISSOR_TEST);
 226         }
 227         else
 228                 DE_ASSERT(false);
 229 }
 230
 231 class ReferenceProgram
 232 {
 233 public:
 234                         ReferenceProgram        (void);
 235                         ~ReferenceProgram       (void);
 236
 237         void    render                          (tcu::Surface* target, float x1, float y1, float x2, float y2, PreservingSwapTest::DrawType drawType);
 238
 239 private:
 240                                                 ReferenceProgram        (const ReferenceProgram&);
 241         ReferenceProgram&       operator=                       (const ReferenceProgram&);
 242 };
 243
 244 ReferenceProgram::ReferenceProgram (void)
 245 {
 246 }
 247
 248 ReferenceProgram::~ReferenceProgram (void)
 249 {
 250 }
 251
 252 void ReferenceProgram::render (tcu::Surface* target, float x1, float y1, float x2, float y2, PreservingSwapTest::DrawType drawType)
 253 {
 254         if (drawType == PreservingSwapTest::DRAWTYPE_GLES2_RENDER || drawType == PreservingSwapTest::DRAWTYPE_GLES2_CLEAR)
 255         {
 256                 const int ox    = target->getWidth()/2;
 257                 const int oy    = target->getHeight()/2;
 258
 259                 const int px    = target->getWidth();
 260                 const int py    = target->getHeight();
 261
 262                 const int x1i   = (int)((px/2.0) * x1 + ox);
 263                 const int y1i   = (int)((py/2.0) * y1 + oy);
 264
 265                 const int x2i   = (int)((px/2.0) * x2 + ox);
 266                 const int y2i   = (int)((py/2.0) * y2 + oy);
 267
 268                 const tcu::RGBA color(127, 127, 127, 255);
 269
 270                 for (int y = y1i; y <= y2i; y++)
 271                 {
 272                         for (int x = x1i; x <= x2i; x++)
 273                                 target->setPixel(x, y, color);
 274                 }
 275         }
 276         else
 277                 DE_ASSERT(false);
 278 }
 279
 280 PreservingSwapTest::PreservingSwapTest (EglTestContext& eglTestCtx, bool preserveColorbuffer, bool readPixelsBeforeSwap, DrawType preSwapDrawType, DrawType postSwapDrawType, const char* name, const char* description)
 281         : TestCase                                      (eglTestCtx, name, description)
 282         , m_seed                                        (deStringHash(name))
 283         , m_preserveColorbuffer         (preserveColorbuffer)
 284         , m_readPixelsBeforeSwap        (readPixelsBeforeSwap)
 285         , m_preSwapDrawType                     (preSwapDrawType)
 286         , m_postSwapDrawType            (postSwapDrawType)
 287         , m_eglDisplay                          (EGL_NO_DISPLAY)
 288         , m_window                                      (DE_NULL)
 289         , m_eglSurface                          (EGL_NO_SURFACE)
 290         , m_eglContext                          (EGL_NO_CONTEXT)
 291         , m_gles2Program                        (DE_NULL)
 292         , m_refProgram                          (DE_NULL)
 293 {
 294 }
 295
 296 PreservingSwapTest::~PreservingSwapTest (void)
 297 {
 298         deinit();
 299 }
 300
 301 EGLConfig getEGLConfig (const Library& egl, EGLDisplay eglDisplay, bool preserveColorbuffer)
 302 {
 303         const EGLint attribList[] =
 304         {
 305                 EGL_SURFACE_TYPE,               EGL_WINDOW_BIT | (preserveColorbuffer ? EGL_SWAP_BEHAVIOR_PRESERVED_BIT : 0),
 306                 EGL_RENDERABLE_TYPE,    EGL_OPENGL_ES2_BIT,
 307                 EGL_NONE
 308         };
 309
 310         return eglu::chooseSingleConfig(egl, eglDisplay, &attribList[0]);
 311 }
 312
 313 void clearColorScreen (const glw::Functions& gl, float red, float green, float blue, float alpha)
 314 {
 315         gl.clearColor(red, green, blue, alpha);
 316         gl.clear(GL_COLOR_BUFFER_BIT);
 317 }
 318
 319 void clearColorReference (tcu::Surface* ref, float red, float green, float blue, float alpha)
 320 {
 321         tcu::clear(ref->getAccess(), tcu::Vec4(red, green, blue, alpha));
 322 }
 323
 324 void readPixels (const glw::Functions& gl, tcu::Surface* screen)
 325 {
 326         gl.readPixels(0, 0, screen->getWidth(), screen->getHeight(),  GL_RGBA, GL_UNSIGNED_BYTE, screen->getAccess().getDataPtr());
 327 }
 328
 329 void PreservingSwapTest::initEGLSurface (EGLConfig config)
 330 {
 331         const eglu::NativeWindowFactory&        factory = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());
 332
 333         m_window                = factory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_eglDisplay, config, DE_NULL, eglu::WindowParams(480, 480, eglu::parseWindowVisibility(m_testCtx.getCommandLine())));
 334         m_eglSurface    = eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *m_window, m_eglDisplay, config, DE_NULL);
 335 }
 336
 337 void PreservingSwapTest::initEGLContext (EGLConfig config)
 338 {
 339         const Library&  egl                             = m_eglTestCtx.getLibrary();
 340         const EGLint    attribList[]    =
 341         {
 342                 EGL_CONTEXT_CLIENT_VERSION, 2,
 343                 EGL_NONE
 344         };
 345
 346         egl.bindAPI(EGL_OPENGL_ES_API);
 347         m_eglContext = egl.createContext(m_eglDisplay, config, EGL_NO_CONTEXT, attribList);
 348         EGLU_CHECK_MSG(egl, "eglCreateContext");
 349
 350         DE_ASSERT(m_eglSurface != EGL_NO_SURFACE);
 351         egl.makeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext);
 352         EGLU_CHECK_MSG(egl, "eglMakeCurrent");
 353 }
 354
 355 void PreservingSwapTest::init (void)
 356 {
 357         m_eglDisplay    = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
 358         m_eglConfig             = getEGLConfig(m_eglTestCtx.getLibrary(), m_eglDisplay, m_preserveColorbuffer);
 359
 360         if (m_eglConfig == DE_NULL)
 361                 TCU_THROW(NotSupportedError, "No supported config found");
 362
 363         initEGLSurface(m_eglConfig);
 364         initEGLContext(m_eglConfig);
 365
 366         m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0));
 367
 368         m_gles2Program  = new GLES2Program(m_gl);
 369         m_refProgram    = new ReferenceProgram();
 370 }
 371
 372 void PreservingSwapTest::deinit (void)
 373 {
 374         const Library& egl = m_eglTestCtx.getLibrary();
 375
 376         delete m_refProgram;
 377         m_refProgram = DE_NULL;
 378
 379         delete m_gles2Program;
 380         m_gles2Program = DE_NULL;
 381
 382         if (m_eglContext != EGL_NO_CONTEXT)
 383         {
 384                 egl.makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 385                 egl.destroyContext(m_eglDisplay, m_eglContext);
 386                 m_eglContext = EGL_NO_CONTEXT;
 387         }
 388
 389         if (m_eglSurface != EGL_NO_SURFACE)
 390         {
 391                 egl.destroySurface(m_eglDisplay, m_eglSurface);
 392                 m_eglSurface = EGL_NO_SURFACE;
 393         }
 394
 395         if (m_eglDisplay != EGL_NO_DISPLAY)
 396         {
 397                 egl.terminate(m_eglDisplay);
 398                 m_eglDisplay = EGL_NO_DISPLAY;
 399         }
 400
 401         delete m_window;
 402         m_window = DE_NULL;
 403 }
 404
 405 bool compareToReference (tcu::TestLog& log, const char* name, const char* description, const tcu::Surface& reference, const tcu::Surface& screen, int x, int y, int width, int height)
 406 {
 407         return tcu::fuzzyCompare(log, name, description,
 408                                                          getSubregion(reference.getAccess(), x, y, width, height),
 409                                                          getSubregion(screen.getAccess(), x, y, width, height),
 410                                                          0.05f, tcu::COMPARE_LOG_RESULT);
 411 }
 412
 413 bool comparePreAndPostSwapFramebuffers (tcu::TestLog& log, const tcu::Surface& preSwap, const tcu::Surface& postSwap)
 414 {
 415         return tcu::pixelThresholdCompare(log, "Pre- / Post framebuffer compare", "Compare pre- and post-swap framebuffers", preSwap, postSwap, tcu::RGBA(0, 0, 0, 0), tcu::COMPARE_LOG_RESULT);
 416 }
 417
 418 TestCase::IterateResult PreservingSwapTest::iterate (void)
 419 {
 420         const Library&  egl                             = m_eglTestCtx.getLibrary();
 421         tcu::TestLog&   log                             = m_testCtx.getLog();
 422         de::Random              rnd(m_seed);
 423
 424         const int               width                   = eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_WIDTH);
 425         const int               height                  = eglu::querySurfaceInt(egl, m_eglDisplay, m_eglSurface, EGL_HEIGHT);
 426
 427         const float             clearRed                = rnd.getFloat();
 428         const float             clearGreen              = rnd.getFloat();
 429         const float             clearBlue               = rnd.getFloat();
 430         const float             clearAlpha              = 1.0f;
 431
 432         const float             preSwapX1               = -0.9f * rnd.getFloat();
 433         const float             preSwapY1               = -0.9f * rnd.getFloat();
 434         const float             preSwapX2               = 0.9f * rnd.getFloat();
 435         const float             preSwapY2               = 0.9f * rnd.getFloat();
 436
 437         const float             postSwapX1              = -0.9f * rnd.getFloat();
 438         const float             postSwapY1              = -0.9f * rnd.getFloat();
 439         const float             postSwapX2              = 0.9f * rnd.getFloat();
 440         const float             postSwapY2              = 0.9f * rnd.getFloat();
 441
 442         tcu::Surface    postSwapFramebufferReference(width, height);
 443         tcu::Surface    preSwapFramebufferReference(width, height);
 444
 445         tcu::Surface    postSwapFramebuffer(width, height);
 446         tcu::Surface    preSwapFramebuffer(width, height);
 447
 448         if (m_preserveColorbuffer)
 449                 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED));
 450
 451         EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext));
 452
 453         clearColorScreen(m_gl, clearRed, clearGreen, clearBlue, clearAlpha);
 454
 455         if (m_readPixelsBeforeSwap)
 456                 clearColorReference(&preSwapFramebufferReference, clearRed, clearGreen, clearBlue, clearAlpha);
 457
 458         clearColorReference(&postSwapFramebufferReference, clearRed, clearGreen, clearBlue, clearAlpha);
 459
 460         if (m_preSwapDrawType != DRAWTYPE_NONE)
 461         {
 462                 m_gles2Program->render(width, height, preSwapX1, preSwapY1, preSwapX2, preSwapY2, m_preSwapDrawType);
 463                 m_refProgram->render(&postSwapFramebufferReference, preSwapX1, preSwapY1, preSwapX2, preSwapY2, m_preSwapDrawType);
 464         }
 465
 466         if (m_readPixelsBeforeSwap)
 467         {
 468                 if (m_preSwapDrawType != DRAWTYPE_NONE)
 469                         m_refProgram->render(&preSwapFramebufferReference, preSwapX1, preSwapY1, preSwapX2, preSwapY2, m_preSwapDrawType);
 470
 471                 readPixels(m_gl, &preSwapFramebuffer);
 472         }
 473
 474         EGLU_CHECK_CALL(egl, swapBuffers(m_eglDisplay, m_eglSurface));
 475
 476         if (m_postSwapDrawType != DRAWTYPE_NONE)
 477         {
 478                 m_refProgram->render(&postSwapFramebufferReference, postSwapX1, postSwapY1, postSwapX2, postSwapY2, m_postSwapDrawType);
 479                 m_gles2Program->render(width, height, postSwapX1, postSwapY1, postSwapX2, postSwapY2, m_postSwapDrawType);
 480         }
 481
 482         readPixels(m_gl, &postSwapFramebuffer);
 483
 484         bool isOk = true;
 485
 486         if (m_preserveColorbuffer)
 487         {
 488                 if (m_readPixelsBeforeSwap)
 489                         isOk = isOk && compareToReference(log, "Compare pre-swap framebuffer to reference", "Compare pre-swap framebuffer to reference", preSwapFramebufferReference, preSwapFramebuffer, 0, 0, width, height);
 490
 491                 isOk = isOk && compareToReference(log, "Compare post-swap framebuffer to reference", "Compare post-swap framebuffer to reference", postSwapFramebufferReference, postSwapFramebuffer, 0, 0, width, height);
 492
 493                 if (m_readPixelsBeforeSwap && m_postSwapDrawType == PreservingSwapTest::DRAWTYPE_NONE)
 494                         isOk = isOk && comparePreAndPostSwapFramebuffers(log, preSwapFramebuffer, postSwapFramebuffer);
 495         }
 496         else
 497         {
 498                 const int ox    = width/2;
 499                 const int oy    = height/2;
 500
 501                 const int px    = width;
 502                 const int py    = height;
 503
 504                 const int x1i   = (int)(((float)px/2.0f) * postSwapX1 + (float)ox);
 505                 const int y1i   = (int)(((float)py/2.0f) * postSwapY1 + (float)oy);
 506
 507                 const int x2i   = (int)(((float)px/2.0f) * postSwapX2 + (float)ox);
 508                 const int y2i   = (int)(((float)py/2.0f) * postSwapY2 + (float)oy);
 509
 510                 if (m_readPixelsBeforeSwap)
 511                         isOk = isOk && compareToReference(log, "Compare pre-swap framebuffer to reference", "Compare pre-swap framebuffer to reference", preSwapFramebufferReference, preSwapFramebuffer, 0, 0, width, height);
 512
 513                 DE_ASSERT(m_postSwapDrawType != DRAWTYPE_NONE);
 514                 isOk = isOk && compareToReference(log, "Compare valid are of post-swap framebuffer to reference", "Compare valid area of post-swap framebuffer to reference", postSwapFramebufferReference, postSwapFramebuffer, x1i, y1i, x2i - x1i, y2i - y1i);
 515         }
 516
 517         if (isOk)
 518                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 519         else
 520                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 521
 522         return STOP;
 523 }
 524
 525 string generateTestName (PreservingSwapTest::DrawType preSwapDrawType, PreservingSwapTest::DrawType postSwapDrawType)
 526 {
 527         std::ostringstream stream;
 528
 529         if (preSwapDrawType == PreservingSwapTest::DRAWTYPE_NONE && postSwapDrawType == PreservingSwapTest::DRAWTYPE_NONE)
 530                 stream << "no_draw";
 531         else
 532         {
 533                 switch (preSwapDrawType)
 534                 {
 535                         case PreservingSwapTest::DRAWTYPE_NONE:
 536                                 // Do nothing
 537                                 break;
 538
 539                         case PreservingSwapTest::DRAWTYPE_GLES2_RENDER:
 540                                 stream << "pre_render";
 541                                 break;
 542
 543                         case PreservingSwapTest::DRAWTYPE_GLES2_CLEAR:
 544                                 stream << "pre_clear";
 545                                 break;
 546
 547                         default:
 548                                 DE_ASSERT(false);
 549                 }
 550
 551                 if (preSwapDrawType != PreservingSwapTest::DRAWTYPE_NONE && postSwapDrawType != PreservingSwapTest::DRAWTYPE_NONE)
 552                         stream << "_";
 553
 554                 switch (postSwapDrawType)
 555                 {
 556                         case PreservingSwapTest::DRAWTYPE_NONE:
 557                                 // Do nothing
 558                                 break;
 559
 560                         case PreservingSwapTest::DRAWTYPE_GLES2_RENDER:
 561                                 stream << "post_render";
 562                                 break;
 563
 564                         case PreservingSwapTest::DRAWTYPE_GLES2_CLEAR:
 565                                 stream << "post_clear";
 566                                 break;
 567
 568                         default:
 569                                 DE_ASSERT(false);
 570                 }
 571         }
 572
 573         return stream.str();
 574 }
 575
 576 } // anonymous
 577
 578 PreservingSwapTests::PreservingSwapTests (EglTestContext& eglTestCtx)
 579         : TestCaseGroup(eglTestCtx, "preserve_swap", "Color buffer preserving swap tests")
 580 {
 581 }
 582
 583 void PreservingSwapTests::init (void)
 584 {
 585         const PreservingSwapTest::DrawType preSwapDrawTypes[] =
 586         {
 587                 PreservingSwapTest::DRAWTYPE_NONE,
 588                 PreservingSwapTest::DRAWTYPE_GLES2_CLEAR,
 589                 PreservingSwapTest::DRAWTYPE_GLES2_RENDER
 590         };
 591
 592         const PreservingSwapTest::DrawType postSwapDrawTypes[] =
 593         {
 594                 PreservingSwapTest::DRAWTYPE_NONE,
 595                 PreservingSwapTest::DRAWTYPE_GLES2_CLEAR,
 596                 PreservingSwapTest::DRAWTYPE_GLES2_RENDER
 597         };
 598
 599         for (int preserveNdx = 0; preserveNdx < 2; preserveNdx++)
 600         {
 601                 const bool                              preserve                = (preserveNdx == 0);
 602                 TestCaseGroup* const    preserveGroup   = new TestCaseGroup(m_eglTestCtx, (preserve ? "preserve" : "no_preserve"), "");
 603
 604                 for (int readPixelsNdx = 0; readPixelsNdx < 2; readPixelsNdx++)
 605                 {
 606                         const bool                              readPixelsBeforeSwap            = (readPixelsNdx == 1);
 607                         TestCaseGroup* const    readPixelsBeforeSwapGroup       = new TestCaseGroup(m_eglTestCtx, (readPixelsBeforeSwap ? "read_before_swap" : "no_read_before_swap"), "");
 608
 609                         for (int preSwapDrawTypeNdx = 0; preSwapDrawTypeNdx < DE_LENGTH_OF_ARRAY(preSwapDrawTypes); preSwapDrawTypeNdx++)
 610                         {
 611                                 const PreservingSwapTest::DrawType preSwapDrawType = preSwapDrawTypes[preSwapDrawTypeNdx];
 612
 613                                 for (int postSwapDrawTypeNdx = 0; postSwapDrawTypeNdx < DE_LENGTH_OF_ARRAY(postSwapDrawTypes); postSwapDrawTypeNdx++)
 614                                 {
 615                                         const PreservingSwapTest::DrawType postSwapDrawType = postSwapDrawTypes[postSwapDrawTypeNdx];
 616
 617                                         // If not preserving and rendering after swap, then there is nothing to verify
 618                                         if (!preserve && postSwapDrawType == PreservingSwapTest::DRAWTYPE_NONE)
 619                                                 continue;
 620
 621                                         const std::string name = generateTestName(preSwapDrawType, postSwapDrawType);
 622
 623                                         readPixelsBeforeSwapGroup->addChild(new PreservingSwapTest(m_eglTestCtx, preserve, readPixelsBeforeSwap, preSwapDrawType, postSwapDrawType, name.c_str(), ""));
 624                                 }
 625                         }
 626
 627                         preserveGroup->addChild(readPixelsBeforeSwapGroup);
 628                 }
 629
 630                 addChild(preserveGroup);
 631         }
 632 }
 633
 634 } // egl
 635 } // deqp