modules/egl/teglSyncTests.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 EGL EGL_KHR_fence_sync and EGL_KHR_reusable_sync tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "teglSyncTests.hpp"
  25
  26 #include "egluNativeWindow.hpp"
  27 #include "egluStrUtil.hpp"
  28 #include "egluUtil.hpp"
  29
  30 #include "eglwLibrary.hpp"
  31 #include "eglwEnums.hpp"
  32
  33 #include "tcuTestLog.hpp"
  34 #include "tcuCommandLine.hpp"
  35
  36 #include "gluDefs.hpp"
  37
  38 #include "glwFunctions.hpp"
  39 #include "glwEnums.hpp"
  40
  41 #include <vector>
  42 #include <string>
  43 #include <sstream>
  44 #include <set>
  45
  46 using std::vector;
  47 using std::string;
  48 using std::set;
  49
  50 using tcu::TestLog;
  51
  52 using namespace eglw;
  53 using namespace glw;
  54
  55 namespace deqp
  56 {
  57 namespace egl
  58 {
  59 namespace
  60 {
  61
  62 const char* getSyncTypeName (EGLenum syncType)
  63 {
  64         switch (syncType)
  65         {
  66                 case EGL_SYNC_FENCE_KHR:        return "EGL_SYNC_FENCE_KHR";
  67                 case EGL_SYNC_REUSABLE_KHR:     return "EGL_SYNC_REUSABLE_KHR";
  68                 default:
  69                         DE_ASSERT(DE_FALSE);
  70                         return "<Unknown>";
  71         }
  72 }
  73
  74 class SyncTest : public TestCase
  75 {
  76 public:
  77         enum Extension
  78         {
  79                 EXTENSION_NONE                          = 0,
  80                 EXTENSION_WAIT_SYNC                     = (0x1 << 0),
  81                 EXTENSION_FENCE_SYNC            = (0x1 << 1),
  82                 EXTENSION_REUSABLE_SYNC         = (0x1 << 2)
  83         };
  84                                                                         SyncTest        (EglTestContext& eglTestCtx, EGLenum syncType, Extension extensions, const char* name, const char* description);
  85                                                                         ~SyncTest       (void);
  86
  87         void                                                    init            (void);
  88         void                                                    deinit          (void);
  89
  90 protected:
  91         const EGLenum                                   m_syncType;
  92         const Extension                                 m_extensions;
  93
  94         glw::Functions                                  m_gl;
  95
  96         EGLDisplay                                              m_eglDisplay;
  97         EGLConfig                                               m_eglConfig;
  98         EGLSurface                                              m_eglSurface;
  99         eglu::NativeWindow*                             m_nativeWindow;
 100         EGLContext                                              m_eglContext;
 101         EGLSyncKHR                                              m_sync;
 102 };
 103
 104 SyncTest::SyncTest (EglTestContext& eglTestCtx, EGLenum syncType, Extension extensions, const char* name, const char* description)
 105         : TestCase                      (eglTestCtx, name, description)
 106         , m_syncType            (syncType)
 107         , m_extensions          (extensions)
 108         , m_eglDisplay          (EGL_NO_DISPLAY)
 109         , m_eglSurface          (EGL_NO_SURFACE)
 110         , m_nativeWindow        (DE_NULL)
 111         , m_eglContext          (EGL_NO_CONTEXT)
 112         , m_sync                        (EGL_NO_SYNC_KHR)
 113 {
 114 }
 115
 116 SyncTest::~SyncTest (void)
 117 {
 118         SyncTest::deinit();
 119 }
 120
 121 void requiredEGLExtensions (const Library& egl, EGLDisplay display, SyncTest::Extension requiredExtensions)
 122 {
 123         SyncTest::Extension foundExtensions = SyncTest::EXTENSION_NONE;
 124         std::istringstream      extensionStream(egl.queryString(display, EGL_EXTENSIONS));
 125         string                          extension;
 126
 127         EGLU_CHECK_MSG(egl, "eglQueryString(display, EGL_EXTENSIONS)");
 128
 129         while (std::getline(extensionStream, extension, ' '))
 130         {
 131                 if (extension == "EGL_KHR_fence_sync")
 132                         foundExtensions = (SyncTest::Extension)(foundExtensions | SyncTest::EXTENSION_FENCE_SYNC);
 133                 else if (extension == "EGL_KHR_reusable_sync")
 134                         foundExtensions = (SyncTest::Extension)(foundExtensions | SyncTest::EXTENSION_REUSABLE_SYNC);
 135                 else if (extension == "EGL_KHR_wait_sync")
 136                         foundExtensions = (SyncTest::Extension)(foundExtensions | SyncTest::EXTENSION_WAIT_SYNC);
 137         }
 138
 139         {
 140                 const SyncTest::Extension missingExtensions = (SyncTest::Extension)((foundExtensions & requiredExtensions) ^ requiredExtensions);
 141
 142                 if ((missingExtensions & SyncTest::EXTENSION_FENCE_SYNC) != 0)
 143                         TCU_THROW(NotSupportedError, "EGL_KHR_fence_sync not supported");
 144
 145                 if ((missingExtensions & SyncTest::EXTENSION_REUSABLE_SYNC) != 0)
 146                         TCU_THROW(NotSupportedError, "EGL_KHR_reusable_sync not supported");
 147
 148                 if ((missingExtensions & SyncTest::EXTENSION_WAIT_SYNC) != 0)
 149                         TCU_THROW(NotSupportedError, "EGL_KHR_wait_sync not supported");
 150         }
 151 }
 152
 153 void requiredGLESExtensions (const glw::Functions& gl)
 154 {
 155         bool                            found = false;
 156         std::istringstream      extensionStream((const char*)gl.getString(GL_EXTENSIONS));
 157         string                          extension;
 158
 159         GLU_CHECK_GLW_MSG(gl, "glGetString(GL_EXTENSIONS)");
 160
 161         while (std::getline(extensionStream, extension, ' '))
 162         {
 163                 if (extension == "GL_OES_EGL_sync")
 164                         found = true;
 165         }
 166
 167         if (!found)
 168                 TCU_THROW(NotSupportedError, "GL_OES_EGL_sync not supported");
 169 }
 170
 171 SyncTest::Extension getSyncTypeExtension (EGLenum syncType)
 172 {
 173         switch (syncType)
 174         {
 175                 case EGL_SYNC_FENCE_KHR:        return SyncTest::EXTENSION_FENCE_SYNC;
 176                 case EGL_SYNC_REUSABLE_KHR:     return SyncTest::EXTENSION_REUSABLE_SYNC;
 177                 default:
 178                         DE_ASSERT(DE_FALSE);
 179                         return SyncTest::EXTENSION_NONE;
 180         }
 181 }
 182
 183 void SyncTest::init (void)
 184 {
 185         const Library&                                          egl                             = m_eglTestCtx.getLibrary();
 186         const eglu::NativeWindowFactory&        windowFactory   = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());
 187
 188         const EGLint displayAttribList[] =
 189         {
 190                 EGL_RENDERABLE_TYPE,    EGL_OPENGL_ES2_BIT,
 191                 EGL_SURFACE_TYPE,               EGL_WINDOW_BIT,
 192                 EGL_ALPHA_SIZE,                 1,
 193                 EGL_NONE
 194         };
 195
 196         const EGLint contextAttribList[] =
 197         {
 198                 EGL_CONTEXT_CLIENT_VERSION, 2,
 199                 EGL_NONE
 200         };
 201
 202         m_eglDisplay    = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
 203         m_eglConfig     = eglu::chooseSingleConfig(egl, m_eglDisplay, displayAttribList);
 204
 205         m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0));
 206
 207         {
 208                 const Extension syncTypeExtension = getSyncTypeExtension(m_syncType);
 209                 requiredEGLExtensions(egl, m_eglDisplay, (Extension)(m_extensions | syncTypeExtension));
 210         }
 211
 212         // Create context
 213         EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API));
 214         m_eglContext = egl.createContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, contextAttribList);
 215         EGLU_CHECK_MSG(egl, "Failed to create GLES2 context");
 216
 217         // Create surface
 218         m_nativeWindow = windowFactory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_eglDisplay, m_eglConfig, DE_NULL, eglu::WindowParams(480, 480, eglu::parseWindowVisibility(m_testCtx.getCommandLine())));
 219         m_eglSurface = eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *m_nativeWindow, m_eglDisplay, m_eglConfig, DE_NULL);
 220
 221         EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext));
 222
 223         requiredGLESExtensions(m_gl);
 224 }
 225
 226 void SyncTest::deinit (void)
 227 {
 228         const Library&  egl             = m_eglTestCtx.getLibrary();
 229
 230         if (m_eglDisplay != EGL_NO_DISPLAY)
 231         {
 232                 if (m_sync != EGL_NO_SYNC_KHR)
 233                 {
 234                         EGLU_CHECK_CALL(egl, destroySyncKHR(m_eglDisplay, m_sync));
 235                         m_sync = EGL_NO_SYNC_KHR;
 236                 }
 237
 238                 EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
 239
 240                 if (m_eglContext != EGL_NO_CONTEXT)
 241                 {
 242                         EGLU_CHECK_CALL(egl, destroyContext(m_eglDisplay, m_eglContext));
 243                         m_eglContext = EGL_NO_CONTEXT;
 244                 }
 245
 246                 if (m_eglSurface != EGL_NO_SURFACE)
 247                 {
 248                         EGLU_CHECK_CALL(egl, destroySurface(m_eglDisplay, m_eglSurface));
 249                         m_eglSurface = EGL_NO_SURFACE;
 250                 }
 251
 252                 delete m_nativeWindow;
 253                 m_nativeWindow = DE_NULL;
 254
 255                 egl.terminate(m_eglDisplay);
 256                 m_eglDisplay = EGL_NO_DISPLAY;
 257         }
 258 }
 259
 260 class CreateNullAttribsTest : public SyncTest
 261 {
 262 public:
 263                                         CreateNullAttribsTest   (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "create_null_attribs", "create_null_attribs") {}
 264
 265         IterateResult   iterate                                 (void)
 266         {
 267                 const Library&  egl             = m_eglTestCtx.getLibrary();
 268                 TestLog&                log             = m_testCtx.getLog();
 269
 270                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
 271                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 272                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
 273
 274                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 275                 return STOP;
 276         }
 277 };
 278
 279 class CreateEmptyAttribsTest : public SyncTest
 280 {
 281 public:
 282                                         CreateEmptyAttribsTest  (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "create_empty_attribs", "create_empty_attribs") {}
 283
 284         IterateResult   iterate                                 (void)
 285         {
 286
 287                 const Library&  egl                             = m_eglTestCtx.getLibrary();
 288                 TestLog&                log                             = m_testCtx.getLog();
 289                 const EGLint    attribList[]    =
 290                 {
 291                         EGL_NONE
 292                 };
 293
 294                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, attribList);
 295                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", { EGL_NONE })" << TestLog::EndMessage;
 296                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
 297
 298                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 299                 return STOP;
 300         }
 301 };
 302
 303 class CreateInvalidDisplayTest : public SyncTest
 304 {
 305 public:
 306                                         CreateInvalidDisplayTest        (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "create_invalid_display", "create_invalid_display") {}
 307
 308         IterateResult   iterate                                         (void)
 309         {
 310                 const Library&  egl             = m_eglTestCtx.getLibrary();
 311                 TestLog&                log             = m_testCtx.getLog();
 312
 313                 m_sync = egl.createSyncKHR(EGL_NO_DISPLAY, m_syncType, NULL);
 314                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(EGL_NO_DISPLAY, " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 315
 316                 EGLint error = egl.getError();
 317                 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
 318
 319                 if (error != EGL_BAD_DISPLAY)
 320                 {
 321                         log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_DISPLAY" << TestLog::EndMessage;
 322                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 323                         return STOP;
 324                 }
 325
 326                 TCU_CHECK(m_sync == EGL_NO_SYNC_KHR);
 327
 328                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 329                 return STOP;
 330         }
 331 };
 332
 333 class CreateInvalidTypeTest : public SyncTest
 334 {
 335 public:
 336                                         CreateInvalidTypeTest   (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "create_invalid_type", "create_invalid_type") {}
 337
 338         IterateResult   iterate                                 (void)
 339         {
 340                 const Library&  egl             = m_eglTestCtx.getLibrary();
 341                 TestLog&                log             = m_testCtx.getLog();
 342
 343                 m_sync = egl.createSyncKHR(m_eglDisplay, EGL_NONE, NULL);
 344                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", EGL_NONE, NULL)" << TestLog::EndMessage;
 345
 346                 EGLint error = egl.getError();
 347                 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
 348
 349                 if (error != EGL_BAD_ATTRIBUTE)
 350                 {
 351                         log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_ATTRIBUTE" << TestLog::EndMessage;
 352                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 353                         return STOP;
 354                 }
 355
 356                 TCU_CHECK(m_sync == EGL_NO_SYNC_KHR);
 357
 358                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 359                 return STOP;
 360         }
 361 };
 362
 363 class CreateInvalidAttribsTest : public SyncTest
 364 {
 365 public:
 366                                         CreateInvalidAttribsTest        (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "create_invalid_attribs", "create_invalid_attribs") {}
 367
 368         IterateResult   iterate                                         (void)
 369         {
 370                 const Library&  egl             = m_eglTestCtx.getLibrary();
 371                 TestLog&                log             = m_testCtx.getLog();
 372
 373                 EGLint attribs[] = {
 374                         2, 3, 4, 5,
 375                         EGL_NONE
 376                 };
 377
 378                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, attribs);
 379                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", { 2, 3, 4, 5, EGL_NONE })" << TestLog::EndMessage;
 380
 381                 EGLint error = egl.getError();
 382                 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
 383
 384                 if (error != EGL_BAD_ATTRIBUTE)
 385                 {
 386                         log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_ATTRIBUTE" << TestLog::EndMessage;
 387                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 388                         return STOP;
 389                 }
 390
 391                 TCU_CHECK(m_sync == EGL_NO_SYNC_KHR);
 392
 393                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 394                 return STOP;
 395         }
 396 };
 397
 398 class CreateInvalidContextTest : public SyncTest
 399 {
 400 public:
 401                                         CreateInvalidContextTest        (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "create_invalid_context", "create_invalid_context") {}
 402
 403         IterateResult   iterate                                         (void)
 404         {
 405                 const Library&  egl             = m_eglTestCtx.getLibrary();
 406                 TestLog&                log             = m_testCtx.getLog();
 407
 408                 log << TestLog::Message << "eglMakeCurrent(" << m_eglDisplay << ", EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)" << TestLog::EndMessage;
 409                 EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
 410
 411                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
 412                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 413
 414                 EGLint error = egl.getError();
 415                 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
 416
 417                 if (error != EGL_BAD_MATCH)
 418                 {
 419                         log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_MATCH" << TestLog::EndMessage;
 420                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 421                         return STOP;
 422                 }
 423
 424                 TCU_CHECK(m_sync == EGL_NO_SYNC_KHR);
 425
 426                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 427                 return STOP;
 428         }
 429 };
 430
 431 class ClientWaitNoTimeoutTest : public SyncTest
 432 {
 433 public:
 434                                         ClientWaitNoTimeoutTest (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "wait_no_timeout", "wait_no_timeout") {}
 435
 436         IterateResult   iterate                                 (void)
 437         {
 438                 const Library&  egl             = m_eglTestCtx.getLibrary();
 439                 TestLog&                log             = m_testCtx.getLog();
 440
 441                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
 442                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 443                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
 444
 445                 EGLint status = egl.clientWaitSyncKHR(m_eglDisplay, m_sync, 0, 0);
 446                 log << TestLog::Message << status << " = eglClientWaitSyncKHR(" << m_eglDisplay << ", " << m_sync << ", 0, 0)" << TestLog::EndMessage;
 447
 448                 if (m_syncType == EGL_SYNC_FENCE_KHR)
 449                         TCU_CHECK(status == EGL_CONDITION_SATISFIED_KHR || status == EGL_TIMEOUT_EXPIRED_KHR);
 450                 else if (m_syncType == EGL_SYNC_REUSABLE_KHR)
 451                         TCU_CHECK(status == EGL_TIMEOUT_EXPIRED_KHR);
 452                 else
 453                         DE_ASSERT(DE_FALSE);
 454
 455                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 456                 return STOP;
 457         }
 458
 459 };
 460
 461 class ClientWaitForeverTest : public SyncTest
 462 {
 463 public:
 464                                         ClientWaitForeverTest   (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "wait_forever", "wait_forever") {}
 465
 466         IterateResult   iterate                                 (void)
 467         {
 468                 const Library&  egl             = m_eglTestCtx.getLibrary();
 469                 TestLog&                log             = m_testCtx.getLog();
 470
 471                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
 472                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 473                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
 474
 475                 if (m_syncType == EGL_SYNC_REUSABLE_KHR)
 476                 {
 477                         EGLBoolean ret = egl.signalSyncKHR(m_eglDisplay, m_sync, EGL_SIGNALED_KHR);
 478                         log << TestLog::Message << ret << " = eglSignalSyncKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SIGNALED_KHR)" << TestLog::EndMessage;
 479                         EGLU_CHECK_MSG(egl, "eglSignalSyncKHR()");
 480                 }
 481                 else if (m_syncType == EGL_SYNC_FENCE_KHR)
 482                 {
 483                         GLU_CHECK_GLW_CALL(m_gl, flush());
 484                         log << TestLog::Message << "glFlush()" << TestLog::EndMessage;
 485                 }
 486                 else
 487                         DE_ASSERT(DE_FALSE);
 488
 489                 EGLint status = egl.clientWaitSyncKHR(m_eglDisplay, m_sync, 0, EGL_FOREVER_KHR);
 490                 log << TestLog::Message << status << " = eglClientWaitSyncKHR(" << m_eglDisplay << ", " << m_sync << ", 0, EGL_FOREVER_KHR)" << TestLog::EndMessage;
 491
 492                 TCU_CHECK(status == EGL_CONDITION_SATISFIED_KHR);
 493                 EGLU_CHECK_MSG(egl, "eglClientWaitSyncKHR()");
 494
 495                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 496                 return STOP;
 497         }
 498 };
 499
 500 class ClientWaitNoContextTest : public SyncTest
 501 {
 502 public:
 503                                         ClientWaitNoContextTest (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "wait_no_context", "wait_no_Context") {}
 504
 505         IterateResult   iterate                                 (void)
 506         {
 507                 const Library&  egl             = m_eglTestCtx.getLibrary();
 508                 TestLog&                log             = m_testCtx.getLog();
 509
 510                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
 511                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 512                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
 513
 514
 515                 if (m_syncType == EGL_SYNC_REUSABLE_KHR)
 516                 {
 517                         EGLBoolean ret = egl.signalSyncKHR(m_eglDisplay, m_sync, EGL_SIGNALED_KHR);
 518                         log << TestLog::Message << ret << " = eglSignalSyncKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SIGNALED_KHR)" << TestLog::EndMessage;
 519                         EGLU_CHECK_MSG(egl, "eglSignalSyncKHR()");
 520                 }
 521                 else if (m_syncType == EGL_SYNC_FENCE_KHR)
 522                 {
 523                         GLU_CHECK_GLW_CALL(m_gl, flush());
 524                         log << TestLog::Message << "glFlush()" << TestLog::EndMessage;
 525                 }
 526                 else
 527                         DE_ASSERT(DE_FALSE);
 528
 529                 log << TestLog::Message << "eglMakeCurrent(" << m_eglDisplay << ", EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)" << TestLog::EndMessage;
 530                 EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
 531
 532                 EGLint result = egl.clientWaitSyncKHR(m_eglDisplay, m_sync, 0, EGL_FOREVER_KHR);
 533                 log << TestLog::Message << result << " = eglClientWaitSyncKHR(" << m_eglDisplay << ", " << m_sync << ", 0, EGL_FOREVER_KHR)" << TestLog::EndMessage;
 534
 535                 TCU_CHECK(result == EGL_CONDITION_SATISFIED_KHR);
 536
 537                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 538                 return STOP;
 539         }
 540 };
 541
 542 class ClientWaitForeverFlushTest : public SyncTest
 543 {
 544 public:
 545                                         ClientWaitForeverFlushTest      (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "wait_forever_flush", "wait_forever_flush") {}
 546
 547         IterateResult   iterate                                         (void)
 548         {
 549                 const Library&  egl             = m_eglTestCtx.getLibrary();
 550                 TestLog&                log             = m_testCtx.getLog();
 551
 552                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
 553                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 554                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
 555
 556                 if (m_syncType == EGL_SYNC_REUSABLE_KHR)
 557                 {
 558                         EGLBoolean ret = egl.signalSyncKHR(m_eglDisplay, m_sync, EGL_SIGNALED_KHR);
 559                         log << TestLog::Message << ret << " = eglSignalSyncKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SIGNALED_KHR)" << TestLog::EndMessage;
 560                         EGLU_CHECK_MSG(egl, "eglSignalSyncKHR()");
 561                 }
 562
 563                 EGLint status = egl.clientWaitSyncKHR(m_eglDisplay, m_sync, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR);
 564                 log << TestLog::Message << status << " = eglClientWaitSyncKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR)" << TestLog::EndMessage;
 565
 566                 TCU_CHECK(status == EGL_CONDITION_SATISFIED_KHR);
 567
 568                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 569                 return STOP;
 570         }
 571 };
 572
 573 class ClientWaitInvalidDisplayTest : public SyncTest
 574 {
 575 public:
 576                                         ClientWaitInvalidDisplayTest    (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "wait_invalid_display", "wait_invalid_display") {}
 577
 578         IterateResult   iterate                                                 (void)
 579         {
 580                 const Library&  egl             = m_eglTestCtx.getLibrary();
 581                 TestLog&                log             = m_testCtx.getLog();
 582
 583                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
 584                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 585                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
 586
 587                 EGLint status = egl.clientWaitSyncKHR(EGL_NO_DISPLAY, m_sync, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR);
 588                 log << TestLog::Message << status << " = eglClientWaitSyncKHR(EGL_NO_DISPLAY, " << m_sync << ", EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR)" << TestLog::EndMessage;
 589
 590                 EGLint error = egl.getError();
 591                 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
 592
 593                 if (error != EGL_BAD_DISPLAY)
 594                 {
 595                         log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_DISPLAY" << TestLog::EndMessage;
 596                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 597                         return STOP;
 598                 }
 599
 600                 TCU_CHECK(status == EGL_FALSE);
 601
 602                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 603                 return STOP;
 604         }
 605 };
 606
 607 class ClientWaitInvalidSyncTest : public SyncTest
 608 {
 609 public:
 610                                         ClientWaitInvalidSyncTest       (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "wait_invalid_sync", "wait_invalid_sync") {}
 611
 612         IterateResult   iterate                                         (void)
 613         {
 614                 const Library&  egl             = m_eglTestCtx.getLibrary();
 615                 TestLog&                log             = m_testCtx.getLog();
 616
 617                 EGLint status = egl.clientWaitSyncKHR(m_eglDisplay, EGL_NO_SYNC_KHR, 0, EGL_FOREVER_KHR);
 618                 log << TestLog::Message << status << " = eglClientWaitSyncKHR(" << m_eglDisplay << ", EGL_NO_SYNC_KHR, 0, EGL_FOREVER_KHR)" << TestLog::EndMessage;
 619
 620                 EGLint error = egl.getError();
 621                 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
 622
 623                 if (error != EGL_BAD_PARAMETER)
 624                 {
 625                         log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage;
 626                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 627                         return STOP;
 628                 }
 629
 630                 TCU_CHECK(status == EGL_FALSE);
 631
 632                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 633                 return STOP;
 634         }
 635 };
 636
 637 class GetSyncTypeTest : public SyncTest
 638 {
 639 public:
 640                                         GetSyncTypeTest (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "get_type", "get_type") {}
 641
 642         IterateResult   iterate                 (void)
 643         {
 644                 const Library&  egl             = m_eglTestCtx.getLibrary();
 645                 TestLog&                log             = m_testCtx.getLog();
 646
 647                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
 648                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 649                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
 650
 651                 EGLint type = 0;
 652                 EGLU_CHECK_CALL(egl, getSyncAttribKHR(m_eglDisplay, m_sync, EGL_SYNC_TYPE_KHR, &type));
 653                 log << TestLog::Message << "eglGetSyncAttribKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SYNC_TYPE_KHR, {" << type << "})" << TestLog::EndMessage;
 654
 655                 TCU_CHECK(type == ((EGLint)m_syncType));
 656
 657                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 658                 return STOP;
 659         }
 660 };
 661
 662 class GetSyncStatusTest : public SyncTest
 663 {
 664 public:
 665                                         GetSyncStatusTest       (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "get_status", "get_status") {}
 666
 667         IterateResult   iterate                         (void)
 668         {
 669                 const Library&  egl             = m_eglTestCtx.getLibrary();
 670                 TestLog&                log             = m_testCtx.getLog();
 671
 672                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
 673                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 674                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
 675
 676                 EGLint status = 0;
 677                 EGLU_CHECK_CALL(egl, getSyncAttribKHR(m_eglDisplay, m_sync, EGL_SYNC_STATUS_KHR, &status));
 678                 log << TestLog::Message << "eglGetSyncAttribKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SYNC_STATUS_KHR, {" << status << "})" << TestLog::EndMessage;
 679
 680                 if (m_syncType == EGL_SYNC_FENCE_KHR)
 681                         TCU_CHECK(status == EGL_SIGNALED_KHR || status == EGL_UNSIGNALED_KHR);
 682                 else if (m_syncType == EGL_SYNC_REUSABLE_KHR)
 683                         TCU_CHECK(status == EGL_UNSIGNALED_KHR);
 684
 685                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 686                 return STOP;
 687         }
 688 };
 689
 690 class GetSyncStatusSignaledTest : public SyncTest
 691 {
 692 public:
 693                                         GetSyncStatusSignaledTest       (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "get_status_signaled", "get_status_signaled") {}
 694
 695         IterateResult   iterate                                         (void)
 696         {
 697                 const Library&  egl             = m_eglTestCtx.getLibrary();
 698                 TestLog&                log             = m_testCtx.getLog();
 699
 700                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
 701                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 702                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
 703
 704                 if (m_syncType == EGL_SYNC_REUSABLE_KHR)
 705                 {
 706                         EGLBoolean ret = egl.signalSyncKHR(m_eglDisplay, m_sync, EGL_SIGNALED_KHR);
 707                         log << TestLog::Message << ret << " = eglSignalSyncKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SIGNALED_KHR)" << TestLog::EndMessage;
 708                         EGLU_CHECK_MSG(egl, "eglSignalSyncKHR()");
 709                 }
 710                 else if (m_syncType == EGL_SYNC_FENCE_KHR)
 711                 {
 712                         GLU_CHECK_GLW_CALL(m_gl, finish());
 713                         log << TestLog::Message << "glFinish()" << TestLog::EndMessage;
 714                 }
 715                 else
 716                         DE_ASSERT(DE_FALSE);
 717
 718                 {
 719                         EGLint status = egl.clientWaitSyncKHR(m_eglDisplay, m_sync, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR);
 720                         log << TestLog::Message << status << " = eglClientWaitSyncKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR)" << TestLog::EndMessage;
 721                         TCU_CHECK(status == EGL_CONDITION_SATISFIED_KHR);
 722                 }
 723
 724                 EGLint status = 0;
 725                 EGLU_CHECK_CALL(egl, getSyncAttribKHR(m_eglDisplay, m_sync, EGL_SYNC_STATUS_KHR, &status));
 726                 log << TestLog::Message << "eglGetSyncAttribKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SYNC_STATUS_KHR, {" << status << "})" << TestLog::EndMessage;
 727
 728                 TCU_CHECK(status == EGL_SIGNALED_KHR);
 729
 730                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 731                 return STOP;
 732         }
 733 };
 734
 735 class GetSyncConditionTest : public SyncTest
 736 {
 737 public:
 738                                         GetSyncConditionTest    (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "get_condition", "get_condition") {}
 739
 740         IterateResult   iterate                                 (void)
 741         {
 742                 const Library&  egl             = m_eglTestCtx.getLibrary();
 743                 TestLog&                log             = m_testCtx.getLog();
 744
 745                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
 746                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 747                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
 748
 749                 EGLint condition = 0;
 750                 EGLU_CHECK_CALL(egl, getSyncAttribKHR(m_eglDisplay, m_sync, EGL_SYNC_CONDITION_KHR, &condition));
 751                 log << TestLog::Message << "eglGetSyncAttribKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SYNC_CONDITION_KHR, {" << condition << "})" << TestLog::EndMessage;
 752
 753                 TCU_CHECK(condition == EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR);
 754
 755                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 756                 return STOP;
 757         }
 758 };
 759
 760 class GetSyncInvalidDisplayTest : public SyncTest
 761 {
 762 public:
 763                                         GetSyncInvalidDisplayTest       (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "get_invalid_display", "get_invalid_display") {}
 764
 765         IterateResult   iterate                                         (void)
 766         {
 767                 const Library&  egl             = m_eglTestCtx.getLibrary();
 768                 TestLog&                log             = m_testCtx.getLog();
 769
 770                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
 771                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 772                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
 773
 774                 EGLint condition = 0xF0F0F;
 775                 EGLBoolean result = egl.getSyncAttribKHR(EGL_NO_DISPLAY, m_sync, EGL_SYNC_CONDITION_KHR, &condition);
 776                 log << TestLog::Message << result << " = eglGetSyncAttribKHR(EGL_NO_DISPLAY, " << m_sync << ", EGL_SYNC_CONDITION_KHR, {" << condition << "})" << TestLog::EndMessage;
 777
 778                 EGLint error = egl.getError();
 779                 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
 780
 781                 if (error != EGL_BAD_DISPLAY)
 782                 {
 783                         log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_DISPLAY" << TestLog::EndMessage;
 784                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 785                         return STOP;
 786                 }
 787
 788                 TCU_CHECK(result == EGL_FALSE);
 789                 TCU_CHECK(condition == 0xF0F0F);
 790
 791                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 792                 return STOP;
 793         }
 794 };
 795
 796 class GetSyncInvalidSyncTest : public SyncTest
 797 {
 798 public:
 799                                         GetSyncInvalidSyncTest  (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "get_invalid_sync", "get_invalid_sync") {}
 800
 801         IterateResult   iterate                                 (void)
 802         {
 803                 const Library&  egl             = m_eglTestCtx.getLibrary();
 804                 TestLog&                log             = m_testCtx.getLog();
 805
 806                 EGLint condition = 0xF0F0F;
 807                 EGLBoolean result = egl.getSyncAttribKHR(m_eglDisplay, EGL_NO_SYNC_KHR, EGL_SYNC_CONDITION_KHR, &condition);
 808                 log << TestLog::Message << result << " = eglGetSyncAttribKHR(" << m_eglDisplay << ", EGL_NO_SYNC_KHR, EGL_SYNC_CONDITION_KHR, {" << condition << "})" << TestLog::EndMessage;
 809
 810                 EGLint error = egl.getError();
 811                 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
 812
 813                 if (error != EGL_BAD_PARAMETER)
 814                 {
 815                         log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage;
 816                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 817                         return STOP;
 818                 }
 819
 820                 TCU_CHECK(result == EGL_FALSE);
 821                 TCU_CHECK(condition == 0xF0F0F);
 822
 823                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 824                 return STOP;
 825         }
 826 };
 827
 828 class GetSyncInvalidAttributeTest : public SyncTest
 829 {
 830 public:
 831                                         GetSyncInvalidAttributeTest     (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "get_invalid_attribute", "get_invalid_attribute") {}
 832
 833         IterateResult   iterate                                         (void)
 834         {
 835                 const Library&  egl             = m_eglTestCtx.getLibrary();
 836                 TestLog&                log             = m_testCtx.getLog();
 837
 838                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
 839                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 840                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
 841
 842                 EGLint condition = 0xF0F0F;
 843                 EGLBoolean result = egl.getSyncAttribKHR(m_eglDisplay, m_sync, EGL_NONE, &condition);
 844                 log << TestLog::Message << result << " = eglGetSyncAttribKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_NONE, {" << condition << "})" << TestLog::EndMessage;
 845
 846                 EGLint error = egl.getError();
 847                 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
 848
 849                 if (error != EGL_BAD_ATTRIBUTE)
 850                 {
 851                         log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_ATTRIBUTE" << TestLog::EndMessage;
 852                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 853                         return STOP;
 854                 }
 855
 856                 TCU_CHECK(result == EGL_FALSE);
 857                 TCU_CHECK(condition == 0xF0F0F);
 858
 859                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 860                 return STOP;
 861         }
 862 };
 863
 864 class GetSyncInvalidValueTest : public SyncTest
 865 {
 866 public:
 867                                         GetSyncInvalidValueTest (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "get_invalid_value", "get_invalid_value") {}
 868
 869         IterateResult   iterate                                 (void)
 870         {
 871                 const Library&  egl             = m_eglTestCtx.getLibrary();
 872                 TestLog&                log             = m_testCtx.getLog();
 873
 874                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
 875                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 876                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
 877
 878                 EGLBoolean result = egl.getSyncAttribKHR(m_eglDisplay, m_sync, EGL_SYNC_TYPE_KHR, NULL);
 879                 log << TestLog::Message << result << " = eglGetSyncAttribKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SYNC_CONDITION_KHR, NULL)" << TestLog::EndMessage;
 880
 881                 EGLint error = egl.getError();
 882                 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
 883
 884                 if (error != EGL_BAD_PARAMETER)
 885                 {
 886                         log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage;
 887                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 888                         return STOP;
 889                 }
 890
 891                 TCU_CHECK(result == EGL_FALSE);
 892
 893                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 894                 return STOP;
 895         }
 896 };
 897
 898 class DestroySyncTest : public SyncTest
 899 {
 900 public:
 901                                         DestroySyncTest (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "destroy", "destroy") {}
 902
 903         IterateResult   iterate                 (void)
 904         {
 905                 const Library&  egl             = m_eglTestCtx.getLibrary();
 906                 TestLog&                log             = m_testCtx.getLog();
 907
 908                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
 909                 log << TestLog::Message << "eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 910                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
 911
 912                 log << TestLog::Message << "eglDestroySyncKHR(" << m_eglDisplay << ", " << m_sync << ")" << TestLog::EndMessage;
 913                 EGLU_CHECK_CALL(egl, destroySyncKHR(m_eglDisplay, m_sync));
 914                 m_sync = EGL_NO_SYNC_KHR;
 915
 916                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 917                 return STOP;
 918         }
 919 };
 920
 921 class DestroySyncInvalidDislayTest : public SyncTest
 922 {
 923 public:
 924                                         DestroySyncInvalidDislayTest    (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "destroy_invalid_display", "destroy_invalid_display") {}
 925
 926         IterateResult   iterate                                                 (void)
 927         {
 928                 const Library&  egl             = m_eglTestCtx.getLibrary();
 929                 TestLog&                log             = m_testCtx.getLog();
 930
 931                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
 932                 log << TestLog::Message << "eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 933                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
 934
 935                 EGLBoolean result = egl.destroySyncKHR(EGL_NO_DISPLAY, m_sync);
 936                 log << TestLog::Message << result << " = eglDestroySyncKHR(EGL_NO_DISPLAY, " << m_sync << ")" << TestLog::EndMessage;
 937
 938                 EGLint error = egl.getError();
 939                 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
 940
 941                 if (error != EGL_BAD_DISPLAY)
 942                 {
 943                         log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_DISPLAY" << TestLog::EndMessage;
 944                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 945                         return STOP;
 946                 }
 947
 948                 TCU_CHECK(result == EGL_FALSE);
 949
 950                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 951                 return STOP;
 952         }
 953 };
 954
 955 class DestroySyncInvalidSyncTest : public SyncTest
 956 {
 957 public:
 958                                         DestroySyncInvalidSyncTest      (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, "destroy_invalid_sync", "destroy_invalid_sync") {}
 959
 960         IterateResult   iterate                                         (void)
 961         {
 962                 const Library&  egl             = m_eglTestCtx.getLibrary();
 963                 TestLog&                log             = m_testCtx.getLog();
 964
 965                 EGLBoolean result = egl.destroySyncKHR(m_eglDisplay, EGL_NO_SYNC_KHR);
 966                 log << TestLog::Message << result << " = eglDestroySyncKHR(" << m_eglDisplay << ", EGL_NO_SYNC_KHR)" << TestLog::EndMessage;
 967
 968                 EGLint error = egl.getError();
 969                 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
 970
 971                 if (error != EGL_BAD_PARAMETER)
 972                 {
 973                         log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage;
 974                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 975                         return STOP;
 976                 }
 977
 978                 TCU_CHECK(result == EGL_FALSE);
 979
 980                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 981                 return STOP;
 982         }
 983 };
 984
 985 class WaitSyncTest : public SyncTest
 986 {
 987 public:
 988                                         WaitSyncTest    (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_WAIT_SYNC, "wait_server", "wait_server") {}
 989
 990         IterateResult   iterate                 (void)
 991         {
 992                 const Library&  egl             = m_eglTestCtx.getLibrary();
 993                 TestLog&                log             = m_testCtx.getLog();
 994
 995                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
 996                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
 997                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
 998
 999                 EGLint status = egl.waitSyncKHR(m_eglDisplay, m_sync, 0);
1000                 log << TestLog::Message << status << " = eglWaitSyncKHR(" << m_eglDisplay << ", " << m_sync << ", 0, 0)" << TestLog::EndMessage;
1001
1002                 TCU_CHECK(status == EGL_TRUE);
1003
1004                 GLU_CHECK_GLW_CALL(m_gl, finish());
1005
1006                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1007                 return STOP;
1008         }
1009
1010 };
1011
1012 class WaitSyncInvalidDisplayTest : public SyncTest
1013 {
1014 public:
1015                                         WaitSyncInvalidDisplayTest      (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_WAIT_SYNC, "wait_server_invalid_display", "wait_server_invalid_display") {}
1016
1017         IterateResult   iterate                                         (void)
1018         {
1019                 const Library&  egl             = m_eglTestCtx.getLibrary();
1020                 TestLog&                log             = m_testCtx.getLog();
1021
1022                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
1023                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
1024                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
1025
1026                 EGLint status = egl.waitSyncKHR(EGL_NO_DISPLAY, m_sync, 0);
1027                 log << TestLog::Message << status << " = eglWaitSyncKHR(EGL_NO_DISPLAY, " << m_sync << ", 0)" << TestLog::EndMessage;
1028
1029                 EGLint error = egl.getError();
1030                 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
1031
1032                 if (error != EGL_BAD_DISPLAY)
1033                 {
1034                         log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_DISPLAY" << TestLog::EndMessage;
1035                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1036                         return STOP;
1037                 }
1038
1039                 TCU_CHECK(status == EGL_FALSE);
1040
1041                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1042                 return STOP;
1043         }
1044 };
1045
1046 class WaitSyncInvalidSyncTest : public SyncTest
1047 {
1048 public:
1049                                         WaitSyncInvalidSyncTest (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_WAIT_SYNC, "wait_server_invalid_sync", "wait_server_invalid_sync") {}
1050
1051         IterateResult   iterate                                 (void)
1052         {
1053                 const Library&  egl             = m_eglTestCtx.getLibrary();
1054                 TestLog&                log             = m_testCtx.getLog();
1055
1056                 EGLint status = egl.waitSyncKHR(m_eglDisplay, EGL_NO_SYNC_KHR, 0);
1057                 log << TestLog::Message << status << " = eglWaitSyncKHR(" << m_eglDisplay << ", EGL_NO_SYNC_KHR, 0)" << TestLog::EndMessage;
1058
1059                 EGLint error = egl.getError();
1060                 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
1061
1062                 if (error != EGL_BAD_PARAMETER)
1063                 {
1064                         log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage;
1065                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1066                         return STOP;
1067                 }
1068
1069                 TCU_CHECK(status == EGL_FALSE);
1070
1071                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1072                 return STOP;
1073         }
1074 };
1075
1076 class WaitSyncInvalidFlagTest : public SyncTest
1077 {
1078 public:
1079                                         WaitSyncInvalidFlagTest (EglTestContext& eglTestCtx, EGLenum syncType) : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_WAIT_SYNC, "wait_server_invalid_flag", "wait_server_invalid_flag") {}
1080
1081         IterateResult   iterate                                 (void)
1082         {
1083                 const Library&  egl             = m_eglTestCtx.getLibrary();
1084                 TestLog&                log             = m_testCtx.getLog();
1085
1086                 m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL);
1087                 log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage;
1088                 EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()");
1089
1090                 EGLint status = egl.waitSyncKHR(m_eglDisplay, m_sync, 0xFFFFFFFF);
1091                 log << TestLog::Message << status << " = eglWaitSyncKHR(" << m_eglDisplay << ", " << m_sync << ", 0xFFFFFFFF)" << TestLog::EndMessage;
1092
1093                 EGLint error = egl.getError();
1094                 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
1095
1096                 if (error != EGL_BAD_PARAMETER)
1097                 {
1098                         log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage;
1099                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1100                         return STOP;
1101                 }
1102
1103                 TCU_CHECK(status == EGL_FALSE);
1104
1105                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1106                 return STOP;
1107         }
1108 };
1109
1110 } // anonymous
1111
1112 FenceSyncTests::FenceSyncTests (EglTestContext& eglTestCtx)
1113         : TestCaseGroup (eglTestCtx, "fence_sync", "EGL_KHR_fence_sync extension tests")
1114 {
1115 }
1116
1117 void FenceSyncTests::init (void)
1118 {
1119         // Add valid API test
1120         {
1121                 TestCaseGroup* const valid = new TestCaseGroup(m_eglTestCtx, "valid", "Valid function calls");
1122
1123                 // eglCreateSyncKHR tests
1124                 valid->addChild(new CreateNullAttribsTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1125                 valid->addChild(new CreateEmptyAttribsTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1126
1127                 // eglClientWaitSyncKHR tests
1128                 valid->addChild(new ClientWaitNoTimeoutTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1129                 valid->addChild(new ClientWaitForeverTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1130                 valid->addChild(new ClientWaitNoContextTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1131                 valid->addChild(new ClientWaitForeverFlushTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1132
1133                 // eglGetSyncAttribKHR tests
1134                 valid->addChild(new GetSyncTypeTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1135                 valid->addChild(new GetSyncStatusTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1136                 valid->addChild(new GetSyncStatusSignaledTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1137                 valid->addChild(new GetSyncConditionTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1138
1139                 // eglDestroySyncKHR tests
1140                 valid->addChild(new DestroySyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1141
1142                 // eglWaitSyncKHR tests
1143                 valid->addChild(new WaitSyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1144
1145                 addChild(valid);
1146         }
1147
1148         // Add negative API tests
1149         {
1150                 TestCaseGroup* const invalid = new TestCaseGroup(m_eglTestCtx, "invalid", "Invalid function calls");
1151
1152                 // eglCreateSyncKHR tests
1153                 invalid->addChild(new CreateInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1154                 invalid->addChild(new CreateInvalidTypeTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1155                 invalid->addChild(new CreateInvalidAttribsTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1156                 invalid->addChild(new CreateInvalidContextTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1157
1158                 // eglClientWaitSyncKHR tests
1159                 invalid->addChild(new ClientWaitInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1160                 invalid->addChild(new ClientWaitInvalidSyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1161
1162                 // eglGetSyncAttribKHR tests
1163                 invalid->addChild(new GetSyncInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1164                 invalid->addChild(new GetSyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1165                 invalid->addChild(new GetSyncInvalidAttributeTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1166                 invalid->addChild(new GetSyncInvalidValueTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1167
1168                 // eglDestroySyncKHR tests
1169                 invalid->addChild(new DestroySyncInvalidDislayTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1170                 invalid->addChild(new DestroySyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1171
1172                 // eglWaitSyncKHR tests
1173                 invalid->addChild(new WaitSyncInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1174                 invalid->addChild(new WaitSyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1175                 invalid->addChild(new WaitSyncInvalidFlagTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
1176
1177                 addChild(invalid);
1178         }
1179 }
1180
1181 ReusableSyncTests::ReusableSyncTests (EglTestContext& eglTestCtx)
1182         : TestCaseGroup (eglTestCtx, "reusable_sync", "EGL_KHR_reusable_sync extension tests")
1183 {
1184 }
1185
1186 void ReusableSyncTests::init (void)
1187 {
1188         // Add valid API test
1189         {
1190                 TestCaseGroup* const valid = new TestCaseGroup(m_eglTestCtx, "valid", "Valid function calls");
1191
1192                 // eglCreateSyncKHR tests
1193                 valid->addChild(new CreateNullAttribsTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1194                 valid->addChild(new CreateEmptyAttribsTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1195
1196                 // eglClientWaitSyncKHR tests
1197                 valid->addChild(new ClientWaitNoTimeoutTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1198                 valid->addChild(new ClientWaitForeverTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1199                 valid->addChild(new ClientWaitNoContextTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1200                 valid->addChild(new ClientWaitForeverFlushTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1201
1202                 // eglGetSyncAttribKHR tests
1203                 valid->addChild(new GetSyncTypeTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1204                 valid->addChild(new GetSyncStatusTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1205                 valid->addChild(new GetSyncStatusSignaledTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1206
1207                 // eglDestroySyncKHR tests
1208                 valid->addChild(new DestroySyncTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1209
1210                 // eglWaitSyncKHR tests
1211                 valid->addChild(new WaitSyncTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1212
1213                 addChild(valid);
1214         }
1215
1216         // Add negative API tests
1217         {
1218                 TestCaseGroup* const invalid = new TestCaseGroup(m_eglTestCtx, "invalid", "Invalid function calls");
1219
1220                 // eglCreateSyncKHR tests
1221                 invalid->addChild(new CreateInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1222                 invalid->addChild(new CreateInvalidTypeTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1223                 invalid->addChild(new CreateInvalidAttribsTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1224
1225                 // eglClientWaitSyncKHR tests
1226                 invalid->addChild(new ClientWaitInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1227                 invalid->addChild(new ClientWaitInvalidSyncTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1228
1229                 // eglGetSyncAttribKHR tests
1230                 invalid->addChild(new GetSyncInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1231                 invalid->addChild(new GetSyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1232                 invalid->addChild(new GetSyncInvalidAttributeTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1233                 invalid->addChild(new GetSyncInvalidValueTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1234
1235                 // eglDestroySyncKHR tests
1236                 invalid->addChild(new DestroySyncInvalidDislayTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1237                 invalid->addChild(new DestroySyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1238
1239                 // eglWaitSyncKHR tests
1240                 invalid->addChild(new WaitSyncInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1241                 invalid->addChild(new WaitSyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1242                 invalid->addChild(new WaitSyncInvalidFlagTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
1243
1244                 addChild(invalid);
1245         }
1246 }
1247
1248 } // egl
1249 } // deqp