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 Negative API Tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "teglNegativeApiTests.hpp" 25 #include "teglApiCase.hpp" 26 27 #include "egluNativeDisplay.hpp" 28 #include "egluNativeWindow.hpp" 29 #include "egluUtil.hpp" 30 #include "egluUtil.hpp" 31 #include "egluUnique.hpp" 32 33 #include "eglwLibrary.hpp" 34 35 #include <memory> 36 37 using tcu::TestLog; 38 39 namespace deqp 40 { 41 namespace egl 42 { 43 44 using namespace eglw; 45 46 template <deUint32 Type> 47 static bool renderable (const eglu::CandidateConfig& c) 48 { 49 return (c.renderableType() & Type) == Type; 50 } 51 52 template <deUint32 Type> 53 static bool notRenderable (const eglu::CandidateConfig& c) 54 { 55 return (c.renderableType() & Type) == 0; 56 } 57 58 template <deUint32 Bits> 59 static bool surfaceBits (const eglu::CandidateConfig& c) 60 { 61 return (c.surfaceType() & Bits) == Bits; 62 } 63 64 template <deUint32 Bits> 65 static bool notSurfaceBits (const eglu::CandidateConfig& c) 66 { 67 return (c.surfaceType() & Bits) == 0; 68 } 69 70 NegativeApiTests::NegativeApiTests (EglTestContext& eglTestCtx) 71 : TestCaseGroup(eglTestCtx, "negative_api", "Negative API Tests") 72 { 73 } 74 75 NegativeApiTests::~NegativeApiTests (void) 76 { 77 } 78 79 void NegativeApiTests::init (void) 80 { 81 // \todo [2012-10-02 pyry] Add tests for EGL_NOT_INITIALIZED to all functions taking in EGLDisplay 82 // \todo [2012-10-02 pyry] Implement negative cases for following non-trivial cases: 83 // * eglBindTexImage() 84 // - EGL_BAD_ACCESS is generated if buffer is already bound to a texture 85 // - EGL_BAD_MATCH is generated if the surface attribute EGL_TEXTURE_FORMAT is set to EGL_NO_TEXTURE 86 // - EGL_BAD_MATCH is generated if buffer is not a valid buffer (currently only EGL_BACK_BUFFER may be specified) 87 // - EGL_BAD_SURFACE is generated if surface is not a pbuffer surface supporting texture binding 88 // * eglCopyBuffers() 89 // - EGL_BAD_NATIVE_PIXMAP is generated if the implementation does not support native pixmaps 90 // - EGL_BAD_NATIVE_PIXMAP may be generated if native_pixmap is not a valid native pixmap 91 // - EGL_BAD_MATCH is generated if the format of native_pixmap is not compatible with the color buffer of surface 92 // * eglCreateContext() 93 // - EGL_BAD_MATCH is generated if the current rendering API is EGL_NONE 94 // - EGL_BAD_MATCH is generated if the server context state for share_context exists in an address space which cannot be shared with the newly created context 95 // - EGL_BAD_CONTEXT is generated if share_context is not an EGL rendering context of the same client API type as the newly created context and is not EGL_NO_CONTEXT 96 // * eglCreatePbufferFromClientBuffer() 97 // - various BAD_MATCH, BAD_ACCESS etc. conditions 98 // * eglCreatePbufferSurface() 99 // - EGL_BAD_MATCH is generated if the EGL_TEXTURE_FORMAT attribute is not EGL_NO_TEXTURE, and EGL_WIDTH and/or EGL_HEIGHT specify an invalid size 100 // * eglCreatePixmapSurface() 101 // - EGL_BAD_ATTRIBUTE is generated if attrib_list contains an invalid pixmap attribute 102 // - EGL_BAD_MATCH is generated if the attributes of native_pixmap do not correspond to config or if config does not support rendering to pixmaps 103 // - EGL_BAD_MATCH is generated if config does not support the specified OpenVG alpha format attribute or colorspace attribute 104 // * eglCreateWindowSurface() 105 // - EGL_BAD_ATTRIBUTE is generated if attrib_list contains an invalid window attribute 106 // - EGL_BAD_MATCH is generated if the attributes of native_window do not correspond to config or if config does not support rendering to windows 107 // - EGL_BAD_MATCH is generated if config does not support the specified OpenVG alpha format attribute or colorspace attribute 108 // * eglMakeCurrent() 109 // - EGL_BAD_MATCH is generated if draw or read are not compatible with context 110 // - EGL_BAD_MATCH is generated if context is set to EGL_NO_CONTEXT and draw or read are not set to EGL_NO_SURFACE 111 // - EGL_BAD_MATCH is generated if draw or read are set to EGL_NO_SURFACE and context is not set to EGL_NO_CONTEXT 112 // - EGL_BAD_ACCESS is generated if context is current to some other thread 113 // - EGL_BAD_NATIVE_PIXMAP may be generated if a native pixmap underlying either draw or read is no longer valid 114 // - EGL_BAD_NATIVE_WINDOW may be generated if a native window underlying either draw or read is no longer valid 115 // * eglReleaseTexImage() 116 // - EGL_BAD_MATCH is generated if buffer is not a valid buffer (currently only EGL_BACK_BUFFER may be specified) 117 // * eglSwapInterval() 118 // - EGL_BAD_SURFACE is generated if there is no surface bound to the current context 119 // * eglWaitNative() 120 // - EGL_BAD_CURRENT_SURFACE is generated if the surface associated with the current context has a native window or pixmap, and that window or pixmap is no longer valid 121 122 using namespace eglw; 123 using namespace eglu; 124 125 static const EGLint s_emptyAttribList[] = { EGL_NONE }; 126 static const EGLint s_es1ContextAttribList[] = { EGL_CONTEXT_CLIENT_VERSION, 1, EGL_NONE }; 127 static const EGLint s_es2ContextAttribList[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; 128 129 static const EGLenum s_renderAPIs[] = { EGL_OPENGL_API, EGL_OPENGL_ES_API, EGL_OPENVG_API }; 130 static const eglu::ConfigFilter s_renderAPIFilters[] = { renderable<EGL_OPENGL_BIT>, renderable<EGL_OPENGL_ES_BIT>, renderable<EGL_OPENVG_BIT> }; 131 132 TEGL_ADD_API_CASE(bind_api, "eglBindAPI() negative tests", 133 { 134 TestLog& log = m_testCtx.getLog(); 135 log << TestLog::Section("Test1", "EGL_BAD_PARAMETER is generated if api is not one of the accepted tokens"); 136 137 expectFalse(eglBindAPI(0)); 138 expectError(EGL_BAD_PARAMETER); 139 140 expectFalse(eglBindAPI(0xfdfdfdfd)); 141 expectError(EGL_BAD_PARAMETER); 142 143 expectFalse(eglBindAPI((EGLenum)0xffffffff)); 144 expectError(EGL_BAD_PARAMETER); 145 146 log << TestLog::EndSection; 147 148 log << TestLog::Section("Test2", "EGL_BAD_PARAMETER is generated if the specified client API is not supported by the EGL display, or no configuration is provided for the specified API."); 149 150 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_renderAPIs); ndx++) 151 { 152 if (!isAPISupported(s_renderAPIs[ndx])) 153 { 154 if (!eglBindAPI(s_renderAPIs[ndx])) 155 expectError(EGL_BAD_PARAMETER); 156 else 157 { 158 EGLConfig eglConfig; 159 expectFalse(getConfig(&eglConfig, FilterList() << s_renderAPIFilters[ndx])); 160 } 161 } 162 } 163 164 log << TestLog::EndSection; 165 }); 166 167 TEGL_ADD_API_CASE(bind_tex_image, "eglBindTexImage() negative tests", 168 { 169 TestLog& log = m_testCtx.getLog(); 170 EGLDisplay display = getDisplay(); 171 172 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 173 174 expectFalse(eglBindTexImage(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_BACK_BUFFER)); 175 expectError(EGL_BAD_DISPLAY); 176 177 expectFalse(eglBindTexImage((EGLDisplay)-1, EGL_NO_SURFACE, EGL_BACK_BUFFER)); 178 expectError(EGL_BAD_DISPLAY); 179 180 log << TestLog::EndSection; 181 182 log << TestLog::Section("Test2", "EGL_BAD_SURFACE is generated if surface is not an EGL surface"); 183 184 expectFalse(eglBindTexImage(display, EGL_NO_SURFACE, EGL_BACK_BUFFER)); 185 expectError(EGL_BAD_SURFACE); 186 187 expectFalse(eglBindTexImage(display, (EGLSurface)-1, EGL_BACK_BUFFER)); 188 expectError(EGL_BAD_SURFACE); 189 190 log << TestLog::EndSection; 191 }); 192 193 static const EGLint s_validGenericPbufferAttrib[] = { EGL_WIDTH, 64, EGL_HEIGHT, 64, EGL_NONE }; 194 195 TEGL_ADD_API_CASE(copy_buffers, "eglCopyBuffers() negative tests", 196 { 197 TestLog& log = m_testCtx.getLog(); 198 const eglw::Library& egl = m_eglTestCtx.getLibrary(); 199 EGLDisplay display = getDisplay(); 200 const eglu::NativePixmapFactory& factory = eglu::selectNativePixmapFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine()); 201 de::UniquePtr<eglu::NativePixmap> pixmap (factory.createPixmap(&m_eglTestCtx.getNativeDisplay(), 64, 64)); 202 EGLConfig config; 203 204 { 205 if (getConfig(&config, FilterList() << surfaceBits<EGL_PBUFFER_BIT>)) 206 { 207 eglu::UniqueSurface surface (egl, display, egl.createPbufferSurface(display, config, s_validGenericPbufferAttrib)); 208 209 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 210 211 expectFalse(eglCopyBuffers(EGL_NO_DISPLAY, EGL_NO_SURFACE, pixmap->getLegacyNative())); 212 expectError(EGL_BAD_DISPLAY); 213 214 expectFalse(eglCopyBuffers((EGLDisplay)-1, EGL_NO_SURFACE, pixmap->getLegacyNative())); 215 expectError(EGL_BAD_DISPLAY); 216 217 log << TestLog::EndSection; 218 } 219 } 220 221 log << TestLog::Section("Test2", "EGL_BAD_SURFACE is generated if surface is not an EGL surface"); 222 223 expectFalse(eglCopyBuffers(display, EGL_NO_SURFACE, pixmap->getLegacyNative())); 224 expectError(EGL_BAD_SURFACE); 225 226 expectFalse(eglCopyBuffers(display, (EGLSurface)-1, pixmap->getLegacyNative())); 227 expectError(EGL_BAD_SURFACE); 228 229 log << TestLog::EndSection; 230 }); 231 232 static const EGLint s_invalidChooseConfigAttribList0[] = { 0, EGL_NONE }; 233 static const EGLint s_invalidChooseConfigAttribList1[] = { (EGLint)0xffffffff }; 234 static const EGLint s_invalidChooseConfigAttribList2[] = { EGL_BIND_TO_TEXTURE_RGB, 4, EGL_NONE }; 235 static const EGLint s_invalidChooseConfigAttribList3[] = { EGL_BIND_TO_TEXTURE_RGBA, 5, EGL_NONE }; 236 static const EGLint s_invalidChooseConfigAttribList4[] = { EGL_COLOR_BUFFER_TYPE, 0, EGL_NONE }; 237 static const EGLint s_invalidChooseConfigAttribList5[] = { EGL_NATIVE_RENDERABLE, 6, EGL_NONE }; 238 static const EGLint s_invalidChooseConfigAttribList6[] = { EGL_TRANSPARENT_TYPE, 6, EGL_NONE }; 239 static const EGLint* s_invalidChooseConfigAttribLists[] = 240 { 241 &s_invalidChooseConfigAttribList0[0], 242 &s_invalidChooseConfigAttribList1[0], 243 &s_invalidChooseConfigAttribList2[0], 244 &s_invalidChooseConfigAttribList3[0], 245 &s_invalidChooseConfigAttribList4[0], 246 &s_invalidChooseConfigAttribList5[0], 247 &s_invalidChooseConfigAttribList6[0] 248 }; 249 250 TEGL_ADD_API_CASE(choose_config, "eglChooseConfig() negative tests", 251 { 252 TestLog& log = m_testCtx.getLog(); 253 EGLDisplay display = getDisplay(); 254 EGLConfig configs[1]; 255 EGLint numConfigs; 256 257 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 258 259 expectFalse(eglChooseConfig(EGL_NO_DISPLAY, s_emptyAttribList, &configs[0], DE_LENGTH_OF_ARRAY(configs), &numConfigs)); 260 expectError(EGL_BAD_DISPLAY); 261 262 expectFalse(eglChooseConfig((EGLDisplay)-1, s_emptyAttribList, &configs[0], DE_LENGTH_OF_ARRAY(configs), &numConfigs)); 263 expectError(EGL_BAD_DISPLAY); 264 265 log << TestLog::EndSection; 266 267 log << TestLog::Section("Test2", "EGL_BAD_ATTRIBUTE is generated if attribute_list contains an invalid frame buffer configuration attribute"); 268 269 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_invalidChooseConfigAttribLists); ndx++) 270 { 271 expectFalse(eglChooseConfig(display, s_invalidChooseConfigAttribLists[ndx], &configs[0], DE_LENGTH_OF_ARRAY(configs), &numConfigs)); 272 expectError(EGL_BAD_ATTRIBUTE); 273 } 274 275 log << TestLog::EndSection; 276 277 log << TestLog::Section("Test3", "EGL_BAD_PARAMETER is generated if num_config is NULL"); 278 279 expectFalse(eglChooseConfig(display, s_emptyAttribList, &configs[0], DE_LENGTH_OF_ARRAY(configs), DE_NULL)); 280 expectError(EGL_BAD_PARAMETER); 281 282 log << TestLog::EndSection; 283 }); 284 285 static const EGLint s_invalidCreateContextAttribList0[] = { 0, EGL_NONE }; 286 static const EGLint s_invalidCreateContextAttribList1[] = { (EGLint)0xffffffff }; 287 288 TEGL_ADD_API_CASE(create_context, "eglCreateContext() negative tests", 289 { 290 TestLog& log = m_testCtx.getLog(); 291 EGLDisplay display = getDisplay(); 292 293 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 294 295 expectNoContext(eglCreateContext(EGL_NO_DISPLAY, DE_NULL, EGL_NO_CONTEXT, s_emptyAttribList)); 296 expectError(EGL_BAD_DISPLAY); 297 298 expectNoContext(eglCreateContext((EGLDisplay)-1, DE_NULL, EGL_NO_CONTEXT, s_emptyAttribList)); 299 expectError(EGL_BAD_DISPLAY); 300 301 log << TestLog::EndSection; 302 303 log << TestLog::Section("Test2", "EGL_BAD_CONFIG is generated if config is not an EGL frame buffer configuration"); 304 305 expectNoContext(eglCreateContext(display, (EGLConfig)-1, EGL_NO_CONTEXT, s_emptyAttribList)); 306 expectError(EGL_BAD_CONFIG); 307 308 log << TestLog::EndSection; 309 310 log << TestLog::Section("Test3", "EGL_BAD_CONFIG is generated if config does not support the current rendering API"); 311 312 if (isAPISupported(EGL_OPENGL_API)) 313 { 314 EGLConfig es1OnlyConfig; 315 if (getConfig(&es1OnlyConfig, FilterList() << renderable<EGL_OPENGL_ES_BIT> << notRenderable<EGL_OPENGL_BIT>)) 316 { 317 expectTrue(eglBindAPI(EGL_OPENGL_API)); 318 expectNoContext(eglCreateContext(display, es1OnlyConfig, EGL_NO_CONTEXT, s_es1ContextAttribList)); 319 expectError(EGL_BAD_CONFIG); 320 } 321 322 EGLConfig es2OnlyConfig; 323 if (getConfig(&es2OnlyConfig, FilterList() << renderable<EGL_OPENGL_ES2_BIT> << notRenderable<EGL_OPENGL_BIT>)) 324 { 325 expectTrue(eglBindAPI(EGL_OPENGL_API)); 326 expectNoContext(eglCreateContext(display, es2OnlyConfig, EGL_NO_CONTEXT, s_es2ContextAttribList)); 327 expectError(EGL_BAD_CONFIG); 328 } 329 330 EGLConfig vgOnlyConfig; 331 if (getConfig(&vgOnlyConfig, FilterList() << renderable<EGL_OPENVG_BIT> << notRenderable<EGL_OPENGL_BIT>)) 332 { 333 expectTrue(eglBindAPI(EGL_OPENGL_API)); 334 expectNoContext(eglCreateContext(display, vgOnlyConfig, EGL_NO_CONTEXT, s_emptyAttribList)); 335 expectError(EGL_BAD_CONFIG); 336 } 337 } 338 339 if (isAPISupported(EGL_OPENGL_ES_API)) 340 { 341 EGLConfig glOnlyConfig; 342 if (getConfig(&glOnlyConfig, FilterList() << renderable<EGL_OPENGL_BIT> << notRenderable<EGL_OPENGL_ES_BIT|EGL_OPENGL_ES2_BIT>)) 343 { 344 expectTrue(eglBindAPI(EGL_OPENGL_ES_API)); 345 expectNoContext(eglCreateContext(display, glOnlyConfig, EGL_NO_CONTEXT, s_emptyAttribList)); 346 expectError(EGL_BAD_CONFIG); 347 } 348 349 EGLConfig vgOnlyConfig; 350 if (getConfig(&vgOnlyConfig, FilterList() << renderable<EGL_OPENVG_BIT> << notRenderable<EGL_OPENGL_ES_BIT|EGL_OPENGL_ES2_BIT>)) 351 { 352 expectTrue(eglBindAPI(EGL_OPENGL_ES_API)); 353 expectNoContext(eglCreateContext(display, vgOnlyConfig, EGL_NO_CONTEXT, s_emptyAttribList)); 354 expectError(EGL_BAD_CONFIG); 355 } 356 } 357 358 if (isAPISupported(EGL_OPENVG_API)) 359 { 360 EGLConfig glOnlyConfig; 361 if (getConfig(&glOnlyConfig, FilterList() << renderable<EGL_OPENGL_BIT> << notRenderable<EGL_OPENVG_BIT>)) 362 { 363 expectTrue(eglBindAPI(EGL_OPENVG_API)); 364 expectNoContext(eglCreateContext(display, glOnlyConfig, EGL_NO_CONTEXT, s_emptyAttribList)); 365 expectError(EGL_BAD_CONFIG); 366 } 367 368 EGLConfig es1OnlyConfig; 369 if (getConfig(&es1OnlyConfig, FilterList() << renderable<EGL_OPENGL_ES_BIT> << notRenderable<EGL_OPENVG_BIT>)) 370 { 371 expectTrue(eglBindAPI(EGL_OPENVG_API)); 372 expectNoContext(eglCreateContext(display, es1OnlyConfig, EGL_NO_CONTEXT, s_es1ContextAttribList)); 373 expectError(EGL_BAD_CONFIG); 374 } 375 376 EGLConfig es2OnlyConfig; 377 if (getConfig(&es2OnlyConfig, FilterList() << renderable<EGL_OPENGL_ES2_BIT> << notRenderable<EGL_OPENVG_BIT>)) 378 { 379 expectTrue(eglBindAPI(EGL_OPENVG_API)); 380 expectNoContext(eglCreateContext(display, es2OnlyConfig, EGL_NO_CONTEXT, s_es2ContextAttribList)); 381 expectError(EGL_BAD_CONFIG); 382 } 383 } 384 385 log << TestLog::EndSection; 386 387 log << TestLog::Section("Test4", "EGL_BAD_CONFIG or EGL_BAD_MATCH is generated if OpenGL ES 1.x context is requested and EGL_RENDERABLE_TYPE attribute of config does not contain EGL_OPENGL_ES_BIT"); 388 389 if (isAPISupported(EGL_OPENGL_ES_API)) 390 { 391 EGLConfig notES1Config; 392 if (getConfig(¬ES1Config, FilterList() << notRenderable<EGL_OPENGL_ES_BIT>)) 393 { 394 // EGL 1.4, EGL 1.5, and EGL_KHR_create_context contain contradictory language about the expected error. 395 Version version = eglu::getVersion(m_eglTestCtx.getLibrary(), display); 396 bool hasKhrCreateContext = eglu::hasExtension(m_eglTestCtx.getLibrary(), display, "EGL_KHR_create_context"); 397 398 expectTrue(eglBindAPI(EGL_OPENGL_ES_API)); 399 expectNoContext(eglCreateContext(display, notES1Config, EGL_NO_CONTEXT, s_es1ContextAttribList)); 400 if (hasKhrCreateContext) 401 expectEitherError(EGL_BAD_CONFIG, EGL_BAD_MATCH); 402 else 403 { 404 if (version >= eglu::Version(1, 5)) 405 expectError(EGL_BAD_MATCH); 406 else 407 expectError(EGL_BAD_CONFIG); 408 } 409 } 410 } 411 412 log << TestLog::EndSection; 413 414 log << TestLog::Section("Test5", "EGL_BAD_CONFIG or EGL_BAD_MATCH is generated if OpenGL ES 2.x context is requested and EGL_RENDERABLE_TYPE attribute of config does not contain EGL_OPENGL_ES2_BIT"); 415 416 if (isAPISupported(EGL_OPENGL_ES_API)) 417 { 418 EGLConfig notES2Config; 419 if (getConfig(¬ES2Config, FilterList() << notRenderable<EGL_OPENGL_ES2_BIT>)) 420 { 421 // EGL 1.4, EGL 1.5, and EGL_KHR_create_context contain contradictory language about the expected error. 422 Version version = eglu::getVersion(m_eglTestCtx.getLibrary(), display); 423 bool hasKhrCreateContext = eglu::hasExtension(m_eglTestCtx.getLibrary(), display, "EGL_KHR_create_context"); 424 425 expectTrue(eglBindAPI(EGL_OPENGL_ES_API)); 426 expectNoContext(eglCreateContext(display, notES2Config, EGL_NO_CONTEXT, s_es2ContextAttribList)); 427 if (hasKhrCreateContext) 428 expectEitherError(EGL_BAD_CONFIG, EGL_BAD_MATCH); 429 else 430 { 431 if (version >= eglu::Version(1, 5)) 432 expectError(EGL_BAD_MATCH); 433 else 434 expectError(EGL_BAD_CONFIG); 435 } 436 } 437 } 438 439 log << TestLog::EndSection; 440 441 log << TestLog::Section("Test6", "EGL_BAD_ATTRIBUTE is generated if attrib_list contains an invalid context attribute"); 442 443 if (isAPISupported(EGL_OPENGL_API) && !eglu::hasExtension(m_eglTestCtx.getLibrary(), display, "EGL_KHR_create_context")) 444 { 445 EGLConfig glConfig; 446 if (getConfig(&glConfig, FilterList() << renderable<EGL_OPENGL_BIT>)) 447 { 448 expectTrue(eglBindAPI(EGL_OPENGL_API)); 449 expectNoContext(eglCreateContext(display, glConfig, EGL_NO_CONTEXT, s_es1ContextAttribList)); 450 expectError(EGL_BAD_ATTRIBUTE); 451 } 452 } 453 454 if (isAPISupported(EGL_OPENVG_API)) 455 { 456 EGLConfig vgConfig; 457 if (getConfig(&vgConfig, FilterList() << renderable<EGL_OPENVG_BIT>)) 458 { 459 expectTrue(eglBindAPI(EGL_OPENVG_API)); 460 expectNoContext(eglCreateContext(display, vgConfig, EGL_NO_CONTEXT, s_es1ContextAttribList)); 461 expectError(EGL_BAD_ATTRIBUTE); 462 } 463 } 464 465 if (isAPISupported(EGL_OPENGL_ES_API)) 466 { 467 bool gotConfig = false; 468 EGLConfig esConfig; 469 470 gotConfig = getConfig(&esConfig, FilterList() << renderable<EGL_OPENGL_ES_BIT>) || 471 getConfig(&esConfig, FilterList() << renderable<EGL_OPENGL_ES2_BIT>); 472 473 if (gotConfig) 474 { 475 expectTrue(eglBindAPI(EGL_OPENGL_ES_API)); 476 expectNoContext(eglCreateContext(display, esConfig, EGL_NO_CONTEXT, s_invalidCreateContextAttribList0)); 477 expectError(EGL_BAD_ATTRIBUTE); 478 expectNoContext(eglCreateContext(display, esConfig, EGL_NO_CONTEXT, s_invalidCreateContextAttribList1)); 479 expectError(EGL_BAD_ATTRIBUTE); 480 } 481 } 482 483 log << TestLog::EndSection; 484 }); 485 486 TEGL_ADD_API_CASE(create_pbuffer_from_client_buffer, "eglCreatePbufferFromClientBuffer() negative tests", 487 { 488 TestLog& log = m_testCtx.getLog(); 489 EGLDisplay display = getDisplay(); 490 EGLConfig anyConfig; 491 EGLint unused = 0; 492 493 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 494 495 expectNoSurface(eglCreatePbufferFromClientBuffer(EGL_NO_DISPLAY, EGL_OPENVG_IMAGE, 0, (EGLConfig)0, DE_NULL)); 496 expectError(EGL_BAD_DISPLAY); 497 498 expectNoSurface(eglCreatePbufferFromClientBuffer((EGLDisplay)-1, EGL_OPENVG_IMAGE, 0, (EGLConfig)0, DE_NULL)); 499 expectError(EGL_BAD_DISPLAY); 500 501 log << TestLog::EndSection; 502 503 if (isAPISupported(EGL_OPENVG_API)) 504 { 505 log << TestLog::Section("Test2", "EGL_BAD_CONFIG or EGL_BAD_PARAMETER is generated if config is not an EGL frame buffer configuration and if buffer is not valid OpenVG image"); 506 507 expectNoSurface(eglCreatePbufferFromClientBuffer(display, EGL_OPENVG_IMAGE, (EGLClientBuffer)-1, (EGLConfig)-1, DE_NULL)); 508 expectEitherError(EGL_BAD_CONFIG, EGL_BAD_PARAMETER); 509 510 log << TestLog::EndSection; 511 512 log << TestLog::Section("Test3", "EGL_BAD_PARAMETER is generated if buftype is not EGL_OPENVG_IMAGE"); 513 514 expectTrue(eglGetConfigs(display, &anyConfig, 1, &unused)); 515 516 log << TestLog::EndSection; 517 518 log << TestLog::Section("Test4", "EGL_BAD_PARAMETER is generated if buffer is not valid OpenVG image"); 519 expectNoSurface(eglCreatePbufferFromClientBuffer(display, EGL_OPENVG_IMAGE, (EGLClientBuffer)-1, anyConfig, DE_NULL)); 520 expectError(EGL_BAD_PARAMETER); 521 522 log << TestLog::EndSection; 523 } 524 }); 525 526 static const EGLint s_invalidGenericPbufferAttrib0[] = { 0, EGL_NONE }; 527 static const EGLint s_invalidGenericPbufferAttrib1[] = { (EGLint)0xffffffff }; 528 static const EGLint s_negativeWidthPbufferAttrib[] = { EGL_WIDTH, -1, EGL_HEIGHT, 64, EGL_NONE }; 529 static const EGLint s_negativeHeightPbufferAttrib[] = { EGL_WIDTH, 64, EGL_HEIGHT, -1, EGL_NONE }; 530 static const EGLint s_negativeWidthAndHeightPbufferAttrib[] = { EGL_WIDTH, -1, EGL_HEIGHT, -1, EGL_NONE }; 531 static const EGLint* s_invalidGenericPbufferAttribs[] = 532 { 533 s_invalidGenericPbufferAttrib0, 534 s_invalidGenericPbufferAttrib1, 535 }; 536 537 static const EGLint s_invalidNoEsPbufferAttrib0[] = { EGL_MIPMAP_TEXTURE, EGL_TRUE, EGL_WIDTH, 64, EGL_HEIGHT, 64, EGL_NONE }; 538 static const EGLint s_invalidNoEsPbufferAttrib1[] = { EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA, EGL_WIDTH, 64, EGL_HEIGHT, 64, EGL_NONE }; 539 static const EGLint s_invalidNoEsPbufferAttrib2[] = { EGL_TEXTURE_TARGET, EGL_TEXTURE_2D, EGL_WIDTH, 64, EGL_HEIGHT, 64, EGL_NONE }; 540 static const EGLint* s_invalidNoEsPbufferAttribs[] = 541 { 542 s_invalidNoEsPbufferAttrib0, 543 s_invalidNoEsPbufferAttrib1, 544 s_invalidNoEsPbufferAttrib2 545 }; 546 547 static const EGLint s_invalidEsPbufferAttrib0[] = { EGL_TEXTURE_FORMAT, EGL_NO_TEXTURE, EGL_TEXTURE_TARGET, EGL_TEXTURE_2D, EGL_WIDTH, 64, EGL_HEIGHT, 64, EGL_NONE }; 548 static const EGLint s_invalidEsPbufferAttrib1[] = { EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA, EGL_TEXTURE_TARGET, EGL_NO_TEXTURE, EGL_WIDTH, 64, EGL_HEIGHT, 64, EGL_NONE }; 549 static const EGLint* s_invalidEsPbufferAttribs[] = 550 { 551 s_invalidEsPbufferAttrib0, 552 s_invalidEsPbufferAttrib1 553 }; 554 555 static const EGLint s_vgPreMultAlphaPbufferAttrib[] = { EGL_ALPHA_FORMAT, EGL_ALPHA_FORMAT_PRE, EGL_WIDTH, 64, EGL_HEIGHT, 64, EGL_NONE }; 556 static const EGLint s_vgLinearColorspacePbufferAttrib[] = { EGL_COLORSPACE, EGL_VG_COLORSPACE_LINEAR, EGL_WIDTH, 64, EGL_HEIGHT, 64, EGL_NONE }; 557 558 TEGL_ADD_API_CASE(create_pbuffer_surface, "eglCreatePbufferSurface() negative tests", 559 { 560 TestLog& log = m_testCtx.getLog(); 561 EGLDisplay display = getDisplay(); 562 563 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 564 565 expectNoSurface(eglCreatePbufferSurface(EGL_NO_DISPLAY, DE_NULL, s_emptyAttribList)); 566 expectError(EGL_BAD_DISPLAY); 567 568 expectNoSurface(eglCreatePbufferSurface((EGLDisplay)-1, DE_NULL, s_emptyAttribList)); 569 expectError(EGL_BAD_DISPLAY); 570 571 log << TestLog::EndSection; 572 573 log << TestLog::Section("Test2", "EGL_BAD_CONFIG is generated if config is not an EGL frame buffer configuration"); 574 575 expectNoSurface(eglCreatePbufferSurface(display, (EGLConfig)-1, s_emptyAttribList)); 576 expectError(EGL_BAD_CONFIG); 577 578 log << TestLog::EndSection; 579 580 log << TestLog::Section("Test3", "EGL_BAD_ATTRIBUTE is generated if attrib_list contains an invalid pixel buffer attribute"); 581 582 // Generic pbuffer-capable config 583 EGLConfig genericConfig; 584 if (getConfig(&genericConfig, FilterList() << surfaceBits<EGL_PBUFFER_BIT>)) 585 { 586 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_invalidGenericPbufferAttribs); ndx++) 587 { 588 expectNoSurface(eglCreatePbufferSurface(display, genericConfig, s_invalidGenericPbufferAttribs[ndx])); 589 expectError(EGL_BAD_ATTRIBUTE); 590 } 591 } 592 593 log << TestLog::EndSection; 594 595 log << TestLog::Section("Test4", "EGL_BAD_MATCH is generated if config does not support rendering to pixel buffers"); 596 597 EGLConfig noPbufferConfig; 598 if (getConfig(&noPbufferConfig, FilterList() << notSurfaceBits<EGL_PBUFFER_BIT>)) 599 { 600 expectNoSurface(eglCreatePbufferSurface(display, noPbufferConfig, s_validGenericPbufferAttrib)); 601 expectError(EGL_BAD_MATCH); 602 } 603 604 log << TestLog::EndSection; 605 606 log << TestLog::Section("Test5", "EGL_BAD_ATTRIBUTE is generated if attrib_list contains any of the attributes EGL_MIPMAP_TEXTURE, EGL_TEXTURE_FORMAT, or EGL_TEXTURE_TARGET, and config does not support OpenGL ES rendering"); 607 608 EGLConfig noEsConfig; 609 if (getConfig(&noEsConfig, FilterList() << notRenderable<EGL_OPENGL_ES_BIT|EGL_OPENGL_ES2_BIT>)) 610 { 611 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_invalidNoEsPbufferAttribs); ndx++) 612 { 613 expectNoSurface(eglCreatePbufferSurface(display, noEsConfig, s_invalidNoEsPbufferAttribs[ndx])); 614 expectError(EGL_BAD_MATCH); 615 } 616 } 617 618 log << TestLog::EndSection; 619 620 log << TestLog::Section("Test6", "EGL_BAD_MATCH is generated if the EGL_TEXTURE_FORMAT attribute is EGL_NO_TEXTURE, and EGL_TEXTURE_TARGET is something other than EGL_NO_TEXTURE; or, EGL_TEXTURE_FORMAT is something other than EGL_NO_TEXTURE, and EGL_TEXTURE_TARGET is EGL_NO_TEXTURE"); 621 622 // ES1 or ES2 config. 623 EGLConfig esConfig; 624 bool gotEsConfig = getConfig(&esConfig, FilterList() << renderable<EGL_OPENGL_ES_BIT>) || 625 getConfig(&esConfig, FilterList() << renderable<EGL_OPENGL_ES2_BIT>); 626 if (gotEsConfig) 627 { 628 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_invalidEsPbufferAttribs); ndx++) 629 { 630 expectNoSurface(eglCreatePbufferSurface(display, esConfig, s_invalidEsPbufferAttribs[ndx])); 631 expectError(EGL_BAD_MATCH); 632 } 633 } 634 635 log << TestLog::EndSection; 636 637 log << TestLog::Section("Test7", "EGL_BAD_MATCH is generated if config does not support the specified OpenVG alpha format attribute or colorspace attribute"); 638 639 EGLConfig vgNoPreConfig; 640 if (getConfig(&vgNoPreConfig, FilterList() << renderable<EGL_OPENVG_BIT> << notSurfaceBits<EGL_VG_ALPHA_FORMAT_PRE_BIT>)) 641 { 642 expectNoSurface(eglCreatePbufferSurface(display, vgNoPreConfig, s_vgPreMultAlphaPbufferAttrib)); 643 expectError(EGL_BAD_MATCH); 644 } 645 646 EGLConfig vgNoLinearConfig; 647 if (getConfig(&vgNoLinearConfig, FilterList() << renderable<EGL_OPENVG_BIT> << notSurfaceBits<EGL_VG_COLORSPACE_LINEAR_BIT>)) 648 { 649 expectNoSurface(eglCreatePbufferSurface(display, vgNoLinearConfig, s_vgLinearColorspacePbufferAttrib)); 650 expectError(EGL_BAD_MATCH); 651 } 652 653 log << TestLog::EndSection; 654 655 log << TestLog::Section("Test8", "EGL_BAD_PARAMETER is generated if EGL_WIDTH or EGL_HEIGHT is negative"); 656 657 if (getConfig(&genericConfig, FilterList() << surfaceBits<EGL_PBUFFER_BIT>)) 658 { 659 expectNoSurface(eglCreatePbufferSurface(display, genericConfig, s_negativeWidthPbufferAttrib)); 660 expectError(EGL_BAD_PARAMETER); 661 662 expectNoSurface(eglCreatePbufferSurface(display, genericConfig, s_negativeHeightPbufferAttrib)); 663 expectError(EGL_BAD_PARAMETER); 664 665 expectNoSurface(eglCreatePbufferSurface(display, genericConfig, s_negativeWidthAndHeightPbufferAttrib)); 666 expectError(EGL_BAD_PARAMETER); 667 } 668 669 log << TestLog::EndSection; 670 671 }); 672 673 TEGL_ADD_API_CASE(create_pixmap_surface, "eglCreatePixmapSurface() negative tests", 674 { 675 TestLog& log = m_testCtx.getLog(); 676 EGLDisplay display = getDisplay(); 677 678 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 679 680 expectNoSurface(eglCreatePixmapSurface(EGL_NO_DISPLAY, DE_NULL, DE_NULL, s_emptyAttribList)); 681 expectError(EGL_BAD_DISPLAY); 682 683 expectNoSurface(eglCreatePixmapSurface((EGLDisplay)-1, DE_NULL, DE_NULL, s_emptyAttribList)); 684 expectError(EGL_BAD_DISPLAY); 685 686 log << TestLog::EndSection; 687 688 log << TestLog::Section("Test2", "EGL_BAD_CONFIG or EGL_BAD_PARAMETER is generated if config is not an EGL frame buffer configuration or if the PixmapSurface call is not supported"); 689 690 expectNoSurface(eglCreatePixmapSurface(display, (EGLConfig)-1, DE_NULL, s_emptyAttribList)); 691 expectEitherError(EGL_BAD_CONFIG, EGL_BAD_PARAMETER); 692 693 log << TestLog::EndSection; 694 }); 695 696 TEGL_ADD_API_CASE(create_window_surface, "eglCreateWindowSurface() negative tests", 697 { 698 EGLConfig config = DE_NULL; 699 bool gotConfig = getConfig(&config, FilterList() << renderable<EGL_OPENGL_ES2_BIT> << surfaceBits<EGL_WINDOW_BIT>); 700 701 if (gotConfig) 702 { 703 TestLog& log = m_testCtx.getLog(); 704 EGLDisplay display = getDisplay(); 705 const eglu::NativeWindowFactory& factory = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine()); 706 de::UniquePtr<eglu::NativeWindow> window (factory.createWindow(&m_eglTestCtx.getNativeDisplay(), display, config, DE_NULL, eglu::WindowParams(256, 256, eglu::parseWindowVisibility(m_testCtx.getCommandLine())))); 707 708 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 709 710 expectNoSurface(eglCreateWindowSurface(EGL_NO_DISPLAY, config, window->getLegacyNative(), s_emptyAttribList)); 711 expectError(EGL_BAD_DISPLAY); 712 713 expectNoSurface(eglCreateWindowSurface((EGLDisplay)-1, config, window->getLegacyNative(), s_emptyAttribList)); 714 expectError(EGL_BAD_DISPLAY); 715 716 log << TestLog::EndSection; 717 } 718 }); 719 720 TEGL_ADD_API_CASE(destroy_context, "eglDestroyContext() negative tests", 721 { 722 TestLog& log = m_testCtx.getLog(); 723 EGLDisplay display = getDisplay(); 724 725 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 726 727 expectFalse(eglDestroyContext(EGL_NO_DISPLAY, DE_NULL)); 728 expectError(EGL_BAD_DISPLAY); 729 730 expectFalse(eglDestroyContext((EGLDisplay)-1, DE_NULL)); 731 expectError(EGL_BAD_DISPLAY); 732 733 log << TestLog::EndSection; 734 735 log << TestLog::Section("Test2", "EGL_BAD_CONTEXT is generated if context is not an EGL rendering context"); 736 737 expectFalse(eglDestroyContext(display, DE_NULL)); 738 expectError(EGL_BAD_CONTEXT); 739 740 expectFalse(eglDestroyContext(display, (EGLContext)-1)); 741 expectError(EGL_BAD_CONTEXT); 742 743 log << TestLog::EndSection; 744 }); 745 746 TEGL_ADD_API_CASE(destroy_surface, "eglDestroySurface() negative tests", 747 { 748 TestLog& log = m_testCtx.getLog(); 749 EGLDisplay display = getDisplay(); 750 751 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 752 753 expectFalse(eglDestroySurface(EGL_NO_DISPLAY, DE_NULL)); 754 expectError(EGL_BAD_DISPLAY); 755 756 expectFalse(eglDestroySurface((EGLDisplay)-1, DE_NULL)); 757 expectError(EGL_BAD_DISPLAY); 758 759 log << TestLog::EndSection; 760 761 log << TestLog::Section("Test2", "EGL_BAD_SURFACE is generated if surface is not an EGL surface"); 762 763 expectFalse(eglDestroySurface(display, DE_NULL)); 764 expectError(EGL_BAD_SURFACE); 765 766 expectFalse(eglDestroySurface(display, (EGLSurface)-1)); 767 expectError(EGL_BAD_SURFACE); 768 769 log << TestLog::EndSection; 770 }); 771 772 TEGL_ADD_API_CASE(get_config_attrib, "eglGetConfigAttrib() negative tests", 773 { 774 TestLog& log = m_testCtx.getLog(); 775 EGLDisplay display = getDisplay(); 776 EGLint value = 0; 777 778 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 779 780 expectFalse(eglGetConfigAttrib(EGL_NO_DISPLAY, DE_NULL, EGL_RED_SIZE, &value)); 781 expectError(EGL_BAD_DISPLAY); 782 783 expectFalse(eglGetConfigAttrib((EGLDisplay)-1, DE_NULL, EGL_RED_SIZE, &value)); 784 expectError(EGL_BAD_DISPLAY); 785 786 log << TestLog::EndSection; 787 788 log << TestLog::Section("Test2", "EGL_BAD_CONFIG is generated if config is not an EGL frame buffer configuration"); 789 790 expectFalse(eglGetConfigAttrib(display, (EGLConfig)-1, EGL_RED_SIZE, &value)); 791 expectError(EGL_BAD_CONFIG); 792 793 log << TestLog::EndSection; 794 795 // Any config. 796 EGLConfig config = DE_NULL; 797 bool hasConfig = getConfig(&config, FilterList()); 798 799 log << TestLog::Section("Test3", "EGL_BAD_ATTRIBUTE is generated if attribute is not a valid frame buffer configuration attribute"); 800 801 if (hasConfig) 802 { 803 expectFalse(eglGetConfigAttrib(display, config, 0, &value)); 804 expectError(EGL_BAD_ATTRIBUTE); 805 806 expectFalse(eglGetConfigAttrib(display, config, -1, &value)); 807 expectError(EGL_BAD_ATTRIBUTE); 808 } 809 810 log << TestLog::EndSection; 811 }); 812 813 TEGL_ADD_API_CASE(get_configs, "eglGetConfigs() negative tests", 814 { 815 TestLog& log = m_testCtx.getLog(); 816 EGLDisplay display = getDisplay(); 817 EGLConfig cfgs[1]; 818 EGLint numCfgs = 0; 819 820 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 821 822 expectFalse(eglGetConfigs(EGL_NO_DISPLAY, &cfgs[0], DE_LENGTH_OF_ARRAY(cfgs), &numCfgs)); 823 expectError(EGL_BAD_DISPLAY); 824 825 expectFalse(eglGetConfigs((EGLDisplay)-1, &cfgs[0], DE_LENGTH_OF_ARRAY(cfgs), &numCfgs)); 826 expectError(EGL_BAD_DISPLAY); 827 828 log << TestLog::EndSection; 829 830 log << TestLog::Section("Test2", "EGL_BAD_PARAMETER is generated if num_config is NULL"); 831 832 expectFalse(eglGetConfigs(display, &cfgs[0], DE_LENGTH_OF_ARRAY(cfgs), DE_NULL)); 833 expectError(EGL_BAD_PARAMETER); 834 835 log << TestLog::EndSection; 836 }); 837 838 TEGL_ADD_API_CASE(initialize, "eglInitialize() negative tests", 839 { 840 TestLog& log = m_testCtx.getLog(); 841 EGLint major = 0; 842 EGLint minor = 0; 843 844 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 845 846 expectFalse(eglInitialize(EGL_NO_DISPLAY, &major, &minor)); 847 expectError(EGL_BAD_DISPLAY); 848 849 expectFalse(eglInitialize((EGLDisplay)-1, &major, &minor)); 850 expectError(EGL_BAD_DISPLAY); 851 852 log << TestLog::EndSection; 853 }); 854 855 TEGL_ADD_API_CASE(make_current, "eglMakeCurrent() negative tests", 856 { 857 TestLog& log = m_testCtx.getLog(); 858 EGLDisplay display = getDisplay(); 859 860 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 861 862 expectFalse(eglMakeCurrent(EGL_NO_DISPLAY, DE_NULL, DE_NULL, DE_NULL)); 863 expectError(EGL_BAD_DISPLAY); 864 865 expectFalse(eglMakeCurrent((EGLDisplay)-1, DE_NULL, DE_NULL, DE_NULL)); 866 expectError(EGL_BAD_DISPLAY); 867 868 log << TestLog::EndSection; 869 870 // Create simple pbuffer surface. 871 EGLSurface surface = EGL_NO_SURFACE; 872 { 873 EGLConfig config; 874 if (getConfig(&config, FilterList() << surfaceBits<EGL_PBUFFER_BIT>)) 875 { 876 surface = eglCreatePbufferSurface(display, config, s_validGenericPbufferAttrib); 877 expectError(EGL_SUCCESS); 878 } 879 } 880 881 // Create simple ES2 context 882 EGLContext context = EGL_NO_CONTEXT; 883 { 884 EGLConfig config; 885 if (getConfig(&config, FilterList() << renderable<EGL_OPENGL_ES2_BIT>)) 886 { 887 context = eglCreateContext(display, config, EGL_NO_CONTEXT, s_es2ContextAttribList); 888 expectError(EGL_SUCCESS); 889 } 890 } 891 892 if (surface != EGL_NO_SURFACE && context != EGL_NO_CONTEXT) 893 { 894 log << TestLog::Section("Test2", "EGL_BAD_SURFACE is generated if surface is not an EGL surface"); 895 896 expectFalse(eglMakeCurrent(display, (EGLSurface)-1, (EGLSurface)-1, context)); 897 expectError(EGL_BAD_SURFACE); 898 899 expectFalse(eglMakeCurrent(display, surface, (EGLSurface)-1, context)); 900 expectError(EGL_BAD_SURFACE); 901 902 expectFalse(eglMakeCurrent(display, (EGLSurface)-1, surface, context)); 903 expectError(EGL_BAD_SURFACE); 904 905 log << TestLog::EndSection; 906 } 907 908 if (surface) 909 { 910 log << TestLog::Section("Test3", "EGL_BAD_CONTEXT is generated if context is not an EGL rendering context"); 911 912 expectFalse(eglMakeCurrent(display, surface, surface, (EGLContext)-1)); 913 expectError(EGL_BAD_CONTEXT); 914 915 log << TestLog::EndSection; 916 } 917 918 if (surface != EGL_NO_SURFACE) 919 { 920 log << TestLog::Section("Test4", "EGL_BAD_MATCH is generated if read or draw surface is not EGL_NO_SURFACE and context is EGL_NO_CONTEXT"); 921 922 expectFalse(eglMakeCurrent(display, surface, EGL_NO_SURFACE, EGL_NO_CONTEXT)); 923 expectError(EGL_BAD_MATCH); 924 925 expectFalse(eglMakeCurrent(display, EGL_NO_SURFACE, surface, EGL_NO_CONTEXT)); 926 expectError(EGL_BAD_MATCH); 927 928 expectFalse(eglMakeCurrent(display, surface, surface, EGL_NO_CONTEXT)); 929 expectError(EGL_BAD_MATCH); 930 931 log << TestLog::EndSection; 932 } 933 934 if (context) 935 { 936 eglDestroyContext(display, context); 937 expectError(EGL_SUCCESS); 938 } 939 940 if (surface) 941 { 942 eglDestroySurface(display, surface); 943 expectError(EGL_SUCCESS); 944 } 945 }); 946 947 TEGL_ADD_API_CASE(get_current_context, "eglGetCurrentContext() negative tests", 948 { 949 expectNoContext(eglGetCurrentContext()); 950 951 if (isAPISupported(EGL_OPENGL_ES_API)) 952 { 953 expectTrue(eglBindAPI(EGL_OPENGL_ES_API)); 954 expectError(EGL_SUCCESS); 955 956 expectNoContext(eglGetCurrentContext()); 957 expectError(EGL_SUCCESS); 958 } 959 }); 960 961 TEGL_ADD_API_CASE(get_current_surface, "eglGetCurrentSurface() negative tests", 962 { 963 TestLog& log = m_testCtx.getLog(); 964 EGLDisplay display = getDisplay(); 965 EGLConfig config = DE_NULL; 966 EGLContext context = EGL_NO_CONTEXT; 967 EGLSurface surface = EGL_NO_SURFACE; 968 bool gotConfig = getConfig(&config, FilterList() << renderable<EGL_OPENGL_ES2_BIT> << surfaceBits<EGL_PBUFFER_BIT>); 969 970 if (gotConfig) 971 { 972 expectTrue(eglBindAPI(EGL_OPENGL_ES_API)); 973 expectError(EGL_SUCCESS); 974 975 context = eglCreateContext(display, config, EGL_NO_CONTEXT, s_es2ContextAttribList); 976 expectError(EGL_SUCCESS); 977 978 // Create simple pbuffer surface. 979 surface = eglCreatePbufferSurface(display, config, s_validGenericPbufferAttrib); 980 expectError(EGL_SUCCESS); 981 982 expectTrue(eglMakeCurrent(display, surface, surface, context)); 983 expectError(EGL_SUCCESS); 984 985 log << TestLog::Section("Test1", "EGL_BAD_PARAMETER is generated if readdraw is neither EGL_READ nor EGL_DRAW"); 986 987 expectNoSurface(eglGetCurrentSurface(EGL_NONE)); 988 expectError(EGL_BAD_PARAMETER); 989 990 log << TestLog::EndSection; 991 992 expectTrue(eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); 993 expectError(EGL_SUCCESS); 994 995 if (surface != EGL_NO_SURFACE) 996 { 997 expectTrue(eglDestroySurface(display, surface)); 998 expectError(EGL_SUCCESS); 999 } 1000 1001 if (context != EGL_NO_CONTEXT) 1002 { 1003 expectTrue(eglDestroyContext(display, context)); 1004 expectError(EGL_SUCCESS); 1005 } 1006 } 1007 }); 1008 1009 TEGL_ADD_API_CASE(query_context, "eglQueryContext() negative tests", 1010 { 1011 TestLog& log = m_testCtx.getLog(); 1012 EGLDisplay display = getDisplay(); 1013 EGLint value = 0; 1014 1015 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 1016 1017 expectFalse(eglQueryContext(EGL_NO_DISPLAY, DE_NULL, EGL_CONFIG_ID, &value)); 1018 expectError(EGL_BAD_DISPLAY); 1019 1020 expectFalse(eglQueryContext((EGLDisplay)-1, DE_NULL, EGL_CONFIG_ID, &value)); 1021 expectError(EGL_BAD_DISPLAY); 1022 1023 log << TestLog::EndSection; 1024 1025 log << TestLog::Section("Test2", "EGL_BAD_CONTEXT is generated if context is not an EGL rendering context"); 1026 1027 expectFalse(eglQueryContext(display, DE_NULL, EGL_CONFIG_ID, &value)); 1028 expectError(EGL_BAD_CONTEXT); 1029 1030 expectFalse(eglQueryContext(display, DE_NULL, EGL_CONFIG_ID, &value)); 1031 expectError(EGL_BAD_CONTEXT); 1032 1033 log << TestLog::EndSection; 1034 1035 // Create ES2 context. 1036 EGLConfig config = DE_NULL; 1037 EGLContext context = DE_NULL; 1038 bool gotConfig = getConfig(&config, FilterList() << renderable<EGL_OPENGL_ES2_BIT>); 1039 1040 if (gotConfig) 1041 { 1042 expectTrue(eglBindAPI(EGL_OPENGL_ES_API)); 1043 expectError(EGL_SUCCESS); 1044 1045 context = eglCreateContext(display, config, EGL_NO_CONTEXT, s_es2ContextAttribList); 1046 expectError(EGL_SUCCESS); 1047 } 1048 1049 log << TestLog::Section("Test3", "EGL_BAD_ATTRIBUTE is generated if attribute is not a valid context attribute"); 1050 1051 if (context) 1052 { 1053 expectFalse(eglQueryContext(display, context, 0, &value)); 1054 expectError(EGL_BAD_ATTRIBUTE); 1055 expectFalse(eglQueryContext(display, context, -1, &value)); 1056 expectError(EGL_BAD_ATTRIBUTE); 1057 expectFalse(eglQueryContext(display, context, EGL_RED_SIZE, &value)); 1058 expectError(EGL_BAD_ATTRIBUTE); 1059 } 1060 1061 log << TestLog::EndSection; 1062 1063 if (context) 1064 { 1065 expectTrue(eglDestroyContext(display, context)); 1066 expectError(EGL_SUCCESS); 1067 } 1068 }); 1069 1070 TEGL_ADD_API_CASE(query_string, "eglQueryString() negative tests", 1071 { 1072 TestLog& log = m_testCtx.getLog(); 1073 EGLDisplay display = getDisplay(); 1074 1075 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 1076 1077 expectNull(eglQueryString(EGL_NO_DISPLAY, EGL_VENDOR)); 1078 expectError(EGL_BAD_DISPLAY); 1079 1080 expectNull(eglQueryString((EGLDisplay)-1, EGL_VENDOR)); 1081 expectError(EGL_BAD_DISPLAY); 1082 1083 log << TestLog::EndSection; 1084 1085 log << TestLog::Section("Test2", "EGL_BAD_PARAMETER is generated if name is not an accepted value"); 1086 1087 expectNull(eglQueryString(display, 0)); 1088 expectError(EGL_BAD_PARAMETER); 1089 expectNull(eglQueryString(display, -1)); 1090 expectError(EGL_BAD_PARAMETER); 1091 1092 log << TestLog::EndSection; 1093 }); 1094 1095 TEGL_ADD_API_CASE(query_surface, "eglQuerySurface() negative tests", 1096 { 1097 TestLog& log = m_testCtx.getLog(); 1098 EGLDisplay display = getDisplay(); 1099 EGLint value = 0; 1100 1101 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 1102 1103 expectFalse(eglQuerySurface(EGL_NO_DISPLAY, DE_NULL, EGL_CONFIG_ID, &value)); 1104 expectError(EGL_BAD_DISPLAY); 1105 1106 expectFalse(eglQuerySurface((EGLDisplay)-1, DE_NULL, EGL_CONFIG_ID, &value)); 1107 expectError(EGL_BAD_DISPLAY); 1108 1109 log << TestLog::EndSection; 1110 1111 log << TestLog::Section("Test2", "EGL_BAD_SURFACE is generated if surface is not an EGL surface"); 1112 1113 expectFalse(eglQuerySurface(display, DE_NULL, EGL_CONFIG_ID, &value)); 1114 expectError(EGL_BAD_SURFACE); 1115 1116 expectFalse(eglQuerySurface(display, (EGLSurface)-1, EGL_CONFIG_ID, &value)); 1117 expectError(EGL_BAD_SURFACE); 1118 1119 log << TestLog::EndSection; 1120 1121 // Create pbuffer surface. 1122 EGLSurface surface = EGL_NO_SURFACE; 1123 { 1124 EGLConfig config; 1125 if (getConfig(&config, FilterList() << surfaceBits<EGL_PBUFFER_BIT>)) 1126 { 1127 surface = eglCreatePbufferSurface(display, config, s_validGenericPbufferAttrib); 1128 expectError(EGL_SUCCESS); 1129 } 1130 else 1131 log << TestLog::Message << "// WARNING: No suitable config found, testing will be incomplete" << TestLog::EndMessage; 1132 } 1133 1134 log << TestLog::Section("Test3", "EGL_BAD_ATTRIBUTE is generated if attribute is not a valid surface attribute"); 1135 1136 if (surface) 1137 { 1138 expectFalse(eglQuerySurface(display, surface, 0, &value)); 1139 expectError(EGL_BAD_ATTRIBUTE); 1140 1141 expectFalse(eglQuerySurface(display, surface, -1, &value)); 1142 expectError(EGL_BAD_ATTRIBUTE); 1143 } 1144 1145 log << TestLog::EndSection; 1146 1147 if (surface) 1148 { 1149 eglDestroySurface(display, surface); 1150 expectError(EGL_SUCCESS); 1151 } 1152 }); 1153 1154 TEGL_ADD_API_CASE(release_tex_image, "eglReleaseTexImage() negative tests", 1155 { 1156 TestLog& log = m_testCtx.getLog(); 1157 EGLDisplay display = getDisplay(); 1158 1159 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 1160 1161 expectFalse(eglReleaseTexImage(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_BACK_BUFFER)); 1162 expectError(EGL_BAD_DISPLAY); 1163 1164 expectFalse(eglReleaseTexImage((EGLDisplay)-1, EGL_NO_SURFACE, EGL_BACK_BUFFER)); 1165 expectError(EGL_BAD_DISPLAY); 1166 1167 log << TestLog::EndSection; 1168 1169 log << TestLog::Section("Test2", "EGL_BAD_SURFACE is generated if surface is not an EGL surface"); 1170 1171 expectFalse(eglReleaseTexImage(display, EGL_NO_SURFACE, EGL_BACK_BUFFER)); 1172 expectError(EGL_BAD_SURFACE); 1173 1174 expectFalse(eglReleaseTexImage(display, (EGLSurface)-1, EGL_BACK_BUFFER)); 1175 expectError(EGL_BAD_SURFACE); 1176 1177 log << TestLog::EndSection; 1178 }); 1179 1180 TEGL_ADD_API_CASE(surface_attrib, "eglSurfaceAttrib() negative tests", 1181 { 1182 TestLog& log = m_testCtx.getLog(); 1183 EGLDisplay display = getDisplay(); 1184 1185 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 1186 1187 expectFalse(eglSurfaceAttrib(EGL_NO_DISPLAY, DE_NULL, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED)); 1188 expectError(EGL_BAD_DISPLAY); 1189 1190 expectFalse(eglSurfaceAttrib((EGLDisplay)-1, DE_NULL, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED)); 1191 expectError(EGL_BAD_DISPLAY); 1192 1193 log << TestLog::EndSection; 1194 1195 log << TestLog::Section("Test2", "EGL_BAD_SURFACE is generated if surface is not an EGL surface"); 1196 1197 expectFalse(eglSurfaceAttrib(display, DE_NULL, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED)); 1198 expectError(EGL_BAD_SURFACE); 1199 1200 expectFalse(eglSurfaceAttrib(display, (EGLSurface)-1, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED)); 1201 expectError(EGL_BAD_SURFACE); 1202 1203 log << TestLog::EndSection; 1204 1205 { 1206 // Create pbuffer surface. 1207 EGLSurface surface = EGL_NO_SURFACE; 1208 { 1209 EGLConfig config; 1210 if (getConfig(&config, FilterList() << surfaceBits<EGL_PBUFFER_BIT>)) 1211 { 1212 surface = eglCreatePbufferSurface(display, config, s_validGenericPbufferAttrib); 1213 expectError(EGL_SUCCESS); 1214 } 1215 else 1216 log << TestLog::Message << "// WARNING: No suitable config found, testing will be incomplete" << TestLog::EndMessage; 1217 } 1218 1219 log << TestLog::Section("Test3", "EGL_BAD_ATTRIBUTE is generated if attribute is not a valid surface attribute"); 1220 1221 if (surface) 1222 { 1223 expectFalse(eglSurfaceAttrib(display, surface, 0, 0)); 1224 expectError(EGL_BAD_ATTRIBUTE); 1225 1226 expectFalse(eglSurfaceAttrib(display, surface, -1, 0)); 1227 expectError(EGL_BAD_ATTRIBUTE); 1228 } 1229 1230 log << TestLog::EndSection; 1231 1232 if (surface) 1233 { 1234 eglDestroySurface(display, surface); 1235 expectError(EGL_SUCCESS); 1236 } 1237 } 1238 1239 { 1240 // Create pbuffer surface without EGL_MULTISAMPLE_RESOLVE_BOX_BIT. 1241 EGLSurface surface = EGL_NO_SURFACE; 1242 { 1243 EGLConfig config; 1244 if (getConfig(&config, FilterList() << surfaceBits<EGL_PBUFFER_BIT> << notSurfaceBits<EGL_MULTISAMPLE_RESOLVE_BOX_BIT>)) 1245 { 1246 surface = eglCreatePbufferSurface(display, config, s_validGenericPbufferAttrib); 1247 expectError(EGL_SUCCESS); 1248 } 1249 else 1250 log << TestLog::Message << "// WARNING: No suitable config found, testing will be incomplete" << TestLog::EndMessage; 1251 } 1252 1253 log << TestLog::Section("Test4", "EGL_BAD_MATCH is generated if attribute is EGL_MULTISAMPLE_RESOLVE, value is EGL_MULTISAMPLE_RESOLVE_BOX, and the EGL_SURFACE_TYPE attribute of the EGLConfig used to create surface does not contain EGL_MULTISAMPLE_RESOLVE_BOX_BIT"); 1254 1255 if (surface) 1256 { 1257 expectFalse(eglSurfaceAttrib(display, surface, EGL_MULTISAMPLE_RESOLVE, EGL_MULTISAMPLE_RESOLVE_BOX)); 1258 expectError(EGL_BAD_MATCH); 1259 } 1260 1261 log << TestLog::EndSection; 1262 1263 if (surface) 1264 { 1265 eglDestroySurface(display, surface); 1266 expectError(EGL_SUCCESS); 1267 } 1268 } 1269 1270 { 1271 // Create pbuffer surface without EGL_SWAP_BEHAVIOR_PRESERVED_BIT. 1272 EGLSurface surface = EGL_NO_SURFACE; 1273 { 1274 EGLConfig config; 1275 if (getConfig(&config, FilterList() << surfaceBits<EGL_PBUFFER_BIT> << notSurfaceBits<EGL_SWAP_BEHAVIOR_PRESERVED_BIT>)) 1276 { 1277 surface = eglCreatePbufferSurface(display, config, s_validGenericPbufferAttrib); 1278 expectError(EGL_SUCCESS); 1279 } 1280 else 1281 log << TestLog::Message << "// WARNING: No suitable config found, testing will be incomplete" << TestLog::EndMessage; 1282 } 1283 1284 log << TestLog::Section("Test5", "EGL_BAD_MATCH is generated if attribute is EGL_SWAP_BEHAVIOR, value is EGL_BUFFER_PRESERVED, and the EGL_SURFACE_TYPE attribute of the EGLConfig used to create surface does not contain EGL_SWAP_BEHAVIOR_PRESERVED_BIT"); 1285 1286 if (surface) 1287 { 1288 expectFalse(eglSurfaceAttrib(display, surface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED)); 1289 expectError(EGL_BAD_MATCH); 1290 } 1291 1292 log << TestLog::EndSection; 1293 1294 if (surface) 1295 { 1296 eglDestroySurface(display, surface); 1297 expectError(EGL_SUCCESS); 1298 } 1299 } 1300 }); 1301 1302 TEGL_ADD_API_CASE(swap_buffers, "eglSwapBuffers() negative tests", 1303 { 1304 TestLog& log = m_testCtx.getLog(); 1305 EGLDisplay display = getDisplay(); 1306 1307 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 1308 1309 expectFalse(eglSwapBuffers(EGL_NO_DISPLAY, DE_NULL)); 1310 expectError(EGL_BAD_DISPLAY); 1311 1312 expectFalse(eglSwapBuffers((EGLDisplay)-1, DE_NULL)); 1313 expectError(EGL_BAD_DISPLAY); 1314 1315 log << TestLog::EndSection; 1316 1317 log << TestLog::Section("Test2", "EGL_BAD_SURFACE is generated if surface is not an EGL surface"); 1318 1319 expectFalse(eglSwapBuffers(display, DE_NULL)); 1320 expectError(EGL_BAD_SURFACE); 1321 1322 expectFalse(eglSwapBuffers(display, (EGLSurface)-1)); 1323 expectError(EGL_BAD_SURFACE); 1324 1325 log << TestLog::EndSection; 1326 }); 1327 1328 TEGL_ADD_API_CASE(swap_interval, "eglSwapInterval() negative tests", 1329 { 1330 TestLog& log = m_testCtx.getLog(); 1331 EGLDisplay display = getDisplay(); 1332 1333 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 1334 1335 expectFalse(eglSwapInterval(EGL_NO_DISPLAY, 0)); 1336 expectError(EGL_BAD_DISPLAY); 1337 1338 expectFalse(eglSwapInterval((EGLDisplay)-1, 0)); 1339 expectError(EGL_BAD_DISPLAY); 1340 1341 log << TestLog::EndSection; 1342 1343 log << TestLog::Section("Test2", "EGL_BAD_CONTEXT is generated if there is no current context on the calling thread"); 1344 1345 expectFalse(eglSwapInterval(display, 0)); 1346 expectError(EGL_BAD_CONTEXT); 1347 1348 log << TestLog::EndSection; 1349 }); 1350 1351 TEGL_ADD_API_CASE(terminate, "eglTerminate() negative tests", 1352 { 1353 TestLog& log = m_testCtx.getLog(); 1354 1355 log << TestLog::Section("Test1", "EGL_BAD_DISPLAY is generated if display is not an EGL display connection"); 1356 1357 expectFalse(eglTerminate(EGL_NO_DISPLAY)); 1358 expectError(EGL_BAD_DISPLAY); 1359 1360 expectFalse(eglTerminate((EGLDisplay)-1)); 1361 expectError(EGL_BAD_DISPLAY); 1362 1363 log << TestLog::EndSection; 1364 }); 1365 1366 TEGL_ADD_API_CASE(wait_native, "eglWaitNative() negative tests", 1367 { 1368 EGLConfig config = DE_NULL; 1369 bool gotConfig = getConfig(&config, FilterList() << renderable<EGL_OPENGL_ES2_BIT> << surfaceBits<EGL_WINDOW_BIT>); 1370 1371 if (gotConfig) 1372 { 1373 TestLog& log = m_testCtx.getLog(); 1374 const Library& egl = m_eglTestCtx.getLibrary(); 1375 EGLDisplay display = getDisplay(); 1376 const eglu::NativeWindowFactory& factory = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine()); 1377 de::UniquePtr<eglu::NativeWindow> window (factory.createWindow(&m_eglTestCtx.getNativeDisplay(), display, config, DE_NULL, eglu::WindowParams(256, 256, eglu::parseWindowVisibility(m_testCtx.getCommandLine())))); 1378 eglu::UniqueSurface surface (egl, display, eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *window, display, config, DE_NULL)); 1379 EGLContext context = EGL_NO_CONTEXT; 1380 1381 expectTrue(eglBindAPI(EGL_OPENGL_ES_API)); 1382 expectError(EGL_SUCCESS); 1383 1384 context = eglCreateContext(display, config, EGL_NO_CONTEXT, s_es2ContextAttribList); 1385 expectError(EGL_SUCCESS); 1386 1387 expectTrue(eglMakeCurrent(display, *surface, *surface, context)); 1388 expectError(EGL_SUCCESS); 1389 1390 log << TestLog::Section("Test1", "EGL_BAD_PARAMETER is generated if engine is not a recognized marking engine and native rendering is supported by current surface"); 1391 1392 eglWaitNative(-1); 1393 expectEitherError(EGL_BAD_PARAMETER, EGL_SUCCESS); 1394 1395 log << TestLog::EndSection; 1396 1397 expectTrue(eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); 1398 expectError(EGL_SUCCESS); 1399 1400 if (context != EGL_NO_CONTEXT) 1401 { 1402 expectTrue(eglDestroyContext(display, context)); 1403 expectError(EGL_SUCCESS); 1404 } 1405 } 1406 }); 1407 } 1408 1409 } // egl 1410 } // deqp 1411
