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