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