int main(int argc, char **argv)
{
static const EGLint attribs[] = {
EGL_NONE
};
const char *version_string;
int major;
int minor;
if (!EGL_KHR_create_context_setup(EGL_OPENGL_ES_BIT)) {
fprintf(stderr, "ES 1 not available.\n");
piglit_report_result(PIGLIT_SKIP);
}
/* The EGL 1.4 spec says:
*
* "attrib list may be NULL or empty (first attribute is EGL_NONE),
* in which case all the attributes assume their default values"
*
* Specify an empty attrib_list and expect to receive an ES 1.x context.
*/
ctx = eglCreateContext(egl_dpy, cfg, EGL_NO_CONTEXT, attribs);
if (ctx == EGL_NO_CONTEXT) {
fprintf(stderr, "eglCreateContext() failed\n");
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);
}
piglit_dispatch_default_init(PIGLIT_DISPATCH_ES1);
version_string = (char *) glGetString(GL_VERSION);
if (!parse_version_string(version_string, &major, &minor)) {
fprintf(stderr,
"Unable to parse GL version string: %s\n",
version_string);
piglit_report_result(PIGLIT_FAIL);
}
if (major != 1 || (minor != 0 && minor != 1)) {
fprintf(stderr,
"Unexpected GLES version: %s\n"
"Expected ES 1.0 or ES 1.1.\n",
version_string);
piglit_report_result(PIGLIT_FAIL);
}
eglMakeCurrent(egl_dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroyContext(egl_dpy, ctx);
EGL_KHR_create_context_teardown();
piglit_report_result(PIGLIT_PASS);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
bool pass = true;
if (!EGL_KHR_create_context_setup(EGL_OPENGL_BIT)) {
fprintf(stderr, "Desktop GL not available.\n");
piglit_report_result(PIGLIT_SKIP);
}
eglBindAPI(EGL_OPENGL_API);
pass = try_version(1, 0) && pass;
pass = try_version(1, 1) && pass;
pass = try_version(1, 2) && pass;
pass = try_version(1, 3) && pass;
pass = try_version(1, 4) && pass;
pass = try_version(1, 5) && pass;
pass = try_version(2, 0) && pass;
pass = try_version(2, 1) && pass;
pass = try_version(3, 0) && pass;
pass = try_version(3, 1) && pass;
EGL_KHR_create_context_teardown();
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
return 0;
}
int main(int argc, char **argv)
{
EGLint bad_attributes[] = {
0xffff0000,
EGL_SAMPLE_BUFFERS
};
bool pass = true;
unsigned i;
if (!EGL_KHR_create_context_setup(EGL_OPENGL_BIT)) {
fprintf(stderr, "Desktop GL not available.\n");
piglit_report_result(PIGLIT_SKIP);
}
eglBindAPI(EGL_OPENGL_API);
for (i = 0; i < ARRAY_SIZE(bad_attributes); i++) {
pass = try_attribute(bad_attributes[i]) && pass;
}
EGL_KHR_create_context_teardown();
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
return EXIT_SUCCESS;
}
static enum piglit_result
check_opengl_es1(void)
{
enum piglit_result result = PIGLIT_SKIP;
if (!EGL_KHR_create_context_setup(EGL_OPENGL_ES_BIT))
return PIGLIT_SKIP;
/* Try OpenGL ES1 context versions. */
fold_results(&result, check_flavor(10, API_GLES1));
fold_results(&result, check_flavor(11, API_GLES1));
fold_results(&result, check_flavor(12, API_GLES1));
fold_results(&result, check_flavor(13, API_GLES1));
EGL_KHR_create_context_teardown();
return result;
}
static enum piglit_result
check_opengl_es3(void)
{
enum piglit_result result = PIGLIT_SKIP;
if (!EGL_KHR_create_context_setup(EGL_OPENGL_ES3_BIT_KHR))
return PIGLIT_SKIP;
fold_results(&result, check_flavor(30, API_GLES3));
fold_results(&result, check_flavor(31, API_GLES3));
fold_results(&result, check_flavor(32, API_GLES3));
fold_results(&result, check_flavor(33, API_GLES3));
fold_results(&result, check_flavor(34, API_GLES3));
fold_results(&result, check_flavor(35, API_GLES3));
fold_results(&result, check_flavor(36, API_GLES3));
fold_results(&result, check_flavor(37, API_GLES3));
EGL_KHR_create_context_teardown();
return result;
}
static enum piglit_result
check_opengl_es2(void)
{
enum piglit_result result = PIGLIT_SKIP;
if (!EGL_KHR_create_context_setup(EGL_OPENGL_ES2_BIT))
return PIGLIT_SKIP;
/* Try OpenGL ES2 context versions. */
fold_results(&result, check_flavor(20, API_GLES2));
fold_results(&result, check_flavor(21, API_GLES2));
fold_results(&result, check_flavor(22, API_GLES2));
fold_results(&result, check_flavor(23, API_GLES2));
fold_results(&result, check_flavor(24, API_GLES2));
fold_results(&result, check_flavor(25, API_GLES2));
fold_results(&result, check_flavor(26, API_GLES2));
fold_results(&result, check_flavor(27, API_GLES2));
EGL_KHR_create_context_teardown();
return result;
}
int main(int argc, char **argv)
{
EGLint attribs[] = {
EGL_CONTEXT_MAJOR_VERSION_KHR, 1,
EGL_NONE
};
const char *version_string;
int major;
int minor;
if (!EGL_KHR_create_context_setup(EGL_OPENGL_ES_BIT)) {
attribs[1] = 2;
if (!EGL_KHR_create_context_setup(EGL_OPENGL_ES2_BIT)) {
fprintf(stderr, "ES 2 not available.\n");
piglit_report_result(PIGLIT_SKIP);
}
}
/* The EGL_KHR_create_context spec says:
*
* "The default values for EGL_CONTEXT_MAJOR_VERSION_KHR and
* EGL_CONTEXT_MINOR_VERSION_KHR are 1 and 0 respectively."
*
* Request an OpenGL ES 1.x or 2.0 context by explicitly setting the
* major version and leaving the minor version at the default value of
* 0.
*
* The EGLConfig's EGL_RENDERABLE_TYPE and the attribute list's
* EGL_CONTEXT_MAJOR_VERSION_KHR have been chosen so that the driver
* is required to succeed at context creation.
*/
ctx = eglCreateContext(egl_dpy, cfg, EGL_NO_CONTEXT, attribs);
if (ctx == EGL_NO_CONTEXT) {
fprintf(stderr, "eglCreateContext() failed\n");
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);
}
if (attribs[1] == 1) {
/* FINISHME: Use PIGLIT_DISPATCH_ES1 when implemented. */
piglit_dispatch_default_init(PIGLIT_DISPATCH_GL);
} else if (attribs[1] == 2) {
piglit_dispatch_default_init(PIGLIT_DISPATCH_ES2);
}
version_string = (char *) glGetString(GL_VERSION);
if (!parse_version_string(version_string, &major, &minor)) {
fprintf(stderr,
"Unable to parse GL version string: %s\n",
version_string);
piglit_report_result(PIGLIT_FAIL);
}
if (!version_is_valid_for_context(attribs[1], major, minor)) {
fprintf(stderr,
"Unexpected GLES version: %s\n"
"Expected ES %s.\n",
version_string,
attribs[1] == 1 ? "1.0 or 1.1" : "2.0 or 3.0");
piglit_report_result(PIGLIT_FAIL);
}
eglMakeCurrent(egl_dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroyContext(egl_dpy, ctx);
EGL_KHR_create_context_teardown();
piglit_report_result(PIGLIT_PASS);
return EXIT_SUCCESS;
}
static enum piglit_result
check_opengl(void)
{
enum piglit_result result = PIGLIT_SKIP;
if (!EGL_KHR_create_context_setup(EGL_OPENGL_BIT))
return PIGLIT_SKIP;
/* Try all valid OpenGL compatibility context versions. */
fold_results(&result, check_flavor(10, API_GL_COMPAT));
fold_results(&result, check_flavor(11, API_GL_COMPAT));
fold_results(&result, check_flavor(12, API_GL_COMPAT));
fold_results(&result, check_flavor(13, API_GL_COMPAT));
fold_results(&result, check_flavor(14, API_GL_COMPAT));
fold_results(&result, check_flavor(15, API_GL_COMPAT));
fold_results(&result, check_flavor(16, API_GL_COMPAT));
fold_results(&result, check_flavor(17, API_GL_COMPAT));
fold_results(&result, check_flavor(20, API_GL_COMPAT));
fold_results(&result, check_flavor(21, API_GL_COMPAT));
fold_results(&result, check_flavor(22, API_GL_COMPAT));
fold_results(&result, check_flavor(23, API_GL_COMPAT));
fold_results(&result, check_flavor(24, API_GL_COMPAT));
fold_results(&result, check_flavor(25, API_GL_COMPAT));
fold_results(&result, check_flavor(26, API_GL_COMPAT));
fold_results(&result, check_flavor(27, API_GL_COMPAT));
fold_results(&result, check_flavor(30, API_GL_COMPAT));
fold_results(&result, check_flavor(31, API_GL_COMPAT));
fold_results(&result, check_flavor(32, API_GL_COMPAT));
fold_results(&result, check_flavor(33, API_GL_COMPAT));
fold_results(&result, check_flavor(34, API_GL_COMPAT));
fold_results(&result, check_flavor(35, API_GL_COMPAT));
fold_results(&result, check_flavor(36, API_GL_COMPAT));
fold_results(&result, check_flavor(37, API_GL_COMPAT));
fold_results(&result, check_flavor(40, API_GL_COMPAT));
fold_results(&result, check_flavor(41, API_GL_COMPAT));
fold_results(&result, check_flavor(42, API_GL_COMPAT));
fold_results(&result, check_flavor(43, API_GL_COMPAT));
fold_results(&result, check_flavor(44, API_GL_COMPAT));
fold_results(&result, check_flavor(45, API_GL_COMPAT));
fold_results(&result, check_flavor(46, API_GL_COMPAT));
fold_results(&result, check_flavor(47, API_GL_COMPAT));
/* Try all valid OpenGL core context versions. */
fold_results(&result, check_flavor(32, API_GL_CORE));
fold_results(&result, check_flavor(33, API_GL_CORE));
fold_results(&result, check_flavor(34, API_GL_CORE));
fold_results(&result, check_flavor(35, API_GL_CORE));
fold_results(&result, check_flavor(36, API_GL_CORE));
fold_results(&result, check_flavor(37, API_GL_CORE));
fold_results(&result, check_flavor(40, API_GL_CORE));
fold_results(&result, check_flavor(41, API_GL_CORE));
fold_results(&result, check_flavor(42, API_GL_CORE));
fold_results(&result, check_flavor(43, API_GL_CORE));
fold_results(&result, check_flavor(44, API_GL_CORE));
fold_results(&result, check_flavor(45, API_GL_CORE));
fold_results(&result, check_flavor(46, API_GL_CORE));
fold_results(&result, check_flavor(47, API_GL_CORE));
EGL_KHR_create_context_teardown();
return result;
}
int main(int argc, char **argv)
{
EGLint attribs[] = {
EGL_CONTEXT_MAJOR_VERSION_KHR, 2,
EGL_NONE
};
const char *version_string;
int major;
int minor;
if (!EGL_KHR_create_context_setup(EGL_OPENGL_BIT)) {
fprintf(stderr, "Desktop GL not available.\n");
piglit_report_result(PIGLIT_SKIP);
}
eglBindAPI(EGL_OPENGL_API);
/* The EGL_KHR_create_context spec says:
*
* "Typically, the implementation will return the most recent
* version of OpenGL it supports which is backwards compatible
* with the requested version."
*
* "The default values for EGL_CONTEXT_MAJOR_VERSION_KHR and
* EGL_CONTEXT_MINOR_VERSION_KHR are 1 and 0 respectively."
*
* Request an OpenGL 2.0 context by explicitly setting the major
* version to 2 and leaving the major version at the default value of
* 0. The Linux OpenGL ABI only requires OpenGL 1.2, so this might
* fail to create a context.
*/
ctx = eglCreateContext(egl_dpy, cfg, EGL_NO_CONTEXT, attribs);
if (ctx == EGL_NO_CONTEXT) {
fprintf(stderr, "eglCreateContext() failed with "
"EGL_CONTEXT_MAJOR_VERSION_KHR=%d. skipping "
"test.\n", attribs[1]);
piglit_report_result(PIGLIT_SKIP);
}
if (!eglMakeCurrent(egl_dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, ctx)) {
fprintf(stderr, "eglMakeCurrent() failed\n");
piglit_report_result(PIGLIT_FAIL);
}
piglit_dispatch_default_init(PIGLIT_DISPATCH_GL);
version_string = (char *) glGetString(GL_VERSION);
if (!parse_version_string(version_string, &major, &minor)) {
fprintf(stderr,
"Unable to parse GL version string: %s\n",
version_string);
piglit_report_result(PIGLIT_FAIL);
}
if ((major == 2 && (minor < 0 || minor > 1)) ||
(major == 3 && (minor != 0)) ||
(major < 2 || major > 3)) {
fprintf(stderr,
"Unexpected GL version: %s\n"
"Expected GL 2.0, 2.1, or 3.0.\n",
version_string);
piglit_report_result(PIGLIT_FAIL);
}
eglMakeCurrent(egl_dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroyContext(egl_dpy, ctx);
EGL_KHR_create_context_teardown();
piglit_report_result(PIGLIT_PASS);
return EXIT_SUCCESS;
}
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);
}
