PIGLIT_GL_TEST_CONFIG_END #define DRM_FORMAT_INVALID fourcc_code('F', 'O', 'O', '0') static bool test_excess_attributes(unsigned w, unsigned h, int fd, unsigned stride, unsigned offset, EGLint attr_id, EGLint attr_val) { const EGLint excess_attr[2 * 7 + 1] = { EGL_HEIGHT, w, EGL_WIDTH, h, EGL_LINUX_DRM_FOURCC_EXT, DRM_FORMAT_ARGB8888, EGL_DMA_BUF_PLANE0_FD_EXT, fd, EGL_DMA_BUF_PLANE0_OFFSET_EXT, offset, EGL_DMA_BUF_PLANE0_PITCH_EXT, stride, attr_id, attr_val, EGL_NONE }; EGLImageKHR img = eglCreateImageKHR(eglGetCurrentDisplay(), EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, (EGLClientBuffer)NULL, excess_attr); if (!piglit_check_egl_error(EGL_BAD_ATTRIBUTE)) { if (img) eglDestroyImageKHR(eglGetCurrentDisplay(), img); return false; } return true; }
static bool test_buffer_not_null(unsigned w, unsigned h, int fd, unsigned stride, unsigned offset) { EGLImageKHR img; EGLint attr[] = { EGL_WIDTH, w, EGL_HEIGHT, h, EGL_LINUX_DRM_FOURCC_EXT, DRM_FORMAT_ARGB8888, EGL_DMA_BUF_PLANE0_FD_EXT, fd, EGL_DMA_BUF_PLANE0_OFFSET_EXT, offset, EGL_DMA_BUF_PLANE0_PITCH_EXT, stride, EGL_NONE }; /** * The spec says: * * "If <target> is EGL_LINUX_DMA_BUF_EXT, <dpy> must be a valid * display, <ctx> must be EGL_NO_CONTEXT, and <buffer> must be * NULL, cast into the type EGLClientBuffer." */ img = eglCreateImageKHR(eglGetCurrentDisplay(), EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, (EGLClientBuffer)1, attr); if (!piglit_check_egl_error(EGL_BAD_PARAMETER)) { if (img) eglDestroyImageKHR(eglGetCurrentDisplay(), img); return false; } return true; }
static bool test_pitch_zero(unsigned w, unsigned h, int fd, unsigned stride, unsigned offset) { EGLImageKHR img; EGLint attr[] = { EGL_WIDTH, w, EGL_HEIGHT, h, EGL_LINUX_DRM_FOURCC_EXT, DRM_FORMAT_ARGB8888, EGL_DMA_BUF_PLANE0_FD_EXT, fd, EGL_DMA_BUF_PLANE0_OFFSET_EXT, offset, EGL_DMA_BUF_PLANE0_PITCH_EXT, 0, EGL_NONE }; img = eglCreateImageKHR(eglGetCurrentDisplay(), EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, (EGLClientBuffer)0, attr); if (!piglit_check_egl_error(EGL_BAD_ACCESS)) { if (img) eglDestroyImageKHR(eglGetCurrentDisplay(), img); return false; } return true; }
/** * Verify that eglCreateSyncKHR emits correct error when no context is current. * * From the EGL_KHR_fence_sync spec: * * If <type> is EGL_SYNC_FENCE_KHR and no context is current for * the bound API (i.e., eglGetCurrentContext returns * EGL_NO_CONTEXT), EGL_NO_SYNC_KHR is returned and an * EGL_BAD_MATCH error is generated. */ static enum piglit_result test_eglCreateSyncKHR_no_current_context(void *test_data) { enum piglit_result result = PIGLIT_PASS; EGLSyncKHR sync = 0; result = test_setup(); if (result != PIGLIT_PASS) { return result; } eglMakeCurrent(g_dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); sync = peglCreateSyncKHR(g_dpy, EGL_SYNC_TYPE_KHR, NULL); if (sync) { piglit_loge("eglCreateSyncKHR() succeeded when no context was " "current"); peglDestroySyncKHR(g_dpy, sync); result = PIGLIT_FAIL; } if (!piglit_check_egl_error(EGL_BAD_MATCH)) { piglit_loge("eglCreateSyncKHR emitted wrong error"); result = PIGLIT_FAIL; } test_cleanup(sync, &result); return result; }
/** * Verify that eglDestroySyncKHR() emits the correct error when given an * invalid sync object. * * From the EGL_KHR_fence_sync spec: * * * If <sync> is not a valid sync object for <dpy>, EGL_FALSE is * returned and an EGL_BAD_PARAMETER error is generated. */ static enum piglit_result test_eglDestroySyncKHR_invalid_sync(void *test_data) { enum piglit_result result = PIGLIT_PASS; bool ok = false; EGLSyncKHR invalid_sync = (EGLSyncKHR) &canary; result = test_setup(); if (result != PIGLIT_PASS) { return result; } ok = peglDestroySyncKHR(g_dpy, invalid_sync); if (ok) { piglit_loge("eglDestroySyncKHR() succeeded when given invalid " "sync object"); result = PIGLIT_FAIL; } if (!piglit_check_egl_error(EGL_BAD_PARAMETER)) { piglit_loge("eglGetSyncAttribKHR(EGL_SYNC_TYPE_KHR) emitted " "an incorrect error"); result = PIGLIT_FAIL; } test_cleanup(EGL_NO_SYNC_KHR, &result); return result; }
enum piglit_result piglit_display(void) { const unsigned w = 2; const unsigned h = 2; const unsigned cpp = 4; const unsigned fourcc = DRM_FORMAT_ARGB8888; const unsigned char *pixels = alloca(w * h * cpp); struct piglit_dma_buf *buf; EGLImageKHR img; enum piglit_result res; bool pass = true; res = piglit_create_dma_buf(w, h, fourcc, pixels, &buf); if (res != PIGLIT_PASS) return res; img = create_image(w, h, buf->fd, buf->stride[0], buf->offset[0]); if (!img) { piglit_destroy_dma_buf(buf); /* unsupported format (BAD_MATCH) is not an error. */ return piglit_check_egl_error(EGL_BAD_MATCH) ? PIGLIT_SKIP : PIGLIT_FAIL; } pass = try_as_texture_2d(img) && pass; pass = try_as_render_buffer(img) && pass; eglDestroyImageKHR(eglGetCurrentDisplay(), img); piglit_destroy_dma_buf(buf); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
/** * Verify that eglClientWaitSyncKHR() emits correct error when given an invalid * sync object. * * From the EGL_KHR_fence_sync: * * * If <sync> is not a valid sync object for <dpy>, EGL_FALSE is * returned and an EGL_BAD_PARAMETER error is generated. */ static enum piglit_result test_eglClientWaitSyncKHR_invalid_sync(void *test_data) { enum piglit_result result = PIGLIT_PASS; EGLint wait_status = 0; EGLSyncKHR invalid_sync = (EGLSyncKHR) &canary; result = test_setup(); if (result != PIGLIT_PASS) { return result; } wait_status = peglClientWaitSyncKHR(g_dpy, invalid_sync, 0, 0); if (wait_status != EGL_FALSE) { piglit_loge("Given an invalid sync object, eglClientWaitSyncKHR() " "should return EGL_FALSE, but returned 0x%x", wait_status); result = PIGLIT_FAIL; } if (!piglit_check_egl_error(EGL_BAD_PARAMETER)) { piglit_loge("Given an invalid sync object, eglClientWaitSyncKHR() " "did not emit EGL_BAD_PARAMETER"); result = PIGLIT_FAIL; } test_cleanup(EGL_NO_SYNC_KHR, &result); return result; }
static bool try_attribute(int attribute) { const EGLint attribs[] = { attribute, EGL_NONE }; bool pass = true; ctx = eglCreateContext(egl_dpy, cfg, EGL_NO_CONTEXT, attribs); if (ctx != NULL) { fprintf(stderr, "Created OpenGL context with invalid attribute " "0x%08x, but this should have failed.\n", attribute); eglDestroyContext(egl_dpy, ctx); pass = false; } /* The EGL_KHR_create_context spec says: * * "* If an attribute name or attribute value in <attrib_list> is not * recognized (including unrecognized bits in bitmask attributes), * then an EGL_BAD_ATTRIBUTE error is generated." */ if (!piglit_check_egl_error(EGL_BAD_ATTRIBUTE)) piglit_report_result(PIGLIT_FAIL); return pass; }
/** * Verify that eglCreateSyncKHR emits correct error when given an invalid * attribute list. * * From the EGL_KHR_fence_sync spec: * * If <attrib_list> is neither NULL nor empty (containing only * EGL_NONE), EGL_NO_SYNC_KHR is returned and an EGL_BAD_ATTRIBUTE * error is generated. */ static enum piglit_result test_eglCreateSyncKHR_invalid_attrib_list(void *test_data) { enum piglit_result result = PIGLIT_PASS; EGLSyncKHR sync = 0; const EGLint attrib_list[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE, }; result = test_setup(); if (result != PIGLIT_PASS) { return result; } sync = peglCreateSyncKHR(g_dpy, EGL_SYNC_FENCE_KHR, attrib_list); if (sync) { piglit_loge("eglCreateSyncKHR() succeeded with invalid " "attrib list"); result = PIGLIT_FAIL; } if (!piglit_check_egl_error(EGL_BAD_ATTRIBUTE)) { piglit_loge("eglCreateSyncKHR emitted wrong error"); result = PIGLIT_FAIL; } test_cleanup(sync, &result); return result; }
/** * Verify that eglCreateSyncKHR emits correct error when given an invalid * sync type. * * From the EGL_KHR_fence_sync spec: * * If <type> is not a supported type of sync object, * EGL_NO_SYNC_KHR is returned and an EGL_BAD_ATTRIBUTE error is * generated. * * TODO(chadv,joshtriplett): eglCreateSyncKHR should generate EGL_BAD_PARAMETER * TODO: on bad sync types, not EGL_BAD_ATTRIBUTE. Bug filed in Khronos private * TODO: Bugzilla; update the test when resolved. */ static enum piglit_result test_eglCreateSyncKHR_invalid_sync_type(void *test_data) { enum piglit_result result = PIGLIT_PASS; EGLSyncKHR sync = 0; EGLenum bad_sync_type = EGL_SYNC_TYPE_KHR; result = test_setup(); if (result != PIGLIT_PASS) { return result; } sync = peglCreateSyncKHR(g_dpy, bad_sync_type, NULL); if (sync) { piglit_loge("eglCreateSyncKHR() succeeded with invalid " "sync type"); result = PIGLIT_FAIL; } if (!piglit_check_egl_error(EGL_BAD_ATTRIBUTE)) { piglit_loge("eglCreateSyncKHR emitted wrong error"); result = PIGLIT_FAIL; } test_cleanup(sync, &result); return result; }
/** * Verify that eglGetSyncAttribKHR emits the correct error when given an object * that is not a sync object. * * From the EGL_KHR_fence_sync: * * * If <sync> is not a valid sync object for <dpy>, EGL_FALSE is * returned and an EGL_BAD_PARAMETER error is generated. * * [...] * * If any error occurs, <*value> is not modified. */ static enum piglit_result test_eglGetSyncAttribKHR_invalid_sync(void *test_data) { enum piglit_result result = PIGLIT_PASS; bool ok = false; EGLint sync_type = canary; EGLSyncKHR invalid_sync = (EGLSyncKHR) &canary; result = test_setup(); if (result != PIGLIT_PASS) { return result; } ok = peglGetSyncAttribKHR(g_dpy, invalid_sync, EGL_SYNC_TYPE_KHR, &sync_type); if (ok) { piglit_loge("eglGetSyncAttribKHR incorrectly succeeded when " "given an invalid sync object"); result = PIGLIT_FAIL; } if (!piglit_check_egl_error(EGL_BAD_PARAMETER)) { piglit_loge("eglGetSyncAttribKHR emitted wrong error"); result = PIGLIT_FAIL; } if (sync_type != canary) { piglit_loge("eglGetSynAttribKHR modified out parameter <value>"); result = PIGLIT_FAIL; } test_cleanup(EGL_NO_SYNC_KHR, &result); return result; }
/** * Conformance test #2 in the EGL_EXT_client_extensions spec: * * 2. Obtain a display with eglGetDisplay but do not initialize it. Verify * that passing the uninitialized display to `eglQueryString(dpy, * EGL_EXTENSIONS)` returns NULL and generates EGL_NOT_INITIALIZED. */ static void test_2(void) { enum piglit_result result = PIGLIT_PASS; EGLDisplay dpy; const char *display_extensions; dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY); if (!dpy) { printf("Failed to get default display. Skipping.n"); piglit_report_result(PIGLIT_SKIP); } printf("Calling eglQueryString(dpy, EGL_EXTENSIONS) with an " "uninitialized display...\n"); display_extensions = eglQueryString(dpy, EGL_EXTENSIONS); if (display_extensions == NULL) { printf("Correctly returned null extension string\n"); } else { printf("Did not return null extension string\n"); result = PIGLIT_FAIL; } if (!piglit_check_egl_error(EGL_NOT_INITIALIZED)) { result = PIGLIT_FAIL; } piglit_report_result(result); }
static void* thread2_create_sync_with_display_bound_in_other_thread(void *arg) { enum piglit_result *result; EGLDisplay t2_dpy = 0; EGLContext t2_ctx = 0; EGLSyncKHR t2_sync = 0; result = malloc(sizeof(*result)); *result = PIGLIT_FAIL; piglit_logi("create second EGLDisplay"); *result = init_other_display(&t2_dpy, g_dpy); if (*result != PIGLIT_PASS) { piglit_loge("failed to initialize a second EGLDisplay"); goto cleanup; } if (!piglit_is_egl_extension_supported(t2_dpy, "EGL_KHR_fence_sync")) { piglit_loge("EGL_KHR_fence_sync unsupported on second display"); *result = PIGLIT_SKIP; goto cleanup; } piglit_logi("create and make context current on second display"); *result = init_context(t2_dpy, &t2_ctx); if (*result != PIGLIT_PASS) { goto cleanup; } *result = check_sync_in_current_context(); if (*result != PIGLIT_PASS) { goto cleanup; } piglit_logi("try to create sync on first display, which is " "bound on thread1"); t2_sync = peglCreateSyncKHR(t2_dpy, EGL_SYNC_FENCE_KHR, NULL); if (t2_sync) { piglit_loge("eglCreateSyncKHR incorrectly succeeded"); *result = PIGLIT_FAIL; goto cleanup; } if (!piglit_check_egl_error(EGL_BAD_MATCH)) { piglit_loge("eglCreateSyncKHR emitted wrong error"); *result = PIGLIT_FAIL; goto cleanup; } piglit_logi("eglCreateSyncKHR correctly failed with " "EGL_BAD_MATCH"); cleanup: if (t2_dpy) { eglMakeCurrent(t2_dpy, 0, 0, 0); eglTerminate(t2_dpy); } return result; }
/** * Conformance test #1 in the EGL_EXT_client_extensions spec: * * 1. Before any call to eglGetDisplay, call `eglQueryString(EGL_NO_DISPLAY, * EGL_EXTENSIONS)`. Verify that either * * a. The call returns NULL and generates EGL_BAD_DISPLAY. * b. The call returns an extension string that contains, at a minimum, * this extension and generates no error. */ static void test_1(void) { enum piglit_result result = PIGLIT_PASS; const char *client_extensions; printf("Making process's first EGL call, " "eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS) ...\n"); client_extensions = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS); if (client_extensions == NULL) { printf("Returned NULL\n"); if (piglit_check_egl_error(EGL_BAD_DISPLAY)) { printf("And correctly emitted EGL_BAD_DISPLAY\n"); } else { printf("But did not emit EGL_BAD_DISPLAY\n"); result = PIGLIT_FAIL; } } else { printf("Returned a non-null extension string\n"); if (!piglit_check_egl_error(EGL_SUCCESS)) { result = PIGLIT_FAIL; } if (!piglit_is_extension_in_string(client_extensions, "EGL_EXT_client_extensions")) { printf("But it does not contain " "EGL_EXT_client_extensions\n"); result = PIGLIT_FAIL; } else { printf("And contains EGL_EXT_client_extensions " "as expected\n"); } } piglit_report_result(result); }
PIGLIT_GL_TEST_CONFIG_END #define NUM_MANDATORY_ATTRS 6 static bool test_missing(int fd, const EGLint *attr) { EGLImageKHR img; img = eglCreateImageKHR(eglGetCurrentDisplay(), EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, (EGLClientBuffer)NULL, attr); if (!piglit_check_egl_error(EGL_BAD_PARAMETER)) { if (img) eglDestroyImageKHR(eglGetCurrentDisplay(), img); return false; } return true; }
/** * Verify that eglCreateSyncKHR() emits correct error when given a display that * does not match the display of the bound context. * * From the EGL_KHR_fence_sync spec: * * * If <type> is EGL_SYNC_FENCE_KHR and <dpy> does not match the * EGLDisplay of the currently bound context for the currently * bound client API (the EGLDisplay returned by * eglGetCurrentDisplay()) then EGL_NO_SYNC_KHR is returned and an * EGL_BAD_MATCH error is generated. * * This test verifies a simple case for the above error. It binds a context and * display to the main thread, creates a second display on the same threads but * does not bind it, then gives the second display to eglCreateSyncKHR(). */ static enum piglit_result test_eglCreateSyncKHR_wrong_display_same_thread(void *test_data) { enum piglit_result result = PIGLIT_PASS; EGLDisplay wrong_dpy = 0; EGLSyncKHR sync = 0; result = test_setup(); if (result != PIGLIT_PASS) { return result; } piglit_logi("create second EGLDisplay"); result = init_other_display(&wrong_dpy, g_dpy); if (result != PIGLIT_PASS) { goto cleanup; } piglit_require_egl_extension(wrong_dpy, "EGL_KHR_fence_sync"); piglit_logi("try to create sync with second display"); sync = peglCreateSyncKHR(wrong_dpy, EGL_SYNC_FENCE_KHR, NULL); if (sync) { piglit_loge("eglCreateSyncKHR() incorrectly succeeded"); result = PIGLIT_FAIL; goto cleanup; } if (!piglit_check_egl_error(EGL_BAD_MATCH)) { piglit_loge("eglCreateSyncKHR emitted wrong error"); result = PIGLIT_FAIL; goto cleanup; } cleanup: if (wrong_dpy) { eglTerminate(wrong_dpy); } test_cleanup(EGL_NO_SYNC_KHR, &result); return result; }
/** * Teardown state after each subtest completes. */ static void test_cleanup(EGLSyncKHR sync, enum piglit_result *inout_result) { bool ok = false; if (sync) { /* From the EGL_KHR_fence_sync spec: * * If no errors are generated, EGL_TRUE is returned, and * <sync> will no longer be the handle of a valid sync * object. */ ok = peglDestroySyncKHR(g_dpy, sync); if (!ok) { piglit_loge("eglDestroySyncKHR failed"); *inout_result = PIGLIT_FAIL; } if (!piglit_check_egl_error(EGL_SUCCESS)) { piglit_loge("eglDestroySyncKHR emitted an error"); *inout_result = PIGLIT_FAIL; } } /* Ensure that no leftover GL commands impact the next test. */ if (eglGetCurrentContext()) { glFinish(); } if (g_dpy) { eglMakeCurrent(g_dpy, 0, 0, 0); ok = eglTerminate(g_dpy); if (!ok) { piglit_loge("failed to terminate EGLDisplay"); *inout_result = PIGLIT_FAIL; } } g_dpy = EGL_NO_DISPLAY; g_ctx = EGL_NO_CONTEXT; }
/** * Verify that eglGetSyncAttribKHR emits the correct error when querying an * unrecognized attribute of a fence sync. * * From the EGL_KHR_fence_sync: * * [eglGetSyncAttribKHR] is used to query attributes of the sync object * <sync>. Legal values for <attribute> depend on the type of sync object, * as shown in table * 3.cc. [...] * * Attribute Description Supported Sync Objects * ----------------- ----------------------- ---------------------- * EGL_SYNC_TYPE_KHR Type of the sync object All * EGL_SYNC_STATUS_KHR Status of the sync object All * EGL_SYNC_CONDITION_KHR Signaling condition EGL_SYNC_FENCE_KHR only * * Table 3.cc Attributes Accepted by eglGetSyncAttribKHR Command * * [...] * * * If <attribute> is not one of the attributes in table 3.cc, * EGL_FALSE is returned and an EGL_BAD_ATTRIBUTE error is * generated. * * [...] * * If any error occurs, <*value> is not modified. */ static enum piglit_result test_eglGetSyncAttribKHR_invalid_attrib(void *test_data) { enum piglit_result result = PIGLIT_PASS; bool ok = false; EGLSyncKHR sync = 0; EGLint attrib_value = canary; result = test_setup(); if (result != PIGLIT_PASS) { return result; } sync = peglCreateSyncKHR(g_dpy, EGL_SYNC_FENCE_KHR, NULL); if (!sync) { piglit_loge("eglCreateSyncKHR(EGL_SYNC_FENCE_KHR) failed"); result = PIGLIT_FAIL; goto cleanup; } ok = peglGetSyncAttribKHR(g_dpy, sync, EGL_BUFFER_PRESERVED, &attrib_value); if (ok) { piglit_loge("eglGetSyncAttribKHR(attrib=EGL_BUFFER_PRESERVED) " "incorrectly succeeded"); result = PIGLIT_FAIL; } if (!piglit_check_egl_error(EGL_BAD_ATTRIBUTE)) { piglit_loge("eglGetSyncAttribKHR emitted wrong error"); result = PIGLIT_FAIL; } if (attrib_value != canary) { piglit_loge("eglGetSynAttribKHR modified out parameter <value>"); result = PIGLIT_FAIL; } cleanup: test_cleanup(sync, &result); return result; }
/* Test that eglCreatePlatformWindowSurface fails with EGL_BAD_NATIVE_WINDOW. * * From the EGL_MESA_platform_surfaceless spec (v1): * * eglCreatePlatformWindowSurface fails when called with a <display> * that belongs to the surfaceless platform. It returns * EGL_NO_SURFACE and generates EGL_BAD_NATIVE_WINDOW. The * justification for this unconditional failure is that the * surfaceless platform has no native windows, and therefore the * <native_window> parameter is always invalid. */ static enum piglit_result test_create_window(void *test_data) { EGLDisplay dpy; EGLSurface surf; test_setup(&dpy); surf = peglCreatePlatformWindowSurfaceEXT(dpy, EGL_NO_CONFIG_KHR, /*native_window*/ NULL, /*attrib_list*/ NULL); if (surf) { printf("eglCreatePlatformWindowSurface incorrectly succeeded\n"); return PIGLIT_FAIL; } if (!piglit_check_egl_error(EGL_BAD_NATIVE_WINDOW)) return PIGLIT_FAIL; eglTerminate(dpy); return PIGLIT_PASS; }
enum piglit_result piglit_display(void) { const unsigned w = 2; const unsigned h = 2; const unsigned cpp = 4; const unsigned char pixels[w * h * cpp]; struct piglit_dma_buf *buf; unsigned stride; unsigned offset; int fd; EGLImageKHR img; enum piglit_result res; res = piglit_create_dma_buf(w, h, cpp, pixels, w * cpp, &buf, &fd, &stride, &offset); if (res != PIGLIT_PASS) return res; img = create_image(w, h, fd, stride, offset); if (!piglit_check_egl_error(EGL_BAD_MATCH)) { if (img) eglDestroyImageKHR(eglGetCurrentDisplay(), img); return PIGLIT_FAIL; } piglit_destroy_dma_buf(buf); /** * EGL stack can claim the ownership of the file descriptor only when it * succeeds. Close the descriptor and check that it really wasn't closed * by EGL. */ return close(fd) == 0 ? PIGLIT_PASS : PIGLIT_FAIL; }
/** * Verify that glClientWaitSyncKHR emits correct error when given invalid flag. * * From the EGL_KHR_fence_sync spec: * * Accepted in the <flags> parameter of eglClientWaitSyncKHR: * * EGL_SYNC_FLUSH_COMMANDS_BIT_KHR 0x0001 */ static enum piglit_result test_eglClientWaitSyncKHR_invalid_flag(void *test_data) { enum piglit_result result = PIGLIT_PASS; EGLSyncKHR sync = 0; EGLint wait_status = 0; EGLint invalid_flag = 0x8000; result = test_setup(); if (result != PIGLIT_PASS) { return result; } sync = peglCreateSyncKHR(g_dpy, EGL_SYNC_FENCE_KHR, NULL); if (!sync) { piglit_loge("eglCreateSyncKHR(EGL_SYNC_FENCE_KHR) failed"); result = PIGLIT_FAIL; goto cleanup; } /* Use timeout=0 so that eglClientWaitSyncKHR immediately returns. */ wait_status = peglClientWaitSyncKHR(g_dpy, sync, invalid_flag, 0); if (wait_status != EGL_FALSE) { piglit_loge("eglClientWaitSyncKHR succeeded when given invalid " "flag 0x%x", invalid_flag); result = PIGLIT_FAIL; } if (!piglit_check_egl_error(EGL_BAD_PARAMETER)) { piglit_loge("eglClientWaitSyncKHR emitted wrong error"); result = PIGLIT_FAIL; } cleanup: test_cleanup(sync, &result); return result; }
/** * Verify that eglCreateSyncKHR emits correct error when given an invalid * display. * * From the EGL_KHR_fence_sync spec: * * If <dpy> is not the name of a valid, initialized EGLDisplay, * EGL_NO_SYNC_KHR is returned and an EGL_BAD_DISPLAY error is * generated. */ static enum piglit_result test_eglCreateSyncKHR_invalid_display(void *test_data) { enum piglit_result result = PIGLIT_PASS; EGLSyncKHR sync = 0; result = test_setup(); if (result != PIGLIT_PASS) { return result; } sync = peglCreateSyncKHR(EGL_NO_DISPLAY, EGL_SYNC_FENCE_KHR, NULL); if (sync) { piglit_loge("eglCreateSyncKHR(EGL_NO_DISPLAY) succeeded"); result = PIGLIT_FAIL; } if (!piglit_check_egl_error(EGL_BAD_DISPLAY)) { piglit_loge("eglCreateSyncKHR emitted wrong error"); result = PIGLIT_FAIL; } test_cleanup(sync, &result); return result; }
/** * Verify that eglGetSyncAttribKHR() reports correct sync status before and * after glFinish(). */ static enum piglit_result test_eglGetSyncAttribKHR_sync_status(void *test_data) { enum piglit_result result = PIGLIT_PASS; EGLSyncKHR sync = 0; EGLint sync_status = 0; bool ok = false; result = test_setup(); if (result != PIGLIT_PASS) { return result; } glClear(GL_COLOR_BUFFER_BIT); sync = peglCreateSyncKHR(g_dpy, EGL_SYNC_FENCE_KHR, NULL); if (!sync) { piglit_loge("eglCreateSyncKHR(EGL_SYNC_FENCE_KHR) failed"); result = PIGLIT_FAIL; goto cleanup; } ok = peglGetSyncAttribKHR(g_dpy, sync, EGL_SYNC_STATUS_KHR, &sync_status); if (!ok) { piglit_loge("before glFinish, eglGetSyncAttribKHR(EGL_SYNC_STATUS_KHR) " "failed"); result = PIGLIT_FAIL; } if (!piglit_check_egl_error(EGL_SUCCESS)) { piglit_loge("before glFinish, eglGetSyncAttribKHR(EGL_SYNC_STATUS_KHR) " "emitted an error"); result = PIGLIT_FAIL; } if (sync_status != EGL_SIGNALED_KHR && sync_status != EGL_UNSIGNALED_KHR) { piglit_loge("before glFinish, eglGetSyncAttribKHR(EGL_SYNC_STATUS_KHR):\n" " Expected status: EGL_SIGNALED_KHR or EGL_UNSIGNALED_KHR\n", " Actual status: 0x%x", sync_status); result = PIGLIT_FAIL; } glFinish(); ok = peglGetSyncAttribKHR(g_dpy, sync, EGL_SYNC_STATUS_KHR, &sync_status); if (!ok) { piglit_loge("after glFinish, eglGetSyncAttribKHR(EGL_SYNC_STATUS_KHR) " "failed"); result = PIGLIT_FAIL; } if (!piglit_check_egl_error(EGL_SUCCESS)) { piglit_loge("after glFinish, eglGetSyncAttribKHR(EGL_SYNC_STATUS_KHR) " "emitted an error"); result = PIGLIT_FAIL; } if (sync_status != EGL_SIGNALED_KHR) { piglit_loge("after glFinish, eglGetSyncAttribKHR(EGL_SYNC_STATUS_KHR):\n" " Expected status: EGL_SIGNALED_KHR\n", " Actual status: 0x%x", sync_status); result = PIGLIT_FAIL; } cleanup: test_cleanup(sync, &result); return result; }
/** * Conformance test #3 in the EGL_EXT_client_extensions spec: * * 3. Obtain a list of display extensions by calling `eglQueryString(dpy, * EGL_EXTENSIONS)` on an initialized display. Obtain the list of client * extensions by calling `eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS)`. * If both calls succeed, verify the two lists are disjoint. * */ static void test_3(void) { enum piglit_result result = PIGLIT_PASS; EGLDisplay dpy; EGLint major_version, minor_version; const char *display_ext_string; const char *client_ext_string; const char **display_ext_array; const char **client_ext_array; int i, j; dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY); if (!dpy) { printf("Failed to get default display. Skipping.\n"); piglit_report_result(PIGLIT_SKIP); } if (!eglInitialize(dpy, &major_version, &minor_version)) { printf("Failed to initialize default display\n"); piglit_report_result(PIGLIT_FAIL); } display_ext_string = eglQueryString(dpy, EGL_EXTENSIONS); if (!piglit_check_egl_error(EGL_SUCCESS)) { printf("eglQueryString(EGL_EXTENSIONS) failed on default " "display\n"); piglit_report_result(PIGLIT_FAIL); } if (!display_ext_string) { printf("eglQueryString(EGL_EXTENSIONS) returned null for " "default display\n"); piglit_report_result(PIGLIT_FAIL); } client_ext_string = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS); if (!client_ext_string) { if (piglit_check_egl_error(EGL_BAD_DISPLAY)) { printf("eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS) " "returned null. Skipping.\n"); piglit_report_result(PIGLIT_SKIP); } else { printf("eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS) " "returned null but did not emit " "EGL_BAD_DISPLAY\n"); piglit_report_result(PIGLIT_FAIL); } abort(); } display_ext_array = piglit_split_string_to_array(display_ext_string, " "); client_ext_array = piglit_split_string_to_array(client_ext_string, " "); /* Check that the two sets of extensions are disjoint. */ for (i = 0; display_ext_array[i] != NULL; ++i) { const char *display_ext = display_ext_array[i]; for (j = 0; client_ext_array[j] != NULL; ++j) { const char *client_ext = client_ext_array[j]; if (strcmp(display_ext, client_ext) == 0) { printf("%s is listed both as a client and " "display extension\n", display_ext); result = PIGLIT_FAIL; } } } piglit_report_result(result); }
static void try_debug_flag(EGLenum context_api, EGLenum context_bit) { GLint actual_flags = 0; piglit_dispatch_api dispatch_api; EGLint attribs[64]; int i = 0; if (!EGL_KHR_create_context_setup(context_bit)) piglit_report_result(PIGLIT_SKIP); if (!piglit_egl_bind_api(context_api)) piglit_report_result(PIGLIT_SKIP); attribs[i++] = EGL_CONTEXT_FLAGS_KHR; attribs[i++] = EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR; switch (context_bit) { case EGL_OPENGL_BIT: break; case EGL_OPENGL_ES_BIT: attribs[i++] = EGL_CONTEXT_MAJOR_VERSION_KHR; attribs[i++] = 1; break; case EGL_OPENGL_ES2_BIT: attribs[i++] = EGL_CONTEXT_MAJOR_VERSION_KHR; attribs[i++] = 2; break; case EGL_OPENGL_ES3_BIT_KHR: attribs[i++] = EGL_CONTEXT_MAJOR_VERSION_KHR; attribs[i++] = 3; break; default: assert(0); break; } attribs[i++] = EGL_NONE; ctx = eglCreateContext(egl_dpy, cfg, EGL_NO_CONTEXT, attribs); if (!ctx) { if (piglit_check_egl_error(EGL_BAD_MATCH)) { piglit_report_result(PIGLIT_SKIP); } else { piglit_report_result(PIGLIT_FAIL); } } if (!eglMakeCurrent(egl_dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, ctx)) { fprintf(stderr, "eglMakeCurrent() failed\n"); piglit_report_result(PIGLIT_FAIL); } switch (context_bit) { case EGL_OPENGL_BIT: dispatch_api = PIGLIT_DISPATCH_GL; break; case EGL_OPENGL_ES_BIT: /* Piglit doesn't yet have ES1 dispatch, so just initialize * with ES2 dispatch. This should be safe because the only * GL functions called by this test are glGetString() and * glGetIntegerv(). */ dispatch_api = PIGLIT_DISPATCH_ES2; break; case EGL_OPENGL_ES2_BIT: case EGL_OPENGL_ES3_BIT_KHR: dispatch_api = PIGLIT_DISPATCH_ES2; break; default: dispatch_api = 0; assert(0); break; } piglit_dispatch_default_init(dispatch_api); switch (context_bit) { case EGL_OPENGL_BIT: if (piglit_get_gl_version() < 31 && !piglit_is_extension_supported("GL_KHR_debug")) { fprintf(stderr, "In OpenGL, either OpenGL 3.1 or " "GL_KHR_debug is required to query " "GL_CONTEXT_FLAGS\n"); piglit_report_result(PIGLIT_SKIP); } break; case EGL_OPENGL_ES_BIT: case EGL_OPENGL_ES2_BIT: case EGL_OPENGL_ES3_BIT_KHR: if (!piglit_is_extension_supported("GL_KHR_debug")) { fprintf(stderr, "In OpenGL ES, GL_KHR_debug is " "required to query GL_CONTEXT_FLAGS\n"); piglit_report_result(PIGLIT_SKIP); } break; default: assert(0); break; } glGetIntegerv(GL_CONTEXT_FLAGS, &actual_flags); if (!piglit_check_gl_error(GL_NO_ERROR)) { fprintf(stderr, "glGetIntegerv(GL_CONTEXT_FLAGS) failed\n"); piglit_report_result(PIGLIT_FAIL); } /* Verify that this is actually a debug context. */ if (!(actual_flags & GL_CONTEXT_FLAG_DEBUG_BIT)) { fprintf(stderr, "GL_CONTEXT_FLAGS=0x%x does not contain " "GL_CONTEXT_FLAG_DEBUG_BIT=0x%x\n", actual_flags, GL_CONTEXT_FLAG_DEBUG_BIT); piglit_report_result(PIGLIT_FAIL); } eglDestroyContext(egl_dpy, ctx); EGL_KHR_create_context_teardown(); piglit_report_result(PIGLIT_PASS); }
static enum piglit_result check_flavor(int requested_version, enum gl_api requested_api) { static bool is_dispatch_init = false; enum piglit_result result = PIGLIT_PASS; int i; const char *api_name = NULL; const char *profile_name = ""; EGLint context_attribs[64]; EGLContext ctx = 0; EGLenum requested_client_type = 0; EGLint actual_client_type = 0; int actual_version = 0; GLint actual_profile = 0; switch (requested_api) { case API_GL_COMPAT: requested_client_type = EGL_OPENGL_API; api_name = "OpenGL"; if (requested_version >= 32) profile_name = "compatibility "; break; case API_GL_CORE: requested_client_type = EGL_OPENGL_API; api_name = "OpenGL"; if (requested_version >= 32) profile_name = "core "; break; case API_GLES1: case API_GLES2: case API_GLES3: requested_client_type = EGL_OPENGL_ES_API; api_name = "OpenGL ES"; break; default: assert(0); break; } printf("info: request an %s %d.%d %scontext\n", api_name, requested_version / 10, requested_version % 10, profile_name); if (!eglBindAPI(requested_client_type)) { /* Assume the driver doesn't support the requested API. */ result = PIGLIT_SKIP; goto cleanup; } i = 0; context_attribs[i++] = EGL_CONTEXT_MAJOR_VERSION_KHR; context_attribs[i++] = requested_version / 10; context_attribs[i++] = EGL_CONTEXT_MINOR_VERSION_KHR; context_attribs[i++] = requested_version % 10; if (requested_api == API_GL_CORE) { context_attribs[i++] = EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR; context_attribs[i++] = EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR; } else if (requested_api == API_GL_COMPAT) { context_attribs[i++] = EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR; context_attribs[i++] = EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR; } context_attribs[i++] = EGL_NONE; ctx = eglCreateContext(egl_dpy, cfg, EGL_NO_CONTEXT, context_attribs); if (ctx == NULL) { printf("%s", "info: context creation failed\n"); if (eglGetError() != EGL_SUCCESS) { result = PIGLIT_SKIP; } else { printf("%s", "error: eglCreateContext failed but " "the EGL error is EGL_SUCCESS\n"); result = PIGLIT_FAIL; } goto cleanup; } if (!piglit_check_egl_error(EGL_SUCCESS)) { result = PIGLIT_FAIL; goto cleanup; } if (!eglMakeCurrent(egl_dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, ctx)) { printf("%s", "error: failed to make context current\n"); goto fail; } if (!is_dispatch_init) { /* We must postpone initialization of piglit-dispatch until * a context is current. */ piglit_dispatch_default_init(PIGLIT_DISPATCH_GL); is_dispatch_init = true; } if (!eglQueryContext(egl_dpy, ctx, EGL_CONTEXT_CLIENT_TYPE, &actual_client_type)) { printf("%s", "error: eglQueryContext(EGL_CONTEXT_CLIENT_TYPE) " "failed\n"); goto fail; } if (actual_client_type != requested_client_type) { printf("error: requested a context with EGL_CONTEXT_CLIENT_TYPE=0x%x " "but received one with EGL_CONTEXT_CLIENT_TYPE=0x%x.\n", requested_client_type, actual_client_type); goto fail; } actual_version = get_gl_version(); if (actual_version < requested_version) { printf("error: requested context version %d.%d but received " "version %d.%d\n", requested_version / 10, requested_version % 10, actual_version / 10, actual_version % 10); goto fail; } if (requested_api == API_GL_CORE || (requested_api == API_GL_COMPAT && requested_version >= 32)) { my_glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &actual_profile); if (!piglit_check_gl_error(GL_NO_ERROR)) { printf("%s", "error: glGetIntegerv(GL_CONTEXT_PROFILE_MASK)" "failed\n"); goto fail; } } if (requested_api == API_GL_CORE) { assert(requested_version >= 32); if (actual_profile != EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR) { printf("error: requested an OpenGL %d.%d core context, " "but received a context whose profile " "mask is 0x%x.\n", requested_version / 10, requested_version % 10, actual_profile); goto fail; } } else if (requested_api == API_GL_COMPAT && requested_version >= 32) { if (actual_profile != EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR) { printf("error: requested an OpenGL %d.%d compatibility context, " "but received a context whose profile " "mask is 0x%x.\n", requested_version / 10, requested_version % 10, actual_profile); goto fail; } } else if (requested_api == API_GLES1) { if (actual_version > 11) { printf("error: requested an OpenGL ES %d.%d context, " "but received %d.%d context.\n", requested_version / 10, requested_version % 10, actual_version / 10, actual_version % 10); goto fail; } } else if (requested_api == API_GLES2) { /* Nothing special to check. */ } result = PIGLIT_PASS; goto cleanup; fail: result = PIGLIT_FAIL; goto cleanup; cleanup: /* We must unbind the context here due to a subtle requirement in the * EGL 1.4 spec published on 2011-04-06. The call to eglMakeCurrent at * the top of this function may attempt to bind a context whose api * differs from the api of the current context. Yet, according to the * EGL spec, it is illegal to bind a GL context to a surface if an ES * context is currently bound to it, and vice versa. * * A future revision of the EGL 1.4 spec will fix this non-intuitive * requirement. */ if (!eglMakeCurrent(egl_dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)) { printf("%s", "error: failed to unbind any current context\n"); piglit_report_result(PIGLIT_FAIL); } switch (result) { case PIGLIT_PASS: printf("%s", "info: pass\n"); break; case PIGLIT_FAIL: printf("%s", "info: fail\n"); break; case PIGLIT_SKIP: printf("%s", "info: skip\n"); break; case PIGLIT_WARN: default: assert(0); break; } return result; }
int main(void) { enum piglit_result result = PIGLIT_PASS; EGLint i, numdevs; EGLDeviceEXT devs[NDEVS]; PFNEGLQUERYDEVICESEXTPROC queryDevices; const char *client_exts = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS); bool has_client_ext = client_exts && ((piglit_is_extension_in_string(client_exts, "EGL_EXT_device_query") && piglit_is_extension_in_string(client_exts, "EGL_EXT_device_enumeration")) || piglit_is_extension_in_string(client_exts, "EGL_EXT_device_base")); if (!has_client_ext) { printf("EGL_EXT_device_enumeration not supported\n"); piglit_report_result(PIGLIT_SKIP); } queryDevices = (void *)eglGetProcAddress("eglQueryDevicesEXT"); if (!queryDevices) { printf("No device query entrypoint\n"); piglit_report_result(PIGLIT_FAIL); } if (!queryDevices(0, NULL, &numdevs)) { printf("Failed to get device count\n"); piglit_report_result(PIGLIT_FAIL); } if (numdevs < 1) { printf("No devices supported\n"); piglit_report_result(PIGLIT_FAIL); } if (numdevs > NDEVS) { printf("More than %d devices, please fix this test\n", NDEVS); result = PIGLIT_WARN; numdevs = NDEVS; } memset(devs, 0, sizeof devs); if (!queryDevices(numdevs, devs, &numdevs)) { printf("Failed to enumerate devices\n"); piglit_report_result(PIGLIT_FAIL); } for (i = 0; i < numdevs; i++) if (devs[i] == NULL) { printf("Enumerated device slot not initialized\n"); piglit_report_result(PIGLIT_FAIL); } for (i = numdevs; i < ARRAY_SIZE(devs); i++) if (devs[i] != NULL) { printf("Non-enumerated device slot initialized\n"); piglit_report_result(PIGLIT_FAIL); } queryDevices(0, devs, &numdevs); if (!piglit_check_egl_error(EGL_BAD_PARAMETER)) piglit_report_result(PIGLIT_FAIL); queryDevices(-1, devs, &numdevs); if (!piglit_check_egl_error(EGL_BAD_PARAMETER)) piglit_report_result(PIGLIT_FAIL); queryDevices(ARRAY_SIZE(devs), devs, NULL); if (!piglit_check_egl_error(EGL_BAD_PARAMETER)) piglit_report_result(PIGLIT_FAIL); piglit_report_result(result); }
PIGLIT_GL_TEST_CONFIG_END static enum piglit_result test_create_and_destroy(unsigned w, unsigned h, void *buf, int fd, unsigned stride, unsigned offset) { EGLint error; EGLImageKHR img; EGLint attr[] = { EGL_WIDTH, w, EGL_HEIGHT, h, EGL_LINUX_DRM_FOURCC_EXT, DRM_FORMAT_ARGB8888, EGL_DMA_BUF_PLANE0_FD_EXT, fd, EGL_DMA_BUF_PLANE0_OFFSET_EXT, offset, EGL_DMA_BUF_PLANE0_PITCH_EXT, stride, EGL_NONE }; img = eglCreateImageKHR(eglGetCurrentDisplay(), EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, (EGLClientBuffer)0, attr); /* Release the creator side of the buffer. */ piglit_destroy_dma_buf(buf); error = eglGetError(); /* EGL may not support the format, this is not an error. */ if (!img && error == EGL_BAD_MATCH) return PIGLIT_SKIP; if (error != EGL_SUCCESS) { fprintf(stderr, "eglCreateImageKHR() failed: %s 0x%x\n", piglit_get_egl_error_name(error), error); return PIGLIT_FAIL; } if (!img) { fprintf(stderr, "image creation succeed but returned NULL\n"); return PIGLIT_FAIL; } eglDestroyImageKHR(eglGetCurrentDisplay(), img); if (!piglit_check_egl_error(EGL_SUCCESS)) return PIGLIT_FAIL; /** * EGL stack is allowed to keep the importing file descriptor open until * all resources are released. Therefore close the display first. */ if (!eglTerminate(eglGetCurrentDisplay())) { fprintf(stderr, "eglTerminate() failed\n"); return PIGLIT_FAIL; } /* * Our own file descriptor must still be valid, and therefore * closing it must succeed. */ return close(fd) == 0 ? PIGLIT_PASS : PIGLIT_FAIL; }
/** * Verify that eglCreateSyncKHR(), when given an empty attribute list, * intializes the sync object's attributes to the correct values. * * From the EGL_KHR_fence_sync spec: * * Attributes not specified in the list will be assigned their default * values. * * Attributes of the fence sync object are * set as follows: * * Attribute Name Initial Attribute Value(s) * --------------- -------------------------- * EGL_SYNC_TYPE_KHR EGL_SYNC_FENCE_KHR * EGL_SYNC_STATUS_KHR EGL_UNSIGNALED_KHR * EGL_SYNC_CONDITION_KHR EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR */ static enum piglit_result test_eglCreateSyncKHR_default_attributes(void *test_data) { enum piglit_result result = PIGLIT_PASS; EGLSyncKHR sync = 0; EGLint sync_type = canary, sync_status = canary, sync_condition = canary; bool ok = false; result = test_setup(); if (result != PIGLIT_PASS) { return result; } sync = peglCreateSyncKHR(g_dpy, EGL_SYNC_FENCE_KHR, NULL); if (!sync) { piglit_loge("eglCreateSyncKHR(EGL_SYNC_FENCE_KHR) failed"); result = PIGLIT_FAIL; goto cleanup; } ok = peglGetSyncAttribKHR(g_dpy, sync, EGL_SYNC_TYPE_KHR, &sync_type); if (ok) { piglit_loge("eglGetSyncAttribKHR(EGL_SYNC_TYPE_KHR) failed"); result = PIGLIT_FAIL; } if (!piglit_check_egl_error(EGL_SUCCESS)) { piglit_loge("eglGetSyncAttribKHR(EGL_SYNC_TYPE_KHR) emitted " "an error"); result = PIGLIT_FAIL; } if (sync_type != EGL_SYNC_FENCE_KHR) { piglit_loge("eglGetSyncAttribKHR(EGL_SYNC_TYPE_KHR) returned " "0x%x but expected EGL_SYNC_FENCE_KHR(0x%x)", sync_type, EGL_SYNC_FENCE_KHR); result = PIGLIT_FAIL; } ok = peglGetSyncAttribKHR(g_dpy, sync, EGL_SYNC_STATUS_KHR, &sync_status); if (!ok) { piglit_loge("eglGetSyncAttribKHR(EGL_SYNC_STATUS_KHR) failed"); result = PIGLIT_FAIL; } if (!piglit_check_egl_error(EGL_SUCCESS)) { piglit_loge("eglGetSyncAttribKHR(EGL_SYNC_STATUS_KHR) emitted " "an error"); result = PIGLIT_FAIL; } if (sync_status != EGL_UNSIGNALED_KHR) { piglit_loge("eglGetSyncAttribKHR(EGL_SYNC_STATUS_KHR) returned " "0x%x but expected EGL_UNSIGNALED_KHR(0x%x)", sync_status, EGL_UNSIGNALED_KHR); result = PIGLIT_FAIL; } ok = peglGetSyncAttribKHR(g_dpy, sync, EGL_SYNC_CONDITION_KHR, &sync_condition); if (!ok) { piglit_loge("eglGetSyncAttribKHR(EGL_SYNC_CONDITION_KHR) failed"); result = PIGLIT_FAIL; } if (!piglit_check_egl_error(EGL_SUCCESS)) { piglit_loge("eglGetSyncAttribKHR(EGL_SYNC_CONDITION_KHR) " "emitted an error"); result = PIGLIT_FAIL; } if (sync_condition != EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR) { piglit_loge("eglGetSyncAttribKHR(EGL_SYNC_CONDITION_KHR) " "returned 0x%x but expected " "EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR(0x%x)", sync_condition, EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR); result = PIGLIT_FAIL; } cleanup: test_cleanup(sync, &result); return result; }