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 "deStringUtil.hpp"
27
28 #include "egluNativeWindow.hpp"
29 #include "egluStrUtil.hpp"
30 #include "egluUtil.hpp"
31
32 #include "eglwLibrary.hpp"
33 #include "eglwEnums.hpp"
34
35 #include "tcuTestLog.hpp"
36 #include "tcuCommandLine.hpp"
37
38 #include "gluDefs.hpp"
39
40 #include "glwFunctions.hpp"
41 #include "glwEnums.hpp"
42
43 #include <vector>
44 #include <string>
45 #include <sstream>
46 #include <set>
47
48 using std::vector;
49 using std::string;
50 using std::set;
51
52 using tcu::TestLog;
53
54 using namespace eglw;
55 using namespace glw;
56
57 namespace deqp
58 {
59 namespace egl
60 {
61
getSyncTypeName(EGLenum syncType)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 typedef EGLSync (Library::*createSync)(EGLDisplay, EGLenum, const EGLAttrib *) const ;
78 typedef EGLSyncKHR (Library::*createSyncKHR)(EGLDisplay, EGLenum, const EGLint *) const ;
79 typedef EGLint (Library::*clientWaitSync)(EGLDisplay, EGLSync, EGLint, EGLTime) const ;
80 typedef EGLint (Library::*clientWaitSyncKHR)(EGLDisplay, EGLSyncKHR, EGLint, EGLTimeKHR) const ;
81 typedef EGLBoolean (Library::*getSyncAttrib)(EGLDisplay, EGLSync, EGLint, EGLAttrib *) const ;
82 typedef EGLBoolean (Library::*getSyncAttribKHR)(EGLDisplay, EGLSyncKHR, EGLint, EGLint *) const ;
83 typedef EGLBoolean (Library::*destroySync)(EGLDisplay, EGLSync) const ;
84 typedef EGLBoolean (Library::*destroySyncKHR)(EGLDisplay, EGLSyncKHR) const ;
85 typedef EGLBoolean (Library::*waitSync)(EGLDisplay, EGLSync, EGLint) const ;
86 typedef EGLint (Library::*waitSyncKHR)(EGLDisplay, EGLSyncKHR, EGLint) const ;
87
88 enum FunctionName
89 {
90 FUNC_NAME_CREATE_SYNC,
91 FUNC_NAME_CLIENT_WAIT_SYNC,
92 FUNC_NAME_GET_SYNC_ATTRIB,
93 FUNC_NAME_DESTROY_SYNC,
94 FUNC_NAME_WAIT_SYNC,
95 FUNC_NAME_NUM_NAMES
96 };
97
98 enum Extension
99 {
100 EXTENSION_NONE = 0,
101 EXTENSION_WAIT_SYNC = (0x1 << 0),
102 EXTENSION_FENCE_SYNC = (0x1 << 1),
103 EXTENSION_REUSABLE_SYNC = (0x1 << 2)
104 };
105 SyncTest (EglTestContext& eglTestCtx, EGLenum syncType, Extension extensions, bool useCurrentContext, const char* name, const char* description);
106 virtual ~SyncTest (void);
107
108 void init (void);
109 void deinit (void);
110 bool hasRequiredEGLVersion(int requiredMajor, int requiredMinor);
111 bool hasEGLFenceSyncExtension(void);
112 bool hasEGLWaitSyncExtension(void);
getEglDisplay()113 EGLDisplay getEglDisplay() {return m_eglDisplay;}
114
115 protected:
116 const EGLenum m_syncType;
117 const bool m_useCurrentContext;
118
119 glw::Functions m_gl;
120
121 Extension m_extensions;
122 EGLDisplay m_eglDisplay;
123 EGLConfig m_eglConfig;
124 EGLSurface m_eglSurface;
125 eglu::NativeWindow* m_nativeWindow;
126 EGLContext m_eglContext;
127 EGLSyncKHR m_sync;
128 string m_funcNames[FUNC_NAME_NUM_NAMES];
129 string m_funcNamesKHR[FUNC_NAME_NUM_NAMES];
130 };
131
SyncTest(EglTestContext & eglTestCtx,EGLenum syncType,Extension extensions,bool useCurrentContext,const char * name,const char * description)132 SyncTest::SyncTest (EglTestContext& eglTestCtx, EGLenum syncType, Extension extensions, bool useCurrentContext, const char* name, const char* description)
133 : TestCase (eglTestCtx, name, description)
134 , m_syncType (syncType)
135 , m_useCurrentContext (useCurrentContext)
136 , m_extensions (extensions)
137 , m_eglDisplay (EGL_NO_DISPLAY)
138 , m_eglConfig (((eglw::EGLConfig)0)) // EGL_NO_CONFIG
139 , m_eglSurface (EGL_NO_SURFACE)
140 , m_nativeWindow (DE_NULL)
141 , m_eglContext (EGL_NO_CONTEXT)
142 , m_sync (EGL_NO_SYNC_KHR)
143 {
144 m_funcNames[FUNC_NAME_CREATE_SYNC] = "eglCreateSync";
145 m_funcNames[FUNC_NAME_CLIENT_WAIT_SYNC] = "eglClientWaitSync";
146 m_funcNames[FUNC_NAME_GET_SYNC_ATTRIB] = "eglGetSyncAttrib";
147 m_funcNames[FUNC_NAME_DESTROY_SYNC] = "eglDestroySync";
148 m_funcNames[FUNC_NAME_WAIT_SYNC] = "eglWaitSync";
149
150 m_funcNamesKHR[FUNC_NAME_CREATE_SYNC] = "eglCreateSyncKHR";
151 m_funcNamesKHR[FUNC_NAME_CLIENT_WAIT_SYNC] = "eglClientWaitSyncKHR";
152 m_funcNamesKHR[FUNC_NAME_GET_SYNC_ATTRIB] = "eglGetSyncAttribKHR";
153 m_funcNamesKHR[FUNC_NAME_DESTROY_SYNC] = "eglDestroySyncKHR";
154 m_funcNamesKHR[FUNC_NAME_WAIT_SYNC] = "eglWaitSyncKHR";
155 }
156
~SyncTest(void)157 SyncTest::~SyncTest (void)
158 {
159 SyncTest::deinit();
160 }
161
hasRequiredEGLVersion(int requiredMajor,int requiredMinor)162 bool SyncTest::hasRequiredEGLVersion (int requiredMajor, int requiredMinor)
163 {
164 const Library& egl = m_eglTestCtx.getLibrary();
165 TestLog& log = m_testCtx.getLog();
166 eglu::Version version = eglu::getVersion(egl, m_eglDisplay);
167
168 if (version < eglu::Version(requiredMajor, requiredMinor))
169 {
170 log << TestLog::Message << "Required EGL version is not supported. "
171 "Has: " << version.getMajor() << "." << version.getMinor()
172 << ", Required: " << requiredMajor << "." << requiredMinor << TestLog::EndMessage;
173 return false;
174 }
175
176 return true;
177 }
178
hasEGLFenceSyncExtension(void)179 bool SyncTest::hasEGLFenceSyncExtension (void)
180 {
181 TestLog& log = m_testCtx.getLog();
182
183 if (!eglu::hasExtension(m_eglTestCtx.getLibrary(), m_eglDisplay, "EGL_KHR_fence_sync"))
184 {
185 log << TestLog::Message << "EGL_KHR_fence_sync not supported" << TestLog::EndMessage;
186 return false;
187 }
188
189 return true;
190 }
191
hasEGLWaitSyncExtension(void)192 bool SyncTest::hasEGLWaitSyncExtension (void)
193 {
194 TestLog& log = m_testCtx.getLog();
195
196 if (!eglu::hasExtension(m_eglTestCtx.getLibrary(), m_eglDisplay, "EGL_KHR_wait_sync"))
197 {
198 log << TestLog::Message << "EGL_KHR_wait_sync not supported" << TestLog::EndMessage;
199 return false;
200 }
201
202 return true;
203 }
204
requiredGLESExtensions(const glw::Functions & gl)205 void requiredGLESExtensions (const glw::Functions& gl)
206 {
207 bool found = false;
208 std::istringstream extensionStream((const char*)gl.getString(GL_EXTENSIONS));
209 string extension;
210
211 GLU_CHECK_GLW_MSG(gl, "glGetString(GL_EXTENSIONS)");
212
213 while (std::getline(extensionStream, extension, ' '))
214 {
215 if (extension == "GL_OES_EGL_sync")
216 found = true;
217 }
218
219 if (!found)
220 TCU_THROW(NotSupportedError, "GL_OES_EGL_sync not supported");
221 }
222
getSyncTypeExtension(EGLenum syncType)223 SyncTest::Extension getSyncTypeExtension (EGLenum syncType)
224 {
225 switch (syncType)
226 {
227 case EGL_SYNC_FENCE_KHR: return SyncTest::EXTENSION_FENCE_SYNC;
228 case EGL_SYNC_REUSABLE_KHR: return SyncTest::EXTENSION_REUSABLE_SYNC;
229 default:
230 DE_ASSERT(DE_FALSE);
231 return SyncTest::EXTENSION_NONE;
232 }
233 }
234
init(void)235 void SyncTest::init (void)
236 {
237 const Library& egl = m_eglTestCtx.getLibrary();
238 const eglu::NativeWindowFactory& windowFactory = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());
239
240 const EGLint displayAttribList[] =
241 {
242 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
243 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
244 EGL_ALPHA_SIZE, 1,
245 EGL_NONE
246 };
247
248 const EGLint contextAttribList[] =
249 {
250 EGL_CONTEXT_CLIENT_VERSION, 2,
251 EGL_NONE
252 };
253
254 m_eglDisplay = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
255 m_eglConfig = eglu::chooseSingleConfig(egl, m_eglDisplay, displayAttribList);
256
257 m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0));
258
259 m_extensions = (Extension)(m_extensions | getSyncTypeExtension(m_syncType));
260
261 if (m_useCurrentContext)
262 {
263 // Create context
264 EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API));
265 m_eglContext = egl.createContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, contextAttribList);
266 EGLU_CHECK_MSG(egl, "Failed to create GLES2 context");
267
268 // Create surface
269 m_nativeWindow = windowFactory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_eglDisplay, m_eglConfig, DE_NULL, eglu::WindowParams(480, 480, eglu::parseWindowVisibility(m_testCtx.getCommandLine())));
270 m_eglSurface = eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *m_nativeWindow, m_eglDisplay, m_eglConfig, DE_NULL);
271
272 EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext));
273
274 requiredGLESExtensions(m_gl);
275 }
276
277 // Verify EXTENSION_REUSABLE_SYNC is supported before running the tests
278 if (m_syncType == EGL_SYNC_REUSABLE_KHR) {
279 if (!eglu::hasExtension(m_eglTestCtx.getLibrary(), m_eglDisplay, "EGL_KHR_reusable_sync"))
280 {
281 TCU_THROW(NotSupportedError, "EGL_KHR_reusable_sync not supported");
282 }
283 }
284 }
285
deinit(void)286 void SyncTest::deinit (void)
287 {
288 const Library& egl = m_eglTestCtx.getLibrary();
289
290 if (m_eglDisplay != EGL_NO_DISPLAY)
291 {
292 if (m_sync != EGL_NO_SYNC_KHR)
293 {
294 EGLU_CHECK_CALL(egl, destroySyncKHR(m_eglDisplay, m_sync));
295 m_sync = EGL_NO_SYNC_KHR;
296 }
297
298 EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
299
300 if (m_eglContext != EGL_NO_CONTEXT)
301 {
302 EGLU_CHECK_CALL(egl, destroyContext(m_eglDisplay, m_eglContext));
303 m_eglContext = EGL_NO_CONTEXT;
304 }
305
306 if (m_eglSurface != EGL_NO_SURFACE)
307 {
308 EGLU_CHECK_CALL(egl, destroySurface(m_eglDisplay, m_eglSurface));
309 m_eglSurface = EGL_NO_SURFACE;
310 }
311
312 delete m_nativeWindow;
313 m_nativeWindow = DE_NULL;
314
315 egl.terminate(m_eglDisplay);
316 m_eglDisplay = EGL_NO_DISPLAY;
317 }
318 }
319
320 class CreateNullAttribsTest : public SyncTest
321 {
322 public:
CreateNullAttribsTest(EglTestContext & eglTestCtx,EGLenum syncType)323 CreateNullAttribsTest (EglTestContext& eglTestCtx, EGLenum syncType)
324 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "create_null_attribs", "create_null_attribs")
325 {
326 }
327
328 template <typename createSyncFuncType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc)329 void test(string funcNames[FUNC_NAME_NUM_NAMES],
330 createSyncFuncType createSyncFunc)
331 {
332 // Reset before each test
333 deinit();
334 init();
335
336 const Library& egl = m_eglTestCtx.getLibrary();
337 TestLog& log = m_testCtx.getLog();
338 string msgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
339
340 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
341 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] << "(" <<
342 m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
343 TestLog::EndMessage;
344 EGLU_CHECK_MSG(egl, msgChk.c_str());
345 }
346
iterate(void)347 IterateResult iterate(void)
348 {
349 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
350
351 if (hasRequiredEGLVersion(1, 5))
352 {
353 test<createSync>(m_funcNames, &Library::createSync);
354 }
355 if (hasEGLFenceSyncExtension())
356 {
357 test<createSyncKHR>(m_funcNamesKHR, &Library::createSyncKHR);
358 }
359 else if (!hasRequiredEGLVersion(1, 5))
360 {
361 TCU_THROW(NotSupportedError, "Required extensions not supported");
362 }
363
364 return STOP;
365 }
366 };
367
368 class CreateEmptyAttribsTest : public SyncTest
369 {
370 public:
CreateEmptyAttribsTest(EglTestContext & eglTestCtx,EGLenum syncType)371 CreateEmptyAttribsTest (EglTestContext& eglTestCtx, EGLenum syncType)
372 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "create_empty_attribs", "create_empty_attribs")
373 {
374 }
375
376 template <typename createSyncFuncType, typename attribType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc)377 void test(string funcNames[FUNC_NAME_NUM_NAMES],
378 createSyncFuncType createSyncFunc)
379 {
380 // Reset before each test
381 deinit();
382 init();
383
384 const Library& egl = m_eglTestCtx.getLibrary();
385 TestLog& log = m_testCtx.getLog();
386 string msgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
387 const attribType attribList[] =
388 {
389 EGL_NONE
390 };
391
392 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, attribList);
393 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
394 "(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) <<
395 ", { EGL_NONE })" << TestLog::EndMessage;
396 EGLU_CHECK_MSG(egl, msgChk.c_str());
397 }
398
iterate(void)399 IterateResult iterate (void)
400 {
401 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
402
403 if (hasRequiredEGLVersion(1, 5))
404 {
405 test<createSync, EGLAttrib>(m_funcNames, &Library::createSync);
406 }
407 if (hasEGLFenceSyncExtension())
408 {
409 test<createSyncKHR, EGLint>(m_funcNamesKHR, &Library::createSyncKHR);
410 }
411 else if (!hasRequiredEGLVersion(1, 5))
412 {
413 TCU_THROW(NotSupportedError, "Required extensions not supported");
414 }
415
416 return STOP;
417 }
418 };
419
420 class CreateInvalidDisplayTest : public SyncTest
421 {
422 public:
CreateInvalidDisplayTest(EglTestContext & eglTestCtx,EGLenum syncType)423 CreateInvalidDisplayTest (EglTestContext& eglTestCtx, EGLenum syncType)
424 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "create_invalid_display", "create_invalid_display")
425 {
426 }
427
428 template <typename createSyncFuncType, typename syncType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,syncType eglNoSync)429 void test(string funcNames[FUNC_NAME_NUM_NAMES],
430 createSyncFuncType createSyncFunc, syncType eglNoSync)
431 {
432 // Reset before each test
433 deinit();
434 init();
435
436 const Library& egl = m_eglTestCtx.getLibrary();
437 TestLog& log = m_testCtx.getLog();
438
439 m_sync = (egl.*createSyncFunc)(EGL_NO_DISPLAY, m_syncType, NULL);
440 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
441 "(EGL_NO_DISPLAY, " << getSyncTypeName(m_syncType) << ", NULL)" <<
442 TestLog::EndMessage;
443
444 EGLint error = egl.getError();
445 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
446
447 if (error != EGL_BAD_DISPLAY)
448 {
449 log << TestLog::Message << "Unexpected error '" <<
450 eglu::getErrorStr(error) << "' expected EGL_BAD_DISPLAY" <<
451 TestLog::EndMessage;
452 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
453 return;
454 }
455
456 TCU_CHECK(m_sync == eglNoSync);
457 }
458
iterate(void)459 IterateResult iterate (void)
460 {
461 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
462
463 if (hasRequiredEGLVersion(1, 5))
464 {
465 test<createSync, EGLSync>(m_funcNames, &Library::createSync, EGL_NO_SYNC);
466 }
467 if (hasEGLFenceSyncExtension())
468 {
469 test<createSyncKHR, EGLSyncKHR>(m_funcNamesKHR, &Library::createSyncKHR, EGL_NO_SYNC_KHR);
470 }
471 else if (!hasRequiredEGLVersion(1, 5))
472 {
473 TCU_THROW(NotSupportedError, "Required extensions not supported");
474 }
475
476 return STOP;
477 }
478 };
479
480 class CreateInvalidTypeTest : public SyncTest
481 {
482 public:
CreateInvalidTypeTest(EglTestContext & eglTestCtx,EGLenum syncType)483 CreateInvalidTypeTest (EglTestContext& eglTestCtx, EGLenum syncType)
484 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "create_invalid_type", "create_invalid_type")
485 {
486 }
487
488 template <typename createSyncFuncType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,EGLSyncKHR eglNoSync,EGLint syncError,string syncErrorName)489 void test(string funcNames[FUNC_NAME_NUM_NAMES],
490 createSyncFuncType createSyncFunc, EGLSyncKHR eglNoSync,
491 EGLint syncError, string syncErrorName)
492 {
493 // Reset before each test
494 deinit();
495 init();
496
497 const Library& egl = m_eglTestCtx.getLibrary();
498 TestLog& log = m_testCtx.getLog();
499
500 m_sync = (egl.*createSyncFunc)(m_eglDisplay, EGL_NONE, NULL);
501 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] << "(" <<
502 m_eglDisplay << ", EGL_NONE, NULL)" << TestLog::EndMessage;
503
504 EGLint error = egl.getError();
505 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
506
507 if (error != syncError)
508 {
509 log << TestLog::Message << "Unexpected error '" <<
510 eglu::getErrorStr(error) << "' expected " << syncErrorName << " " <<
511 TestLog::EndMessage;
512 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
513 return;
514 }
515
516 TCU_CHECK(m_sync == eglNoSync);
517 }
518
iterate(void)519 IterateResult iterate (void)
520 {
521 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
522
523 if (hasRequiredEGLVersion(1, 5))
524 {
525 test<createSync>(m_funcNames, &Library::createSync, EGL_NO_SYNC,
526 EGL_BAD_PARAMETER, "EGL_BAD_PARAMETER");
527 }
528 if (hasEGLFenceSyncExtension())
529 {
530 test<createSyncKHR>(m_funcNamesKHR, &Library::createSyncKHR, EGL_NO_SYNC_KHR,
531 EGL_BAD_ATTRIBUTE, "EGL_BAD_ATTRIBUTE");
532 }
533 else if (!hasRequiredEGLVersion(1, 5))
534 {
535 TCU_THROW(NotSupportedError, "Required extensions not supported");
536 }
537
538 return STOP;
539 }
540 };
541
542 class CreateInvalidAttribsTest : public SyncTest
543 {
544 public:
CreateInvalidAttribsTest(EglTestContext & eglTestCtx,EGLenum syncType)545 CreateInvalidAttribsTest (EglTestContext& eglTestCtx, EGLenum syncType)
546 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "create_invalid_attribs", "create_invalid_attribs")
547 {
548 }
549
550 template <typename createSyncFuncType, typename attribType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,EGLSyncKHR eglNoSync)551 void test(string funcNames[FUNC_NAME_NUM_NAMES],
552 createSyncFuncType createSyncFunc, EGLSyncKHR eglNoSync)
553 {
554 // Reset before each test
555 deinit();
556 init();
557
558 const Library& egl = m_eglTestCtx.getLibrary();
559 TestLog& log = m_testCtx.getLog();
560
561 attribType attribs[] = {
562 2, 3, 4, 5,
563 EGL_NONE
564 };
565
566 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, attribs);
567 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
568 "(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) <<
569 ", { 2, 3, 4, 5, EGL_NONE })" << TestLog::EndMessage;
570
571 EGLint error = egl.getError();
572 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
573
574 if (error != EGL_BAD_ATTRIBUTE)
575 {
576 log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) <<
577 "' expected EGL_BAD_ATTRIBUTE" << TestLog::EndMessage;
578 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
579 return;
580 }
581
582 TCU_CHECK(m_sync == eglNoSync);
583 }
584
iterate(void)585 IterateResult iterate (void)
586 {
587 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
588
589 if (hasRequiredEGLVersion(1, 5))
590 {
591 test<createSync, EGLAttrib>(m_funcNames, &Library::createSync, EGL_NO_SYNC);
592 }
593 if (hasEGLFenceSyncExtension())
594 {
595 test<createSyncKHR, EGLint>(m_funcNamesKHR, &Library::createSyncKHR, EGL_NO_SYNC_KHR);
596 }
597 else if (!hasRequiredEGLVersion(1, 5))
598 {
599 TCU_THROW(NotSupportedError, "Required extensions not supported");
600 }
601
602 return STOP;
603 }
604 };
605
606 class CreateInvalidContextTest : public SyncTest
607 {
608 public:
CreateInvalidContextTest(EglTestContext & eglTestCtx,EGLenum syncType)609 CreateInvalidContextTest (EglTestContext& eglTestCtx, EGLenum syncType)
610 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "create_invalid_context", "create_invalid_context")
611 {
612 }
613
614 template <typename createSyncFuncType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,EGLSyncKHR eglNoSync)615 void test(string funcNames[FUNC_NAME_NUM_NAMES],
616 createSyncFuncType createSyncFunc, EGLSyncKHR eglNoSync)
617 {
618 // Reset before each test
619 deinit();
620 init();
621
622 const Library& egl = m_eglTestCtx.getLibrary();
623 TestLog& log = m_testCtx.getLog();
624
625 log << TestLog::Message << "eglMakeCurrent(" << m_eglDisplay <<
626 ", EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)" << TestLog::EndMessage;
627 EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE,
628 EGL_NO_SURFACE, EGL_NO_CONTEXT));
629
630 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
631 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
632 "(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
633 TestLog::EndMessage;
634
635 EGLint error = egl.getError();
636 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
637
638 if (error != EGL_BAD_MATCH)
639 {
640 log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) <<
641 "' expected EGL_BAD_MATCH" << TestLog::EndMessage;
642 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
643 return;
644 }
645
646 TCU_CHECK(m_sync == eglNoSync);
647 }
648
iterate(void)649 IterateResult iterate (void)
650 {
651 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
652
653 if (hasRequiredEGLVersion(1, 5))
654 {
655 test<createSync>(m_funcNames, &Library::createSync, EGL_NO_SYNC);
656 }
657 if (hasEGLFenceSyncExtension())
658 {
659 test<createSyncKHR>(m_funcNamesKHR, &Library::createSyncKHR, EGL_NO_SYNC_KHR);
660 }
661 else if (!hasRequiredEGLVersion(1, 5))
662 {
663 TCU_THROW(NotSupportedError, "Required extensions not supported");
664 }
665
666 return STOP;
667 }
668 };
669
670 class ClientWaitNoTimeoutTest : public SyncTest
671 {
672 public:
ClientWaitNoTimeoutTest(EglTestContext & eglTestCtx,EGLenum syncType)673 ClientWaitNoTimeoutTest (EglTestContext& eglTestCtx, EGLenum syncType)
674 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "wait_no_timeout", "wait_no_timeout")
675 {
676 }
677
678 template <typename createSyncFuncType, typename clientWaitSyncFuncType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,clientWaitSyncFuncType clientWaitSyncFunc)679 void test(string funcNames[FUNC_NAME_NUM_NAMES],
680 createSyncFuncType createSyncFunc,
681 clientWaitSyncFuncType clientWaitSyncFunc)
682 {
683 // Reset before each test
684 deinit();
685 init();
686
687 const Library& egl = m_eglTestCtx.getLibrary();
688 TestLog& log = m_testCtx.getLog();
689 string msgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
690
691 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
692 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
693 "(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
694 TestLog::EndMessage;
695 EGLU_CHECK_MSG(egl, msgChk.c_str());
696
697 EGLint status = (egl.*clientWaitSyncFunc)(m_eglDisplay, m_sync, 0, 0);
698 log << TestLog::Message << status << " = " << funcNames[FUNC_NAME_CLIENT_WAIT_SYNC] <<
699 "(" << m_eglDisplay << ", " << m_sync << ", 0, 0)" << TestLog::EndMessage;
700
701 if (m_syncType == EGL_SYNC_FENCE_KHR)
702 TCU_CHECK(status == EGL_CONDITION_SATISFIED_KHR || status == EGL_TIMEOUT_EXPIRED_KHR);
703 else if (m_syncType == EGL_SYNC_REUSABLE_KHR)
704 TCU_CHECK(status == EGL_TIMEOUT_EXPIRED_KHR);
705 else
706 DE_ASSERT(DE_FALSE);
707 }
708
iterate(void)709 IterateResult iterate (void)
710 {
711 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
712
713 if (hasRequiredEGLVersion(1, 5))
714 {
715 test<createSync, clientWaitSync>(m_funcNames, &Library::createSync,
716 &Library::clientWaitSync);
717 }
718 if (hasEGLFenceSyncExtension())
719 {
720 test<createSyncKHR, clientWaitSyncKHR>(m_funcNamesKHR, &Library::createSyncKHR,
721 &Library::clientWaitSyncKHR);
722 }
723 else if (!hasRequiredEGLVersion(1, 5))
724 {
725 TCU_THROW(NotSupportedError, "Required extensions not supported");
726 }
727
728 return STOP;
729 }
730
731 };
732
733 class ClientWaitForeverTest : public SyncTest
734 {
735 public:
ClientWaitForeverTest(EglTestContext & eglTestCtx,EGLenum syncType)736 ClientWaitForeverTest (EglTestContext& eglTestCtx, EGLenum syncType)
737 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "wait_forever", "wait_forever")
738 {
739 }
740
741 template <typename createSyncFuncType, typename clientWaitSyncFuncType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,clientWaitSyncFuncType clientWaitSyncFunc,EGLTime eglTime,const string & eglTimeName,EGLint condSatisfied)742 void test(string funcNames[FUNC_NAME_NUM_NAMES],
743 createSyncFuncType createSyncFunc,
744 clientWaitSyncFuncType clientWaitSyncFunc,
745 EGLTime eglTime, const string &eglTimeName,
746 EGLint condSatisfied)
747 {
748 // Reset before each test
749 deinit();
750 init();
751
752 const Library& egl = m_eglTestCtx.getLibrary();
753 TestLog& log = m_testCtx.getLog();
754 string createSyncMsgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
755 string clientWaitSyncMsgChk = funcNames[FUNC_NAME_CLIENT_WAIT_SYNC] + "()";
756
757 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
758 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
759 "(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
760 TestLog::EndMessage;
761 EGLU_CHECK_MSG(egl, createSyncMsgChk.c_str());
762
763 if (m_syncType == EGL_SYNC_REUSABLE_KHR)
764 {
765 EGLBoolean ret = egl.signalSyncKHR(m_eglDisplay, m_sync, EGL_SIGNALED_KHR);
766 log << TestLog::Message << ret << " = eglSignalSyncKHR(" <<
767 m_eglDisplay << ", " << m_sync << ", EGL_SIGNALED_KHR)" <<
768 TestLog::EndMessage;
769 EGLU_CHECK_MSG(egl, "eglSignalSyncKHR()");
770 }
771 else if (m_syncType == EGL_SYNC_FENCE_KHR)
772 {
773 GLU_CHECK_GLW_CALL(m_gl, flush());
774 log << TestLog::Message << "glFlush()" << TestLog::EndMessage;
775 }
776 else
777 DE_ASSERT(DE_FALSE);
778
779 EGLint status = (egl.*clientWaitSyncFunc)(m_eglDisplay, m_sync, 0, eglTime);
780 log << TestLog::Message << status << " = " << funcNames[FUNC_NAME_CLIENT_WAIT_SYNC] <<
781 "(" << m_eglDisplay << ", " << m_sync << ", 0, " << eglTimeName << ")" <<
782 TestLog::EndMessage;
783
784 TCU_CHECK(status == condSatisfied);
785 EGLU_CHECK_MSG(egl, clientWaitSyncMsgChk.c_str());
786 }
787
iterate(void)788 IterateResult iterate (void)
789 {
790 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
791
792 if (hasRequiredEGLVersion(1, 5))
793 {
794 test<createSync, clientWaitSync>(m_funcNames, &Library::createSync,
795 &Library::clientWaitSync,
796 EGL_FOREVER, "EGL_FOREVER",
797 EGL_CONDITION_SATISFIED);
798 }
799 if (hasEGLFenceSyncExtension())
800 {
801 test<createSyncKHR, clientWaitSyncKHR>(m_funcNamesKHR, &Library::createSyncKHR,
802 &Library::clientWaitSyncKHR,
803 EGL_FOREVER_KHR, "EGL_FOREVER_KHR",
804 EGL_CONDITION_SATISFIED_KHR);
805 }
806 else if (!hasRequiredEGLVersion(1, 5))
807 {
808 TCU_THROW(NotSupportedError, "Required extensions not supported");
809 }
810
811 return STOP;
812 }
813 };
814
815 class ClientWaitNoContextTest : public SyncTest
816 {
817 public:
ClientWaitNoContextTest(EglTestContext & eglTestCtx,EGLenum syncType)818 ClientWaitNoContextTest (EglTestContext& eglTestCtx, EGLenum syncType)
819 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "wait_no_context", "wait_no_Context")
820 {
821 }
822
823 template <typename createSyncFuncType, typename clientWaitSyncFuncType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,clientWaitSyncFuncType clientWaitSyncFunc,EGLint condSatisfied,EGLTime eglTime,const string & eglTimeName)824 void test(string funcNames[FUNC_NAME_NUM_NAMES],
825 createSyncFuncType createSyncFunc,
826 clientWaitSyncFuncType clientWaitSyncFunc,
827 EGLint condSatisfied, EGLTime eglTime, const string &eglTimeName)
828 {
829 // Reset before each test
830 deinit();
831 init();
832
833 const Library& egl = m_eglTestCtx.getLibrary();
834 TestLog& log = m_testCtx.getLog();
835 string createSyncMsgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
836
837 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
838 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
839 "(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
840 TestLog::EndMessage;
841 EGLU_CHECK_MSG(egl, createSyncMsgChk.c_str());
842
843
844 if (m_syncType == EGL_SYNC_REUSABLE_KHR)
845 {
846 EGLBoolean ret = egl.signalSyncKHR(m_eglDisplay, m_sync, EGL_SIGNALED_KHR);
847 log << TestLog::Message << ret << " = eglSignalSyncKHR(" <<
848 m_eglDisplay << ", " << m_sync << ", EGL_SIGNALED_KHR)" <<
849 TestLog::EndMessage;
850 EGLU_CHECK_MSG(egl, "eglSignalSyncKHR()");
851 }
852 else if (m_syncType == EGL_SYNC_FENCE_KHR)
853 {
854 GLU_CHECK_GLW_CALL(m_gl, flush());
855 log << TestLog::Message << "glFlush()" << TestLog::EndMessage;
856 }
857 else
858 DE_ASSERT(DE_FALSE);
859
860 log << TestLog::Message << "eglMakeCurrent(" << m_eglDisplay <<
861 ", EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)" << TestLog::EndMessage;
862 EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE,
863 EGL_NO_SURFACE, EGL_NO_CONTEXT));
864
865 EGLint result = (egl.*clientWaitSyncFunc)(m_eglDisplay, m_sync, 0, eglTime);
866 log << TestLog::Message << result << " = " << funcNames[FUNC_NAME_CLIENT_WAIT_SYNC] <<
867 "(" << m_eglDisplay << ", " << m_sync << ", 0, " << eglTimeName << ")" <<
868 TestLog::EndMessage;
869
870 TCU_CHECK(result == condSatisfied);
871 }
872
iterate(void)873 IterateResult iterate (void)
874 {
875 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
876
877 if (hasRequiredEGLVersion(1, 5))
878 {
879 test<createSync, clientWaitSync>(m_funcNames, &Library::createSync,
880 &Library::clientWaitSync,
881 EGL_CONDITION_SATISFIED, EGL_FOREVER, "EGL_FOREVER");
882 }
883 if (hasEGLFenceSyncExtension())
884 {
885 test<createSyncKHR, clientWaitSyncKHR>(m_funcNamesKHR, &Library::createSyncKHR,
886 &Library::clientWaitSyncKHR,
887 EGL_CONDITION_SATISFIED_KHR, EGL_FOREVER_KHR, "EGL_FOREVER_KHR");
888 }
889 else if (!hasRequiredEGLVersion(1, 5))
890 {
891 TCU_THROW(NotSupportedError, "Required extensions not supported");
892 }
893
894 return STOP;
895 }
896 };
897
898 class ClientWaitForeverFlushTest : public SyncTest
899 {
900 public:
ClientWaitForeverFlushTest(EglTestContext & eglTestCtx,EGLenum syncType)901 ClientWaitForeverFlushTest (EglTestContext& eglTestCtx, EGLenum syncType)
902 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "wait_forever_flush", "wait_forever_flush")
903 {
904 }
905
906 template <typename createSyncFuncType, typename clientWaitSyncFuncType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,clientWaitSyncFuncType clientWaitSyncFunc,EGLint flags,const string & flagsName,EGLTime eglTime,const string & eglTimeName,EGLint condSatisfied)907 void test(string funcNames[FUNC_NAME_NUM_NAMES],
908 createSyncFuncType createSyncFunc,
909 clientWaitSyncFuncType clientWaitSyncFunc,
910 EGLint flags, const string &flagsName,
911 EGLTime eglTime, const string &eglTimeName,
912 EGLint condSatisfied)
913 {
914 // Reset before each test
915 deinit();
916 init();
917
918 const Library& egl = m_eglTestCtx.getLibrary();
919 TestLog& log = m_testCtx.getLog();
920 string createSyncMsgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
921
922 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
923 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
924 "(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
925 TestLog::EndMessage;
926 EGLU_CHECK_MSG(egl, createSyncMsgChk.c_str());
927
928 if (m_syncType == EGL_SYNC_REUSABLE_KHR)
929 {
930 EGLBoolean ret = egl.signalSyncKHR(m_eglDisplay, m_sync, EGL_SIGNALED_KHR);
931 log << TestLog::Message << ret << " = eglSignalSyncKHR(" <<
932 m_eglDisplay << ", " << m_sync << ", EGL_SIGNALED_KHR)" <<
933 TestLog::EndMessage;
934 EGLU_CHECK_MSG(egl, "eglSignalSyncKHR()");
935 }
936
937 EGLint status = (egl.*clientWaitSyncFunc)(m_eglDisplay, m_sync, flags, eglTime);
938 log << TestLog::Message << status << " = " << funcNames[FUNC_NAME_CLIENT_WAIT_SYNC] <<
939 "(" << m_eglDisplay << ", " << m_sync << ", " << flagsName << ", " <<
940 eglTimeName << ")" << TestLog::EndMessage;
941
942 TCU_CHECK(status == condSatisfied);
943
944 }
945
iterate(void)946 IterateResult iterate (void)
947 {
948 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
949
950 if (hasRequiredEGLVersion(1, 5))
951 {
952 test<createSync, clientWaitSync>(m_funcNames, &Library::createSync,
953 &Library::clientWaitSync,
954 EGL_SYNC_FLUSH_COMMANDS_BIT, "EGL_SYNC_FLUSH_COMMANDS_BIT",
955 EGL_FOREVER, "EGL_FOREVER",
956 EGL_CONDITION_SATISFIED);
957 }
958 if (hasEGLFenceSyncExtension())
959 {
960 test<createSyncKHR, clientWaitSyncKHR>(m_funcNamesKHR, &Library::createSyncKHR,
961 &Library::clientWaitSyncKHR,
962 EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, "EGL_SYNC_FLUSH_COMMANDS_BIT_KHR",
963 EGL_FOREVER_KHR, "EGL_FOREVER_KHR",
964 EGL_CONDITION_SATISFIED_KHR);
965 }
966 else if (!hasRequiredEGLVersion(1, 5))
967 {
968 TCU_THROW(NotSupportedError, "Required extensions not supported");
969 }
970
971 return STOP;
972 }
973 };
974
975 class ClientWaitInvalidDisplayTest : public SyncTest
976 {
977 public:
ClientWaitInvalidDisplayTest(EglTestContext & eglTestCtx,EGLenum syncType)978 ClientWaitInvalidDisplayTest (EglTestContext& eglTestCtx, EGLenum syncType)
979 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "wait_invalid_display", "wait_invalid_display")
980 {
981 }
982
983 template <typename createSyncFuncType, typename clientWaitSyncFuncType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,clientWaitSyncFuncType clientWaitSyncFunc,EGLint flags,const string & flagsName,EGLTime eglTime,const string & eglTimeName)984 void test(string funcNames[FUNC_NAME_NUM_NAMES],
985 createSyncFuncType createSyncFunc,
986 clientWaitSyncFuncType clientWaitSyncFunc,
987 EGLint flags, const string &flagsName,
988 EGLTime eglTime, const string &eglTimeName)
989 {
990 // Reset before each test
991 deinit();
992 init();
993
994 const Library& egl = m_eglTestCtx.getLibrary();
995 TestLog& log = m_testCtx.getLog();
996 string createSyncMsgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
997
998 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
999 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] << "(" <<
1000 m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
1001 TestLog::EndMessage;
1002 EGLU_CHECK_MSG(egl, createSyncMsgChk.c_str());
1003
1004 EGLint status = (egl.*clientWaitSyncFunc)(EGL_NO_DISPLAY, m_sync, flags, eglTime);
1005 log << TestLog::Message << status << " = " << funcNames[FUNC_NAME_CLIENT_WAIT_SYNC] <<
1006 "(EGL_NO_DISPLAY, " << m_sync << ", " << flagsName << ", " <<
1007 eglTimeName << ")" << TestLog::EndMessage;
1008
1009 EGLint error = egl.getError();
1010 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
1011
1012 if (error != EGL_BAD_DISPLAY)
1013 {
1014 log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) <<
1015 "' expected EGL_BAD_DISPLAY" << TestLog::EndMessage;
1016 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1017 return;
1018 }
1019
1020 TCU_CHECK(status == EGL_FALSE);
1021 }
1022
iterate(void)1023 IterateResult iterate (void)
1024 {
1025 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1026
1027 if (hasRequiredEGLVersion(1, 5))
1028 {
1029 test<createSync, clientWaitSync>(m_funcNames, &Library::createSync,
1030 &Library::clientWaitSync,
1031 EGL_SYNC_FLUSH_COMMANDS_BIT, "EGL_SYNC_FLUSH_COMMANDS_BIT",
1032 EGL_FOREVER, "EGL_FOREVER");
1033 }
1034 if (hasEGLFenceSyncExtension())
1035 {
1036 test<createSyncKHR, clientWaitSyncKHR>(m_funcNamesKHR, &Library::createSyncKHR,
1037 &Library::clientWaitSyncKHR,
1038 EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, "EGL_SYNC_FLUSH_COMMANDS_BIT_KHR",
1039 EGL_FOREVER_KHR, "EGL_FOREVER_KHR");
1040 }
1041 else if (!hasRequiredEGLVersion(1, 5))
1042 {
1043 TCU_THROW(NotSupportedError, "Required extensions not supported");
1044 }
1045
1046 return STOP;
1047 }
1048 };
1049
1050 class ClientWaitInvalidSyncTest : public SyncTest
1051 {
1052 public:
ClientWaitInvalidSyncTest(EglTestContext & eglTestCtx,EGLenum syncType)1053 ClientWaitInvalidSyncTest (EglTestContext& eglTestCtx, EGLenum syncType)
1054 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "wait_invalid_sync", "wait_invalid_sync")
1055 {
1056 }
1057
1058 template <typename clientWaitSyncFuncType>
test(string funcNames[FUNC_NAME_NUM_NAMES],clientWaitSyncFuncType clientWaitSyncFunc,EGLSync sync,const string & syncName,EGLTime eglTime,const string & eglTimeName)1059 void test(string funcNames[FUNC_NAME_NUM_NAMES],
1060 clientWaitSyncFuncType clientWaitSyncFunc,
1061 EGLSync sync, const string &syncName,
1062 EGLTime eglTime, const string &eglTimeName)
1063 {
1064 // Reset before each test
1065 deinit();
1066 init();
1067
1068 const Library& egl = m_eglTestCtx.getLibrary();
1069 TestLog& log = m_testCtx.getLog();
1070
1071 EGLint status = (egl.*clientWaitSyncFunc)(m_eglDisplay, sync, 0, eglTime);
1072 log << TestLog::Message << status << " = " << funcNames[FUNC_NAME_CLIENT_WAIT_SYNC] <<
1073 "(" << m_eglDisplay << ", " << syncName << ", 0, " << eglTimeName << ")" <<
1074 TestLog::EndMessage;
1075
1076 EGLint error = egl.getError();
1077 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
1078
1079 if (error != EGL_BAD_PARAMETER)
1080 {
1081 log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) <<
1082 "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage;
1083 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1084 return;
1085 }
1086
1087 TCU_CHECK(status == EGL_FALSE);
1088 }
1089
iterate(void)1090 IterateResult iterate (void)
1091 {
1092 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1093
1094 if (hasRequiredEGLVersion(1, 5))
1095 {
1096 test<clientWaitSync>(m_funcNames, &Library::clientWaitSync,
1097 EGL_NO_SYNC, "EGL_NO_SYNC",
1098 EGL_FOREVER, "EGL_FOREVER");
1099 }
1100 if (hasEGLFenceSyncExtension())
1101 {
1102 test<clientWaitSyncKHR>(m_funcNamesKHR, &Library::clientWaitSyncKHR,
1103 EGL_NO_SYNC_KHR, "EGL_NO_SYNC_KHR",
1104 EGL_FOREVER_KHR, "EGL_FOREVER_KHR");
1105 }
1106 else if (!hasRequiredEGLVersion(1, 5))
1107 {
1108 TCU_THROW(NotSupportedError, "Required extensions not supported");
1109 }
1110
1111 return STOP;
1112 }
1113 };
1114
1115 class GetSyncTypeTest : public SyncTest
1116 {
1117 public:
GetSyncTypeTest(EglTestContext & eglTestCtx,EGLenum syncType)1118 GetSyncTypeTest (EglTestContext& eglTestCtx, EGLenum syncType)
1119 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "get_type", "get_type")
1120 {
1121 }
1122
1123 template <typename createSyncFuncType, typename getSyncAttribFuncType, typename getSyncAttribValueType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,getSyncAttribFuncType getSyncAttribFunc,EGLint attribute,const string & attributeName)1124 void test(string funcNames[FUNC_NAME_NUM_NAMES],
1125 createSyncFuncType createSyncFunc,
1126 getSyncAttribFuncType getSyncAttribFunc,
1127 EGLint attribute, const string &attributeName)
1128 {
1129 // Reset before each test
1130 deinit();
1131 init();
1132
1133 const Library& egl = m_eglTestCtx.getLibrary();
1134 TestLog& log = m_testCtx.getLog();
1135 string createSyncMsgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
1136
1137 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
1138 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
1139 "(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
1140 TestLog::EndMessage;
1141 EGLU_CHECK_MSG(egl, createSyncMsgChk.c_str());
1142
1143 getSyncAttribValueType type = 0;
1144 EGLU_CHECK_CALL_FPTR(egl, (egl.*getSyncAttribFunc)(m_eglDisplay, m_sync,
1145 attribute, &type));
1146 log << TestLog::Message << funcNames[FUNC_NAME_GET_SYNC_ATTRIB] << "(" << m_eglDisplay <<
1147 ", " << m_sync << ", " << attributeName << ", {" << type << "})" <<
1148 TestLog::EndMessage;
1149
1150 TCU_CHECK(type == ((getSyncAttribValueType)m_syncType));
1151 }
1152
iterate(void)1153 IterateResult iterate (void)
1154 {
1155 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1156
1157 if (hasRequiredEGLVersion(1, 5))
1158 {
1159 test<createSync, getSyncAttrib, EGLAttrib>(m_funcNames, &Library::createSync,
1160 &Library::getSyncAttrib,
1161 EGL_SYNC_TYPE, "EGL_SYNC_TYPE");
1162 }
1163 if (hasEGLFenceSyncExtension())
1164 {
1165 test<createSyncKHR, getSyncAttribKHR, EGLint>(m_funcNamesKHR, &Library::createSyncKHR,
1166 &Library::getSyncAttribKHR,
1167 EGL_SYNC_TYPE_KHR, "EGL_SYNC_TYPE_KHR");
1168 }
1169 else if (!hasRequiredEGLVersion(1, 5))
1170 {
1171 TCU_THROW(NotSupportedError, "Required extensions not supported");
1172 }
1173
1174 return STOP;
1175 }
1176 };
1177
1178 class GetSyncStatusTest : public SyncTest
1179 {
1180 public:
GetSyncStatusTest(EglTestContext & eglTestCtx,EGLenum syncType)1181 GetSyncStatusTest (EglTestContext& eglTestCtx, EGLenum syncType)
1182 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "get_status", "get_status")
1183 {
1184 }
1185
1186 template <typename createSyncFuncType, typename getSyncAttribFuncType, typename getSyncAttribValueType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,getSyncAttribFuncType getSyncAttribFunc,EGLint attribute,const string & attributeName)1187 void test(string funcNames[FUNC_NAME_NUM_NAMES],
1188 createSyncFuncType createSyncFunc,
1189 getSyncAttribFuncType getSyncAttribFunc,
1190 EGLint attribute, const string &attributeName)
1191 {
1192 // Reset before each test
1193 deinit();
1194 init();
1195
1196 const Library& egl = m_eglTestCtx.getLibrary();
1197 TestLog& log = m_testCtx.getLog();
1198 string createSyncMsgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
1199
1200 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
1201 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
1202 "(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
1203 TestLog::EndMessage;
1204 EGLU_CHECK_MSG(egl, createSyncMsgChk.c_str());
1205
1206 getSyncAttribValueType status = 0;
1207 EGLU_CHECK_CALL_FPTR(egl, (egl.*getSyncAttribFunc)(m_eglDisplay, m_sync, attribute, &status));
1208 log << TestLog::Message << funcNames[FUNC_NAME_GET_SYNC_ATTRIB] << "(" <<
1209 m_eglDisplay << ", " << m_sync << ", " << attributeName << ", {" <<
1210 status << "})" << TestLog::EndMessage;
1211
1212 if (m_syncType == EGL_SYNC_FENCE_KHR)
1213 TCU_CHECK(status == EGL_SIGNALED_KHR || status == EGL_UNSIGNALED_KHR);
1214 else if (m_syncType == EGL_SYNC_REUSABLE_KHR)
1215 TCU_CHECK(status == EGL_UNSIGNALED_KHR);
1216 }
1217
iterate(void)1218 IterateResult iterate (void)
1219 {
1220 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1221
1222 if (hasRequiredEGLVersion(1, 5))
1223 {
1224 test<createSync, getSyncAttrib, EGLAttrib>(m_funcNames, &Library::createSync,
1225 &Library::getSyncAttrib,
1226 EGL_SYNC_STATUS, "EGL_SYNC_STATUS");
1227 }
1228 if (hasEGLFenceSyncExtension())
1229 {
1230 test<createSyncKHR, getSyncAttribKHR, EGLint>(m_funcNamesKHR, &Library::createSyncKHR,
1231 &Library::getSyncAttribKHR,
1232 EGL_SYNC_STATUS_KHR, "EGL_SYNC_STATUS_KHR");
1233 }
1234 else if (!hasRequiredEGLVersion(1, 5))
1235 {
1236 TCU_THROW(NotSupportedError, "Required extensions not supported");
1237 }
1238
1239 return STOP;
1240 }
1241 };
1242
1243 class GetSyncStatusSignaledTest : public SyncTest
1244 {
1245 public:
GetSyncStatusSignaledTest(EglTestContext & eglTestCtx,EGLenum syncType)1246 GetSyncStatusSignaledTest (EglTestContext& eglTestCtx, EGLenum syncType)
1247 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "get_status_signaled", "get_status_signaled")
1248 {
1249 }
1250
1251 template <typename createSyncFuncType,
1252 typename clientWaitSyncFuncType,
1253 typename getSyncAttribFuncType,
1254 typename getSyncAttribValueType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,clientWaitSyncFuncType clientWaitSyncFunc,EGLint flags,const string & flagsName,EGLTime eglTime,const string & eglTimeName,EGLint condSatisfied,getSyncAttribFuncType getSyncAttribFunc,EGLint attribute,const string & attributeName,getSyncAttribValueType statusVal)1255 void test(string funcNames[FUNC_NAME_NUM_NAMES],
1256 createSyncFuncType createSyncFunc,
1257 clientWaitSyncFuncType clientWaitSyncFunc,
1258 EGLint flags, const string &flagsName,
1259 EGLTime eglTime, const string &eglTimeName,
1260 EGLint condSatisfied,
1261 getSyncAttribFuncType getSyncAttribFunc,
1262 EGLint attribute, const string &attributeName,
1263 getSyncAttribValueType statusVal)
1264 {
1265 // Reset before each test
1266 deinit();
1267 init();
1268
1269 const Library& egl = m_eglTestCtx.getLibrary();
1270 TestLog& log = m_testCtx.getLog();
1271 string createSyncMsgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
1272
1273 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
1274 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
1275 "(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
1276 TestLog::EndMessage;
1277 EGLU_CHECK_MSG(egl, createSyncMsgChk.c_str());
1278
1279 if (m_syncType == EGL_SYNC_REUSABLE_KHR)
1280 {
1281 EGLBoolean ret = egl.signalSyncKHR(m_eglDisplay, m_sync, EGL_SIGNALED_KHR);
1282 log << TestLog::Message << ret << " = eglSignalSyncKHR(" <<
1283 m_eglDisplay << ", " << m_sync << ", EGL_SIGNALED_KHR)" <<
1284 TestLog::EndMessage;
1285 EGLU_CHECK_MSG(egl, "eglSignalSyncKHR()");
1286 }
1287 else if (m_syncType == EGL_SYNC_FENCE_KHR)
1288 {
1289 GLU_CHECK_GLW_CALL(m_gl, finish());
1290 log << TestLog::Message << "glFinish()" << TestLog::EndMessage;
1291 }
1292 else
1293 DE_ASSERT(DE_FALSE);
1294
1295 {
1296 EGLint status = (egl.*clientWaitSyncFunc)(m_eglDisplay, m_sync, flags, eglTime);
1297 log << TestLog::Message << status << " = " << funcNames[FUNC_NAME_CLIENT_WAIT_SYNC] << "(" <<
1298 m_eglDisplay << ", " << m_sync << ", " << flagsName << ", " <<
1299 eglTimeName << ")" << TestLog::EndMessage;
1300 TCU_CHECK(status == condSatisfied);
1301 }
1302
1303 getSyncAttribValueType status = 0;
1304 EGLU_CHECK_CALL_FPTR(egl, (egl.*getSyncAttribFunc)(m_eglDisplay, m_sync, attribute, &status));
1305 log << TestLog::Message << funcNames[FUNC_NAME_GET_SYNC_ATTRIB] << "(" <<
1306 m_eglDisplay << ", " << m_sync << ", " << attributeName << ", {" <<
1307 status << "})" << TestLog::EndMessage;
1308
1309 TCU_CHECK(status == statusVal);
1310 }
1311
iterate(void)1312 IterateResult iterate (void)
1313 {
1314 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1315
1316 if (hasRequiredEGLVersion(1, 5))
1317 {
1318 test<createSync, clientWaitSync, getSyncAttrib, EGLAttrib>(m_funcNames,
1319 &Library::createSync,
1320 &Library::clientWaitSync,
1321 EGL_SYNC_FLUSH_COMMANDS_BIT, "EGL_SYNC_FLUSH_COMMANDS_BIT",
1322 EGL_FOREVER, "EGL_FOREVER",
1323 EGL_CONDITION_SATISFIED,
1324 &Library::getSyncAttrib,
1325 EGL_SYNC_STATUS, "EGL_SYNC_STATUS",
1326 EGL_SIGNALED);
1327 }
1328 if (hasEGLFenceSyncExtension())
1329 {
1330 test<createSyncKHR, clientWaitSyncKHR, getSyncAttribKHR, EGLint>(m_funcNamesKHR,
1331 &Library::createSyncKHR,
1332 &Library::clientWaitSyncKHR,
1333 EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, "EGL_SYNC_FLUSH_COMMANDS_BIT_KHR",
1334 EGL_FOREVER_KHR, "EGL_FOREVER_KHR",
1335 EGL_CONDITION_SATISFIED_KHR,
1336 &Library::getSyncAttribKHR,
1337 EGL_SYNC_STATUS_KHR, "EGL_SYNC_STATUS_KHR",
1338 EGL_SIGNALED_KHR);
1339 }
1340 else if (!hasRequiredEGLVersion(1, 5))
1341 {
1342 TCU_THROW(NotSupportedError, "Required extensions not supported");
1343 }
1344
1345 return STOP;
1346 }
1347 };
1348
1349 class GetSyncConditionTest : public SyncTest
1350 {
1351 public:
GetSyncConditionTest(EglTestContext & eglTestCtx,EGLenum syncType)1352 GetSyncConditionTest (EglTestContext& eglTestCtx, EGLenum syncType)
1353 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "get_condition", "get_condition")
1354 {
1355 }
1356
1357 template <typename createSyncFuncType,
1358 typename getSyncAttribFuncType,
1359 typename getSyncAttribValueType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,getSyncAttribFuncType getSyncAttribFunc,EGLint attribute,const string & attributeName,getSyncAttribValueType statusVal)1360 void test(string funcNames[FUNC_NAME_NUM_NAMES],
1361 createSyncFuncType createSyncFunc,
1362 getSyncAttribFuncType getSyncAttribFunc,
1363 EGLint attribute, const string &attributeName,
1364 getSyncAttribValueType statusVal)
1365 {
1366 // Reset before each test
1367 deinit();
1368 init();
1369
1370 const Library& egl = m_eglTestCtx.getLibrary();
1371 TestLog& log = m_testCtx.getLog();
1372 string createSyncMsgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
1373
1374 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
1375 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
1376 "(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
1377 TestLog::EndMessage;
1378 EGLU_CHECK_MSG(egl, createSyncMsgChk.c_str());
1379
1380 getSyncAttribValueType condition = 0;
1381 EGLU_CHECK_CALL_FPTR(egl, (egl.*getSyncAttribFunc)(m_eglDisplay, m_sync,
1382 attribute, &condition));
1383 log << TestLog::Message << funcNames[FUNC_NAME_GET_SYNC_ATTRIB] << "(" <<
1384 m_eglDisplay << ", " << m_sync << ", " << attributeName << ", {" <<
1385 condition << "})" << TestLog::EndMessage;
1386
1387 TCU_CHECK(condition == statusVal);
1388 }
1389
iterate(void)1390 IterateResult iterate (void)
1391 {
1392 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1393
1394 if (hasRequiredEGLVersion(1, 5))
1395 {
1396 test<createSync, getSyncAttrib, EGLAttrib>(m_funcNames, &Library::createSync,
1397 &Library::getSyncAttrib,
1398 EGL_SYNC_CONDITION, "EGL_SYNC_CONDITION",
1399 EGL_SYNC_PRIOR_COMMANDS_COMPLETE);
1400 }
1401 if (hasEGLFenceSyncExtension())
1402 {
1403 test<createSyncKHR, getSyncAttribKHR, EGLint>(m_funcNamesKHR, &Library::createSyncKHR,
1404 &Library::getSyncAttribKHR,
1405 EGL_SYNC_CONDITION_KHR, "EGL_SYNC_CONDITION_KHR",
1406 EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR);
1407 }
1408 else if (!hasRequiredEGLVersion(1, 5))
1409 {
1410 TCU_THROW(NotSupportedError, "Required extensions not supported");
1411 }
1412
1413 return STOP;
1414 }
1415 };
1416
1417 class GetSyncInvalidDisplayTest : public SyncTest
1418 {
1419 public:
GetSyncInvalidDisplayTest(EglTestContext & eglTestCtx,EGLenum syncType)1420 GetSyncInvalidDisplayTest (EglTestContext& eglTestCtx, EGLenum syncType)
1421 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR,"get_invalid_display", "get_invalid_display")
1422 {
1423 }
1424
1425 template <typename createSyncFuncType,
1426 typename getSyncAttribFuncType,
1427 typename getSyncAttribValueType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,getSyncAttribFuncType getSyncAttribFunc,EGLint attribute,const string & attributeName)1428 void test(string funcNames[FUNC_NAME_NUM_NAMES],
1429 createSyncFuncType createSyncFunc,
1430 getSyncAttribFuncType getSyncAttribFunc,
1431 EGLint attribute, const string &attributeName)
1432 {
1433 // Reset before each test
1434 deinit();
1435 init();
1436
1437 const Library& egl = m_eglTestCtx.getLibrary();
1438 TestLog& log = m_testCtx.getLog();
1439 string createSyncMsgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
1440
1441 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
1442 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
1443 "(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
1444 TestLog::EndMessage;
1445 EGLU_CHECK_MSG(egl, createSyncMsgChk.c_str());
1446
1447 getSyncAttribValueType condition = 0xF0F0F;
1448 EGLBoolean result = (egl.*getSyncAttribFunc)(EGL_NO_DISPLAY, m_sync, attribute, &condition);
1449 log << TestLog::Message << result << " = " << funcNames[FUNC_NAME_GET_SYNC_ATTRIB] <<
1450 "(EGL_NO_DISPLAY, " << m_sync << ", " << attributeName << ", {" <<
1451 condition << "})" << TestLog::EndMessage;
1452
1453 EGLint error = egl.getError();
1454 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
1455
1456 if (error != EGL_BAD_DISPLAY)
1457 {
1458 log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) <<
1459 "' expected EGL_BAD_DISPLAY" << TestLog::EndMessage;
1460 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1461 return;
1462 }
1463
1464 TCU_CHECK(result == EGL_FALSE);
1465 TCU_CHECK(condition == 0xF0F0F);
1466 }
1467
iterate(void)1468 IterateResult iterate (void)
1469 {
1470 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1471
1472 if (hasRequiredEGLVersion(1, 5))
1473 {
1474 test<createSync, getSyncAttrib, EGLAttrib>(m_funcNames, &Library::createSync,
1475 &Library::getSyncAttrib,
1476 EGL_SYNC_CONDITION, "EGL_SYNC_CONDITION");
1477 }
1478 if (hasEGLFenceSyncExtension())
1479 {
1480 test<createSyncKHR, getSyncAttribKHR, EGLint>(m_funcNamesKHR, &Library::createSyncKHR,
1481 &Library::getSyncAttribKHR,
1482 EGL_SYNC_CONDITION_KHR, "EGL_SYNC_CONDITION_KHR");
1483 }
1484 else if (!hasRequiredEGLVersion(1, 5))
1485 {
1486 TCU_THROW(NotSupportedError, "Required extensions not supported");
1487 }
1488
1489 return STOP;
1490 }
1491 };
1492
1493 class GetSyncInvalidSyncTest : public SyncTest
1494 {
1495 public:
GetSyncInvalidSyncTest(EglTestContext & eglTestCtx,EGLenum syncType)1496 GetSyncInvalidSyncTest (EglTestContext& eglTestCtx, EGLenum syncType)\
1497 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "get_invalid_sync", "get_invalid_sync")
1498 {
1499 }
1500
1501 template <typename getSyncAttribFuncType,
1502 typename getSyncSyncValueType,
1503 typename getSyncAttribValueType>
test(string funcNames[FUNC_NAME_NUM_NAMES],getSyncAttribFuncType getSyncAttribFunc,getSyncSyncValueType syncValue,const string & syncName,EGLint attribute,const string & attributeName)1504 void test(string funcNames[FUNC_NAME_NUM_NAMES],
1505 getSyncAttribFuncType getSyncAttribFunc,
1506 getSyncSyncValueType syncValue, const string &syncName,
1507 EGLint attribute, const string &attributeName)
1508 {
1509 // Reset before each test
1510 deinit();
1511 init();
1512
1513 const Library& egl = m_eglTestCtx.getLibrary();
1514 TestLog& log = m_testCtx.getLog();
1515
1516 getSyncAttribValueType condition = 0xF0F0F;
1517 EGLBoolean result = (egl.*getSyncAttribFunc)(m_eglDisplay, syncValue,
1518 attribute, &condition);
1519 log << TestLog::Message << result << " = " << funcNames[FUNC_NAME_GET_SYNC_ATTRIB] <<
1520 "(" << m_eglDisplay << ", " << syncName << ", " << attributeName << ", {" <<
1521 condition << "})" << TestLog::EndMessage;
1522
1523 EGLint error = egl.getError();
1524 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
1525
1526 if (error != EGL_BAD_PARAMETER)
1527 {
1528 log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) <<
1529 "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage;
1530 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1531 return;
1532 }
1533
1534 TCU_CHECK(result == EGL_FALSE);
1535 TCU_CHECK(condition == 0xF0F0F);
1536 }
1537
iterate(void)1538 IterateResult iterate (void)
1539 {
1540 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1541
1542 if (hasRequiredEGLVersion(1, 5))
1543 {
1544 test<getSyncAttrib, EGLSync, EGLAttrib>(m_funcNames, &Library::getSyncAttrib,
1545 EGL_NO_SYNC, "EGL_NO_SYNC",
1546 EGL_SYNC_CONDITION, "EGL_SYNC_CONDITION");
1547 }
1548 if (hasEGLFenceSyncExtension())
1549 {
1550 test<getSyncAttribKHR, EGLSyncKHR, EGLint>(m_funcNamesKHR, &Library::getSyncAttribKHR,
1551 EGL_NO_SYNC_KHR, "EGL_NO_SYNC_KHR",
1552 EGL_SYNC_CONDITION_KHR, "EGL_SYNC_CONDITION_KHR");
1553 }
1554 else if (!hasRequiredEGLVersion(1, 5))
1555 {
1556 TCU_THROW(NotSupportedError, "Required extensions not supported");
1557 }
1558
1559 return STOP;
1560 }
1561 };
1562
1563 class GetSyncInvalidAttributeTest : public SyncTest
1564 {
1565 public:
GetSyncInvalidAttributeTest(EglTestContext & eglTestCtx,EGLenum syncType)1566 GetSyncInvalidAttributeTest (EglTestContext& eglTestCtx, EGLenum syncType)
1567 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR,"get_invalid_attribute", "get_invalid_attribute")
1568 {
1569 }
1570
1571 template <typename createSyncFuncType,
1572 typename getSyncAttribFuncType,
1573 typename getSyncAttribValueType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,getSyncAttribFuncType getSyncAttribFunc)1574 void test(string funcNames[FUNC_NAME_NUM_NAMES],
1575 createSyncFuncType createSyncFunc,
1576 getSyncAttribFuncType getSyncAttribFunc)
1577 {
1578 // Reset before each test
1579 deinit();
1580 init();
1581
1582 const Library& egl = m_eglTestCtx.getLibrary();
1583 TestLog& log = m_testCtx.getLog();
1584 string createSyncMsgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
1585
1586 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
1587 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
1588 "(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
1589 TestLog::EndMessage;
1590 EGLU_CHECK_MSG(egl, createSyncMsgChk.c_str());
1591
1592 getSyncAttribValueType condition = 0xF0F0F;
1593 EGLBoolean result = (egl.*getSyncAttribFunc)(m_eglDisplay, m_sync, EGL_NONE, &condition);
1594 log << TestLog::Message << result << " = " << funcNames[FUNC_NAME_GET_SYNC_ATTRIB] <<
1595 "(" << m_eglDisplay << ", " << m_sync << ", EGL_NONE, {" << condition << "})" <<
1596 TestLog::EndMessage;
1597
1598 EGLint error = egl.getError();
1599 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
1600
1601 if (error != EGL_BAD_ATTRIBUTE)
1602 {
1603 log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) <<
1604 "' expected EGL_BAD_ATTRIBUTE" << TestLog::EndMessage;
1605 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1606 return;
1607 }
1608
1609 TCU_CHECK(result == EGL_FALSE);
1610 TCU_CHECK(condition == 0xF0F0F);
1611 }
1612
iterate(void)1613 IterateResult iterate (void)
1614 {
1615 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1616
1617 if (hasRequiredEGLVersion(1, 5))
1618 {
1619 test<createSync, getSyncAttrib, EGLAttrib>(m_funcNames,
1620 &Library::createSync,
1621 &Library::getSyncAttrib);
1622 }
1623 if (hasEGLFenceSyncExtension())
1624 {
1625 test<createSyncKHR, getSyncAttribKHR, EGLint>(m_funcNamesKHR,
1626 &Library::createSyncKHR,
1627 &Library::getSyncAttribKHR);
1628 }
1629 else if (!hasRequiredEGLVersion(1, 5))
1630 {
1631 TCU_THROW(NotSupportedError, "Required extensions not supported");
1632 }
1633
1634 return STOP;
1635 }
1636 };
1637
1638 class GetSyncInvalidValueTest : public SyncTest
1639 {
1640 public:
GetSyncInvalidValueTest(EglTestContext & eglTestCtx,EGLenum syncType)1641 GetSyncInvalidValueTest (EglTestContext& eglTestCtx, EGLenum syncType)
1642 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR,"get_invalid_value", "get_invalid_value")
1643 {
1644 }
1645
1646 template <typename createSyncFuncType,
1647 typename getSyncAttribFuncType, typename valueType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,getSyncAttribFuncType getSyncAttribFunc,EGLint attribute,const string & attributeName,valueType value)1648 void test(string funcNames[FUNC_NAME_NUM_NAMES],
1649 createSyncFuncType createSyncFunc,
1650 getSyncAttribFuncType getSyncAttribFunc,
1651 EGLint attribute, const string &attributeName,
1652 valueType value)
1653 {
1654 // Reset before each test
1655 deinit();
1656 init();
1657
1658 const Library& egl = m_eglTestCtx.getLibrary();
1659 TestLog& log = m_testCtx.getLog();
1660 string createSyncMsgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
1661
1662 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
1663 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
1664 "(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
1665 TestLog::EndMessage;
1666 EGLU_CHECK_MSG(egl, createSyncMsgChk.c_str());
1667
1668 EGLBoolean result = (egl.*getSyncAttribFunc)(m_eglDisplay, NULL, attribute, &value);
1669 log << TestLog::Message << result << " = " << funcNames[FUNC_NAME_GET_SYNC_ATTRIB] <<
1670 "(" << m_eglDisplay << ", " << 0x0 << ", " << attributeName << ", " << &value << ")" <<
1671 TestLog::EndMessage;
1672
1673 EGLint error = egl.getError();
1674 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
1675
1676 if (error != EGL_BAD_PARAMETER)
1677 {
1678 log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) <<
1679 "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage;
1680 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1681 return;
1682 }
1683
1684 TCU_CHECK(result == EGL_FALSE);
1685 }
1686
iterate(void)1687 IterateResult iterate (void)
1688 {
1689 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1690
1691 if (hasRequiredEGLVersion(1, 5))
1692 {
1693 EGLAttrib value = 0;
1694 test<createSync, getSyncAttrib>(m_funcNames, &Library::createSync,
1695 &Library::getSyncAttrib,
1696 EGL_SYNC_TYPE, "EGL_SYNC_TYPE", value);
1697 }
1698 if (hasEGLFenceSyncExtension())
1699 {
1700 EGLint value = 0;
1701 test<createSyncKHR, getSyncAttribKHR>(m_funcNamesKHR, &Library::createSyncKHR,
1702 &Library::getSyncAttribKHR,
1703 EGL_SYNC_TYPE_KHR, "EGL_SYNC_TYPE_KHR", value);
1704 }
1705 else if (!hasRequiredEGLVersion(1, 5))
1706 {
1707 TCU_THROW(NotSupportedError, "Required extensions not supported");
1708 }
1709
1710 return STOP;
1711 }
1712 };
1713
1714 class DestroySyncTest : public SyncTest
1715 {
1716 public:
DestroySyncTest(EglTestContext & eglTestCtx,EGLenum syncType)1717 DestroySyncTest (EglTestContext& eglTestCtx, EGLenum syncType)
1718 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR,"destroy", "destroy")
1719 {
1720 }
1721
1722 template <typename createSyncFuncType,
1723 typename destroySyncFuncType,
1724 typename getSyncSyncValueType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,destroySyncFuncType destroySyncFunc,getSyncSyncValueType syncValue)1725 void test(string funcNames[FUNC_NAME_NUM_NAMES],
1726 createSyncFuncType createSyncFunc,
1727 destroySyncFuncType destroySyncFunc,
1728 getSyncSyncValueType syncValue)
1729 {
1730 // Reset before each test
1731 deinit();
1732 init();
1733
1734 const Library& egl = m_eglTestCtx.getLibrary();
1735 TestLog& log = m_testCtx.getLog();
1736 string createSyncMsgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
1737
1738 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
1739 log << TestLog::Message << funcNames[FUNC_NAME_CREATE_SYNC] << "(" <<
1740 m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
1741 TestLog::EndMessage;
1742 EGLU_CHECK_MSG(egl, createSyncMsgChk.c_str());
1743
1744 log << TestLog::Message << funcNames[FUNC_NAME_DESTROY_SYNC] << "(" <<
1745 m_eglDisplay << ", " << m_sync << ")" << TestLog::EndMessage;
1746 EGLU_CHECK_CALL_FPTR(egl, (egl.*destroySyncFunc)(m_eglDisplay, m_sync));
1747 m_sync = syncValue;
1748 }
1749
iterate(void)1750 IterateResult iterate (void)
1751 {
1752 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1753
1754 if (hasRequiredEGLVersion(1, 5))
1755 {
1756 test<createSync, destroySync, EGLSync>(m_funcNames,
1757 &Library::createSync,
1758 &Library::destroySync,
1759 EGL_NO_SYNC);
1760 }
1761 if (hasEGLFenceSyncExtension())
1762 {
1763 test<createSyncKHR, destroySyncKHR, EGLSyncKHR>(m_funcNamesKHR,
1764 &Library::createSyncKHR,
1765 &Library::destroySyncKHR,
1766 EGL_NO_SYNC_KHR);
1767 }
1768 else if (!hasRequiredEGLVersion(1, 5))
1769 {
1770 TCU_THROW(NotSupportedError, "Required extensions not supported");
1771 }
1772
1773 return STOP;
1774 }
1775 };
1776
1777 class DestroySyncInvalidDislayTest : public SyncTest
1778 {
1779 public:
DestroySyncInvalidDislayTest(EglTestContext & eglTestCtx,EGLenum syncType)1780 DestroySyncInvalidDislayTest (EglTestContext& eglTestCtx, EGLenum syncType)
1781 : SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR,"destroy_invalid_display", "destroy_invalid_display")
1782 {
1783 }
1784
1785 template <typename createSyncFuncType, typename destroySyncFuncType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,destroySyncFuncType destroySyncFunc)1786 void test(string funcNames[FUNC_NAME_NUM_NAMES],
1787 createSyncFuncType createSyncFunc,
1788 destroySyncFuncType destroySyncFunc)
1789 {
1790 // Reset before each test
1791 deinit();
1792 init();
1793
1794 const Library& egl = m_eglTestCtx.getLibrary();
1795 TestLog& log = m_testCtx.getLog();
1796 string createSyncMsgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
1797
1798 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
1799 log << TestLog::Message << funcNames[FUNC_NAME_CREATE_SYNC] << "(" <<
1800 m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
1801 TestLog::EndMessage;
1802 EGLU_CHECK_MSG(egl, createSyncMsgChk.c_str());
1803
1804 EGLBoolean result = (egl.*destroySyncFunc)(EGL_NO_DISPLAY, m_sync);
1805 log << TestLog::Message << result << " = " << funcNames[FUNC_NAME_DESTROY_SYNC] <<
1806 "(EGL_NO_DISPLAY, " << m_sync << ")" << TestLog::EndMessage;
1807
1808 EGLint error = egl.getError();
1809 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
1810
1811 if (error != EGL_BAD_DISPLAY)
1812 {
1813 log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) <<
1814 "' expected EGL_BAD_DISPLAY" << TestLog::EndMessage;
1815 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1816 return;
1817 }
1818
1819 TCU_CHECK(result == EGL_FALSE);
1820 }
1821
iterate(void)1822 IterateResult iterate (void)
1823 {
1824 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1825
1826 if (hasRequiredEGLVersion(1, 5))
1827 {
1828 test<createSync, destroySync>(m_funcNames,
1829 &Library::createSync,
1830 &Library::destroySync);
1831 }
1832 if (hasEGLFenceSyncExtension())
1833 {
1834 test<createSyncKHR, destroySyncKHR>(m_funcNamesKHR,
1835 &Library::createSyncKHR,
1836 &Library::destroySyncKHR);
1837 }
1838 else if (!hasRequiredEGLVersion(1, 5))
1839 {
1840 TCU_THROW(NotSupportedError, "Required extensions not supported");
1841 }
1842
1843 return STOP;
1844 }
1845 };
1846
1847 class DestroySyncInvalidSyncTest : public SyncTest
1848 {
1849 public:
DestroySyncInvalidSyncTest(EglTestContext & eglTestCtx,EGLenum syncType)1850 DestroySyncInvalidSyncTest (EglTestContext& eglTestCtx, EGLenum syncType)
1851 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR,"destroy_invalid_sync", "destroy_invalid_sync")
1852 {
1853 }
1854
1855 template <typename destroySyncFuncType, typename getSyncSyncValueType>
test(string funcNames[FUNC_NAME_NUM_NAMES],destroySyncFuncType destroySyncFunc,getSyncSyncValueType syncValue)1856 void test(string funcNames[FUNC_NAME_NUM_NAMES],
1857 destroySyncFuncType destroySyncFunc,
1858 getSyncSyncValueType syncValue)
1859 {
1860 // Reset before each test
1861 deinit();
1862 init();
1863
1864 const Library& egl = m_eglTestCtx.getLibrary();
1865 TestLog& log = m_testCtx.getLog();
1866
1867 EGLBoolean result = (egl.*destroySyncFunc)(m_eglDisplay, syncValue);
1868 log << TestLog::Message << result << " = " << funcNames[FUNC_NAME_DESTROY_SYNC] <<
1869 "(" << m_eglDisplay << ", " << syncValue << ")" << TestLog::EndMessage;
1870
1871 EGLint error = egl.getError();
1872 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
1873
1874 if (error != EGL_BAD_PARAMETER)
1875 {
1876 log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) <<
1877 "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage;
1878 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1879 return;
1880 }
1881
1882 TCU_CHECK(result == EGL_FALSE);
1883 }
1884
iterate(void)1885 IterateResult iterate (void)
1886 {
1887 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1888
1889 if (hasRequiredEGLVersion(1, 5))
1890 {
1891 test<destroySync, EGLSync>(m_funcNames,
1892 &Library::destroySync,
1893 EGL_NO_SYNC);
1894 }
1895 if (hasEGLFenceSyncExtension())
1896 {
1897 test<destroySyncKHR, EGLSyncKHR>(m_funcNamesKHR,
1898 &Library::destroySyncKHR,
1899 EGL_NO_SYNC_KHR);
1900 }
1901 else if (!hasRequiredEGLVersion(1, 5))
1902 {
1903 TCU_THROW(NotSupportedError, "Required extensions not supported");
1904 }
1905
1906 return STOP;
1907 }
1908 };
1909
1910 class WaitSyncTest : public SyncTest
1911 {
1912 public:
WaitSyncTest(EglTestContext & eglTestCtx,EGLenum syncType)1913 WaitSyncTest (EglTestContext& eglTestCtx, EGLenum syncType)
1914 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_WAIT_SYNC, true, "wait_server", "wait_server")
1915 {
1916 }
1917
1918 template <typename createSyncFuncType,
1919 typename waitSyncFuncType,
1920 typename waitSyncStatusType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,waitSyncFuncType waitSyncFunc)1921 void test(string funcNames[FUNC_NAME_NUM_NAMES],
1922 createSyncFuncType createSyncFunc,
1923 waitSyncFuncType waitSyncFunc)
1924 {
1925 // Reset before each test
1926 deinit();
1927 init();
1928
1929 const Library& egl = m_eglTestCtx.getLibrary();
1930 TestLog& log = m_testCtx.getLog();
1931 string msgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
1932
1933 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
1934 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
1935 "(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
1936 TestLog::EndMessage;
1937 EGLU_CHECK_MSG(egl, msgChk.c_str());
1938
1939 waitSyncStatusType status = (egl.*waitSyncFunc)(m_eglDisplay, m_sync, 0);
1940 log << TestLog::Message << status << " = " << funcNames[FUNC_NAME_WAIT_SYNC] << "(" <<
1941 m_eglDisplay << ", " << m_sync << ", 0, 0)" << TestLog::EndMessage;
1942
1943 TCU_CHECK(status == EGL_TRUE);
1944
1945 GLU_CHECK_GLW_CALL(m_gl, finish());
1946 }
1947
1948
iterate(void)1949 IterateResult iterate (void)
1950 {
1951 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1952
1953 if (hasRequiredEGLVersion(1, 5))
1954 {
1955 test<createSync, waitSync, EGLBoolean>(m_funcNames,
1956 &Library::createSync,
1957 &Library::waitSync);
1958 }
1959 if (hasEGLWaitSyncExtension())
1960 {
1961 test<createSyncKHR, waitSyncKHR, EGLint>(m_funcNamesKHR,
1962 &Library::createSyncKHR,
1963 &Library::waitSyncKHR);
1964 }
1965 else if (!hasRequiredEGLVersion(1, 5))
1966 {
1967 TCU_THROW(NotSupportedError, "Required extensions not supported");
1968 }
1969
1970 return STOP;
1971 }
1972
1973 };
1974
1975 class WaitSyncInvalidDisplayTest : public SyncTest
1976 {
1977 public:
WaitSyncInvalidDisplayTest(EglTestContext & eglTestCtx,EGLenum syncType)1978 WaitSyncInvalidDisplayTest (EglTestContext& eglTestCtx, EGLenum syncType)
1979 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_WAIT_SYNC, true, "wait_server_invalid_display", "wait_server_invalid_display")
1980 {
1981 }
1982
1983 template <typename createSyncFuncType,
1984 typename waitSyncFuncType,
1985 typename waitSyncStatusType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,waitSyncFuncType waitSyncFunc)1986 void test(string funcNames[FUNC_NAME_NUM_NAMES],
1987 createSyncFuncType createSyncFunc,
1988 waitSyncFuncType waitSyncFunc)
1989 {
1990 // Reset before each test
1991 deinit();
1992 init();
1993
1994 const Library& egl = m_eglTestCtx.getLibrary();
1995 TestLog& log = m_testCtx.getLog();
1996 string msgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
1997
1998 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
1999 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
2000 "(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
2001 TestLog::EndMessage;
2002 EGLU_CHECK_MSG(egl, msgChk.c_str());
2003
2004 waitSyncStatusType status = (egl.*waitSyncFunc)(EGL_NO_DISPLAY, m_sync, 0);
2005 log << TestLog::Message << status << " = " << funcNames[FUNC_NAME_WAIT_SYNC] <<
2006 "(EGL_NO_DISPLAY, " << m_sync << ", 0)" << TestLog::EndMessage;
2007
2008 EGLint error = egl.getError();
2009 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
2010
2011 if (error != EGL_BAD_DISPLAY)
2012 {
2013 log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) <<
2014 "' expected EGL_BAD_DISPLAY" << TestLog::EndMessage;
2015 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
2016 return;
2017 }
2018
2019 TCU_CHECK(status == EGL_FALSE);
2020 }
2021
iterate(void)2022 IterateResult iterate (void)
2023 {
2024 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2025
2026 if (hasRequiredEGLVersion(1, 5))
2027 {
2028 test<createSync, waitSync, EGLBoolean>(m_funcNames,
2029 &Library::createSync,
2030 &Library::waitSync);
2031 }
2032 if (hasEGLWaitSyncExtension())
2033 {
2034 test<createSyncKHR, waitSyncKHR, EGLint>(m_funcNamesKHR,
2035 &Library::createSyncKHR,
2036 &Library::waitSyncKHR);
2037 }
2038 else if (!hasRequiredEGLVersion(1, 5))
2039 {
2040 TCU_THROW(NotSupportedError, "Required extensions not supported");
2041 }
2042
2043 return STOP;
2044 }
2045 };
2046
2047 class WaitSyncInvalidSyncTest : public SyncTest
2048 {
2049 public:
WaitSyncInvalidSyncTest(EglTestContext & eglTestCtx,EGLenum syncType)2050 WaitSyncInvalidSyncTest (EglTestContext& eglTestCtx, EGLenum syncType)
2051 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_WAIT_SYNC, true, "wait_server_invalid_sync", "wait_server_invalid_sync")
2052 {
2053 }
2054
2055 template <typename waitSyncFuncType, typename waitSyncSyncType>
test(string funcNames[FUNC_NAME_NUM_NAMES],waitSyncFuncType waitSyncFunc,waitSyncSyncType syncValue)2056 void test(string funcNames[FUNC_NAME_NUM_NAMES],
2057 waitSyncFuncType waitSyncFunc,
2058 waitSyncSyncType syncValue)
2059 {
2060 // Reset before each test
2061 deinit();
2062 init();
2063
2064 const Library& egl = m_eglTestCtx.getLibrary();
2065 TestLog& log = m_testCtx.getLog();
2066
2067 EGLint status = (egl.*waitSyncFunc)(m_eglDisplay, syncValue, 0);
2068 log << TestLog::Message << status << " = " << funcNames[FUNC_NAME_WAIT_SYNC] <<
2069 "(" << m_eglDisplay << ", " << syncValue << ", 0)" << TestLog::EndMessage;
2070
2071 EGLint error = egl.getError();
2072 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
2073
2074 if (error != EGL_BAD_PARAMETER)
2075 {
2076 log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) <<
2077 "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage;
2078 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
2079 return;
2080 }
2081
2082 TCU_CHECK(status == EGL_FALSE);
2083 }
2084
iterate(void)2085 IterateResult iterate (void)
2086 {
2087 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2088
2089 if (hasRequiredEGLVersion(1, 5))
2090 {
2091 test<waitSync, EGLSync>(m_funcNames,
2092 &Library::waitSync,
2093 EGL_NO_SYNC);
2094 }
2095 if (hasEGLWaitSyncExtension())
2096 {
2097 test<waitSyncKHR, EGLSyncKHR>(m_funcNamesKHR,
2098 &Library::waitSyncKHR,
2099 EGL_NO_SYNC_KHR);
2100 }
2101 else if (!hasRequiredEGLVersion(1, 5))
2102 {
2103 TCU_THROW(NotSupportedError, "Required extensions not supported");
2104 }
2105
2106 return STOP;
2107 }
2108 };
2109
2110 class WaitSyncInvalidFlagTest : public SyncTest
2111 {
2112 public:
WaitSyncInvalidFlagTest(EglTestContext & eglTestCtx,EGLenum syncType)2113 WaitSyncInvalidFlagTest (EglTestContext& eglTestCtx, EGLenum syncType)
2114 : SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_WAIT_SYNC, true, "wait_server_invalid_flag", "wait_server_invalid_flag")
2115 {
2116 }
2117
2118 template <typename createSyncFuncType, typename waitSyncFuncType>
test(string funcNames[FUNC_NAME_NUM_NAMES],createSyncFuncType createSyncFunc,waitSyncFuncType waitSyncFunc)2119 void test(string funcNames[FUNC_NAME_NUM_NAMES],
2120 createSyncFuncType createSyncFunc,
2121 waitSyncFuncType waitSyncFunc)
2122 {
2123 // Reset before each test
2124 deinit();
2125 init();
2126
2127 const Library& egl = m_eglTestCtx.getLibrary();
2128 TestLog& log = m_testCtx.getLog();
2129 string createSyncMsgChk = funcNames[FUNC_NAME_CREATE_SYNC] + "()";
2130
2131 m_sync = (egl.*createSyncFunc)(m_eglDisplay, m_syncType, NULL);
2132 log << TestLog::Message << m_sync << " = " << funcNames[FUNC_NAME_CREATE_SYNC] <<
2133 "(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" <<
2134 TestLog::EndMessage;
2135 EGLU_CHECK_MSG(egl, createSyncMsgChk.c_str());
2136
2137 EGLint status = (egl.*waitSyncFunc)(m_eglDisplay, m_sync, 0xFFFFFFFF);
2138 log << TestLog::Message << status << " = " << funcNames[FUNC_NAME_WAIT_SYNC] <<
2139 "(" << m_eglDisplay << ", " << m_sync << ", 0xFFFFFFFF)" << TestLog::EndMessage;
2140
2141 EGLint error = egl.getError();
2142 log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage;
2143
2144 if (error != EGL_BAD_PARAMETER)
2145 {
2146 log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) <<
2147 "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage;
2148 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
2149 return;
2150 }
2151
2152 TCU_CHECK(status == EGL_FALSE);
2153 }
2154
iterate(void)2155 IterateResult iterate (void)
2156 {
2157 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2158
2159 if (hasRequiredEGLVersion(1, 5))
2160 {
2161 test<createSync, waitSync>(m_funcNames,
2162 &Library::createSync,
2163 &Library::waitSync);
2164 }
2165 if (hasEGLWaitSyncExtension())
2166 {
2167 test<createSyncKHR, waitSyncKHR>(m_funcNamesKHR,
2168 &Library::createSyncKHR,
2169 &Library::waitSyncKHR);
2170 }
2171 else if (!hasRequiredEGLVersion(1, 5))
2172 {
2173 TCU_THROW(NotSupportedError, "Required extensions not supported");
2174 }
2175
2176 return STOP;
2177 }
2178 };
2179
FenceSyncTests(EglTestContext & eglTestCtx)2180 FenceSyncTests::FenceSyncTests (EglTestContext& eglTestCtx)
2181 : TestCaseGroup (eglTestCtx, "fence_sync", "EGL_KHR_fence_sync extension tests")
2182 {
2183 }
2184
init(void)2185 void FenceSyncTests::init (void)
2186 {
2187 // Add valid API test
2188 {
2189 TestCaseGroup* const valid = new TestCaseGroup(m_eglTestCtx, "valid", "Valid function calls");
2190
2191 // eglCreateSyncKHR tests
2192 valid->addChild(new CreateNullAttribsTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2193 valid->addChild(new CreateEmptyAttribsTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2194
2195 // eglClientWaitSyncKHR tests
2196 valid->addChild(new ClientWaitNoTimeoutTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2197 valid->addChild(new ClientWaitForeverTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2198 valid->addChild(new ClientWaitNoContextTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2199 valid->addChild(new ClientWaitForeverFlushTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2200
2201 // eglGetSyncAttribKHR tests
2202 valid->addChild(new GetSyncTypeTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2203 valid->addChild(new GetSyncStatusTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2204 valid->addChild(new GetSyncStatusSignaledTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2205 valid->addChild(new GetSyncConditionTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2206
2207 // eglDestroySyncKHR tests
2208 valid->addChild(new DestroySyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2209
2210 // eglWaitSyncKHR tests
2211 valid->addChild(new WaitSyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2212
2213 addChild(valid);
2214 }
2215
2216 // Add negative API tests
2217 {
2218 TestCaseGroup* const invalid = new TestCaseGroup(m_eglTestCtx, "invalid", "Invalid function calls");
2219
2220 // eglCreateSyncKHR tests
2221 invalid->addChild(new CreateInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2222 invalid->addChild(new CreateInvalidTypeTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2223 invalid->addChild(new CreateInvalidAttribsTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2224 invalid->addChild(new CreateInvalidContextTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2225
2226 // eglClientWaitSyncKHR tests
2227 invalid->addChild(new ClientWaitInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2228 invalid->addChild(new ClientWaitInvalidSyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2229
2230 // eglGetSyncAttribKHR tests
2231 invalid->addChild(new GetSyncInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2232 invalid->addChild(new GetSyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2233 invalid->addChild(new GetSyncInvalidAttributeTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2234 invalid->addChild(new GetSyncInvalidValueTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2235
2236 // eglDestroySyncKHR tests
2237 invalid->addChild(new DestroySyncInvalidDislayTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2238 invalid->addChild(new DestroySyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2239
2240 // eglWaitSyncKHR tests
2241 invalid->addChild(new WaitSyncInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2242 invalid->addChild(new WaitSyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2243 invalid->addChild(new WaitSyncInvalidFlagTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR));
2244
2245 addChild(invalid);
2246 }
2247 }
2248
ReusableSyncTests(EglTestContext & eglTestCtx)2249 ReusableSyncTests::ReusableSyncTests (EglTestContext& eglTestCtx)
2250 : TestCaseGroup (eglTestCtx, "reusable_sync", "EGL_KHR_reusable_sync extension tests")
2251 {
2252 }
2253
init(void)2254 void ReusableSyncTests::init (void)
2255 {
2256 // Add valid API test
2257 {
2258 TestCaseGroup* const valid = new TestCaseGroup(m_eglTestCtx, "valid", "Valid function calls");
2259
2260 // eglCreateSyncKHR tests
2261 valid->addChild(new CreateNullAttribsTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2262 valid->addChild(new CreateEmptyAttribsTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2263
2264 // eglClientWaitSyncKHR tests
2265 valid->addChild(new ClientWaitNoTimeoutTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2266 valid->addChild(new ClientWaitForeverTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2267 valid->addChild(new ClientWaitNoContextTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2268 valid->addChild(new ClientWaitForeverFlushTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2269
2270 // eglGetSyncAttribKHR tests
2271 valid->addChild(new GetSyncTypeTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2272 valid->addChild(new GetSyncStatusTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2273 valid->addChild(new GetSyncStatusSignaledTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2274
2275 // eglDestroySyncKHR tests
2276 valid->addChild(new DestroySyncTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2277
2278 addChild(valid);
2279 }
2280
2281 // Add negative API tests
2282 {
2283 TestCaseGroup* const invalid = new TestCaseGroup(m_eglTestCtx, "invalid", "Invalid function calls");
2284
2285 // eglCreateSyncKHR tests
2286 invalid->addChild(new CreateInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2287 invalid->addChild(new CreateInvalidTypeTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2288 invalid->addChild(new CreateInvalidAttribsTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2289
2290 // eglClientWaitSyncKHR tests
2291 invalid->addChild(new ClientWaitInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2292 invalid->addChild(new ClientWaitInvalidSyncTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2293
2294 // eglGetSyncAttribKHR tests
2295 invalid->addChild(new GetSyncInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2296 invalid->addChild(new GetSyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2297 invalid->addChild(new GetSyncInvalidAttributeTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2298 invalid->addChild(new GetSyncInvalidValueTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2299
2300 // eglDestroySyncKHR tests
2301 invalid->addChild(new DestroySyncInvalidDislayTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2302 invalid->addChild(new DestroySyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2303
2304 // eglWaitSyncKHR tests
2305 invalid->addChild(new WaitSyncInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2306 invalid->addChild(new WaitSyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR));
2307
2308 addChild(invalid);
2309 }
2310 }
2311
2312 } // egl
2313 } // deqp
2314
2315