1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program EGL Module 3 * --------------------------------------- 4 * 5 * Copyright 2015 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 Test negative use case of KHR_partial_update 22 *//*--------------------------------------------------------------------*/ 23 24 #include "teglNegativePartialUpdateTests.hpp" 25 26 #include "tcuTestLog.hpp" 27 #include "tcuSurface.hpp" 28 29 #include "egluCallLogWrapper.hpp" 30 #include "egluConfigFilter.hpp" 31 #include "egluNativeWindow.hpp" 32 #include "egluStrUtil.hpp" 33 #include "egluUnique.hpp" 34 #include "egluUtil.hpp" 35 36 #include "eglwLibrary.hpp" 37 #include "eglwEnums.hpp" 38 39 using namespace eglu; 40 using namespace eglw; 41 using tcu::TestLog; 42 43 namespace deqp 44 { 45 namespace egl 46 { 47 namespace 48 { 49 50 class NegativePartialUpdateTest : public TestCase 51 { 52 public: 53 enum SurfaceType 54 { 55 SURFACETYPE_WINDOW = 0, 56 SURFACETYPE_PBUFFER 57 }; 58 59 NegativePartialUpdateTest (EglTestContext& eglTestCtx, bool preserveBuffer, SurfaceType surfaceType, const char* name, const char* description); 60 ~NegativePartialUpdateTest (void); 61 void init (void); 62 void deinit (void); 63 virtual IterateResult iterate (void) = 0; 64 65 protected: 66 void expectError (eglw::EGLenum error); 67 void expectBoolean (EGLBoolean expected, EGLBoolean got); 68 inline void expectTrue (eglw::EGLBoolean got) { expectBoolean(EGL_TRUE, got); } 69 inline void expectFalse (eglw::EGLBoolean got) { expectBoolean(EGL_FALSE, got); } 70 71 const bool m_preserveBuffer; 72 SurfaceType m_surfaceType; 73 EGLDisplay m_eglDisplay; 74 EGLConfig m_eglConfig; 75 NativeWindow* m_window; 76 EGLSurface m_eglSurface; 77 EGLContext m_eglContext; 78 }; 79 80 bool isWindow (const CandidateConfig& c) 81 { 82 return (c.surfaceType() & EGL_WINDOW_BIT) == EGL_WINDOW_BIT; 83 } 84 85 bool isPbuffer (const CandidateConfig& c) 86 { 87 return (c.surfaceType() & EGL_PBUFFER_BIT) == EGL_PBUFFER_BIT; 88 } 89 90 bool isES2Renderable (const CandidateConfig& c) 91 { 92 return (c.get(EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES2_BIT) == EGL_OPENGL_ES2_BIT; 93 } 94 95 bool hasPreserveSwap (const CandidateConfig& c) 96 { 97 return (c.surfaceType() & EGL_SWAP_BEHAVIOR_PRESERVED_BIT) == EGL_SWAP_BEHAVIOR_PRESERVED_BIT; 98 } 99 100 EGLConfig getEGLConfig (const Library& egl, EGLDisplay eglDisplay, NegativePartialUpdateTest::SurfaceType surfaceType, bool preserveBuffer) 101 { 102 FilterList filters; 103 if (surfaceType == NegativePartialUpdateTest::SURFACETYPE_WINDOW) 104 filters << isWindow; 105 else if (surfaceType == NegativePartialUpdateTest::SURFACETYPE_PBUFFER) 106 filters << isPbuffer; 107 else 108 DE_FATAL("Invalid surfaceType"); 109 110 filters << isES2Renderable; 111 112 if (preserveBuffer) 113 filters << hasPreserveSwap; 114 115 return chooseSingleConfig(egl, eglDisplay, filters); 116 } 117 118 EGLContext initAndMakeCurrentEGLContext (const Library& egl, EGLDisplay eglDisplay, EGLSurface eglSurface, EGLConfig eglConfig, const EGLint* attribList) 119 { 120 EGLContext eglContext = EGL_NO_CONTEXT; 121 122 egl.bindAPI(EGL_OPENGL_ES_API); 123 eglContext = egl.createContext(eglDisplay, eglConfig, EGL_NO_CONTEXT, attribList); 124 EGLU_CHECK_MSG(egl, "eglCreateContext"); 125 TCU_CHECK(eglSurface != EGL_NO_SURFACE); 126 egl.makeCurrent(eglDisplay, eglSurface, eglSurface, eglContext); 127 EGLU_CHECK_MSG(egl, "eglMakeCurrent"); 128 129 return eglContext; 130 } 131 132 NegativePartialUpdateTest::NegativePartialUpdateTest (EglTestContext& eglTestCtx, bool preserveBuffer, SurfaceType surfaceType, const char* name, const char* description) 133 : TestCase (eglTestCtx, name, description) 134 , m_preserveBuffer (preserveBuffer) 135 , m_surfaceType (surfaceType) 136 , m_eglDisplay (EGL_NO_DISPLAY) 137 , m_window (DE_NULL) 138 , m_eglSurface (EGL_NO_SURFACE) 139 , m_eglContext (EGL_NO_CONTEXT) 140 { 141 } 142 143 NegativePartialUpdateTest::~NegativePartialUpdateTest (void) 144 { 145 deinit(); 146 } 147 148 void NegativePartialUpdateTest::init (void) 149 { 150 const Library& egl = m_eglTestCtx.getLibrary(); 151 static const EGLint contextAttribList[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; 152 const int width = 480; 153 const int height = 480; 154 155 m_eglDisplay = getAndInitDisplay(m_eglTestCtx.getNativeDisplay()); 156 157 if (!hasExtension(egl, m_eglDisplay, "EGL_KHR_partial_update")) 158 TCU_THROW(NotSupportedError, "EGL_KHR_partial_update is not supported"); 159 160 m_eglConfig = getEGLConfig(egl, m_eglDisplay, m_surfaceType, m_preserveBuffer); 161 162 if (m_surfaceType == SURFACETYPE_PBUFFER) 163 { 164 const EGLint pbufferAttribList[] = { EGL_WIDTH, width, EGL_HEIGHT, height, EGL_NONE }; 165 m_eglSurface = egl.createPbufferSurface(m_eglDisplay, m_eglConfig, pbufferAttribList); 166 } 167 else 168 { 169 const NativeWindowFactory& factory = selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine()); 170 m_window = factory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_eglDisplay, m_eglConfig, DE_NULL, 171 WindowParams(width, height, parseWindowVisibility(m_testCtx.getCommandLine()))); 172 m_eglSurface = createWindowSurface(m_eglTestCtx.getNativeDisplay(), *m_window, m_eglDisplay, m_eglConfig, DE_NULL); 173 } 174 m_eglContext = initAndMakeCurrentEGLContext(egl, m_eglDisplay, m_eglSurface, m_eglConfig, contextAttribList); 175 } 176 177 void NegativePartialUpdateTest::deinit (void) 178 { 179 const Library& egl = m_eglTestCtx.getLibrary(); 180 181 if (m_eglContext != EGL_NO_CONTEXT) 182 { 183 EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); 184 EGLU_CHECK_CALL(egl, destroyContext(m_eglDisplay, m_eglContext)); 185 m_eglContext = EGL_NO_CONTEXT; 186 } 187 188 if (m_eglSurface != EGL_NO_SURFACE) 189 { 190 EGLU_CHECK_CALL(egl, destroySurface(m_eglDisplay, m_eglSurface)); 191 m_eglSurface = EGL_NO_SURFACE; 192 } 193 194 if (m_eglDisplay != EGL_NO_DISPLAY) 195 { 196 EGLU_CHECK_CALL(egl, terminate(m_eglDisplay)); 197 m_eglDisplay = EGL_NO_DISPLAY; 198 } 199 200 delete m_window; 201 m_window = DE_NULL; 202 } 203 204 void NegativePartialUpdateTest::expectError (EGLenum expected) 205 { 206 const EGLenum err = m_eglTestCtx.getLibrary().getError(); 207 208 if (err != expected) 209 { 210 m_testCtx.getLog() << TestLog::Message << "// ERROR expected: " << eglu::getErrorStr(expected) << ", Got: " << eglu::getErrorStr(err) << TestLog::EndMessage; 211 if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) 212 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid error"); 213 } 214 } 215 216 void NegativePartialUpdateTest::expectBoolean (EGLBoolean expected, EGLBoolean got) 217 { 218 if (expected != got) 219 { 220 m_testCtx.getLog() << TestLog::Message << "// ERROR expected: " << eglu::getBooleanStr(expected) << ", Got: " << eglu::getBooleanStr(got) << TestLog::EndMessage; 221 if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) 222 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value"); 223 } 224 } 225 226 class NotPostableTest : public NegativePartialUpdateTest 227 { 228 public: 229 NotPostableTest (EglTestContext& context); 230 TestCase::IterateResult iterate (void); 231 }; 232 233 NotPostableTest::NotPostableTest (EglTestContext& context) 234 : NegativePartialUpdateTest (context, false, SURFACETYPE_PBUFFER, "not_postable_surface", "Call setDamageRegion() on pbuffer") 235 { 236 } 237 238 TestCase::IterateResult NotPostableTest::iterate (void) 239 { 240 const Library& egl = m_eglTestCtx.getLibrary(); 241 TestLog& log = m_testCtx.getLog(); 242 CallLogWrapper wrapper (egl, log); 243 EGLint damageRegion[] = { 10, 10, 10, 10 }; 244 int bufferAge = -1; 245 246 wrapper.enableLogging(true); 247 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 248 { 249 tcu::ScopedLogSection(log, "Test1", "If the surface is pbuffer (not postable) --> EGL_BAD_MATCH"); 250 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED)); 251 EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge)); 252 expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion, DE_LENGTH_OF_ARRAY(damageRegion)/4)); 253 expectError(EGL_BAD_MATCH); 254 } 255 256 return STOP; 257 } 258 259 class NotCurrentSurfaceTest : public NegativePartialUpdateTest 260 { 261 public: 262 NotCurrentSurfaceTest (EglTestContext& context); 263 TestCase::IterateResult iterate (void); 264 }; 265 266 NotCurrentSurfaceTest::NotCurrentSurfaceTest (EglTestContext& context) 267 : NegativePartialUpdateTest (context, false, SURFACETYPE_WINDOW, "not_current_surface", "Call setDamageRegion() on pbuffer") 268 { 269 } 270 271 TestCase::IterateResult NotCurrentSurfaceTest::iterate (void) 272 { 273 const int impossibleBufferAge = -26084; 274 const Library& egl = m_eglTestCtx.getLibrary(); 275 const EGLConfig config = getEGLConfig(egl, m_eglDisplay, SURFACETYPE_PBUFFER, false); 276 const EGLint attribList[] = 277 { 278 EGL_WIDTH, 64, 279 EGL_HEIGHT, 64, 280 EGL_NONE 281 }; 282 const eglu::UniqueSurface dummyPbuffer (egl, m_eglDisplay, egl.createPbufferSurface(m_eglDisplay, config, attribList)); 283 TestLog& log = m_testCtx.getLog(); 284 CallLogWrapper wrapper (egl, log); 285 EGLint damageRegion[] = { 10, 10, 10, 10 }; 286 int bufferAge = impossibleBufferAge; 287 288 wrapper.enableLogging(true); 289 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 290 EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, *dummyPbuffer, *dummyPbuffer, m_eglContext)); 291 { 292 tcu::ScopedLogSection(log, "Test2.1", "If query buffer age on a surface that is not the current draw surface --> EGL_BAD_SURFACE"); 293 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED)); 294 expectFalse(wrapper.eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge)); 295 expectError(EGL_BAD_SURFACE); 296 297 if (bufferAge != impossibleBufferAge) 298 { 299 log << tcu::TestLog::Message << "On failure, eglQuerySurface shouldn't change buffer age but buffer age has been changed to " << bufferAge << tcu::TestLog::EndMessage; 300 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail, bufferAge shouldn't be changed"); 301 } 302 } 303 { 304 tcu::ScopedLogSection(log, "Test2.2", "If call setDamageRegion() on a surface that is not the current draw surface --> EGL_BAD_MATCH"); 305 expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion, 1)); 306 expectError(EGL_BAD_MATCH); 307 } 308 309 EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); 310 { 311 tcu::ScopedLogSection(log, "Test3.1", "If query buffer age on a surface that is not the current draw surface --> EGL_BAD_SURFACE"); 312 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED)); 313 expectFalse(wrapper.eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge)); 314 expectError(EGL_BAD_SURFACE); 315 316 if (bufferAge != impossibleBufferAge) 317 { 318 log << tcu::TestLog::Message << "On failure, eglQuerySurface shouldn't change buffer age but buffer age has been changed to " << bufferAge << tcu::TestLog::EndMessage; 319 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail, bufferAge shouldn't be changed"); 320 } 321 } 322 { 323 tcu::ScopedLogSection(log, "Test3.2", "If call setDamageRegion() on a surface that is not the current draw surface --> EGL_BAD_MATCH"); 324 expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion, 1)); 325 expectError(EGL_BAD_MATCH); 326 } 327 328 if (hasExtension(egl, m_eglDisplay, "EGL_KHR_surfaceless_context")) 329 { 330 EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, m_eglContext)); 331 { 332 tcu::ScopedLogSection(log, "Test4.1", "If query buffer age on a surface that is not the current draw surface --> EGL_BAD_SURFACE"); 333 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED)); 334 expectFalse(wrapper.eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge)); 335 expectError(EGL_BAD_SURFACE); 336 337 if (bufferAge != impossibleBufferAge) 338 { 339 log << tcu::TestLog::Message << "On failure, eglQuerySurface shouldn't change buffer age but buffer age has been changed to " << bufferAge << tcu::TestLog::EndMessage; 340 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail, bufferAge shouldn't be changed"); 341 } 342 } 343 { 344 tcu::ScopedLogSection(log, "Test4.2", "If call setDamageRegion() on a surface that is not the current draw surface --> EGL_BAD_MATCH"); 345 expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion, 1)); 346 expectError(EGL_BAD_MATCH); 347 } 348 } 349 350 return STOP; 351 } 352 353 class BufferPreservedTest : public NegativePartialUpdateTest 354 { 355 public: 356 BufferPreservedTest (EglTestContext& context); 357 TestCase::IterateResult iterate (void); 358 }; 359 360 BufferPreservedTest::BufferPreservedTest (EglTestContext& context) 361 : NegativePartialUpdateTest (context, true, SURFACETYPE_WINDOW, "buffer_preserved", "Call setDamageRegion() on pbuffer") 362 { 363 } 364 365 TestCase::IterateResult BufferPreservedTest::iterate (void) 366 { 367 const Library& egl = m_eglTestCtx.getLibrary(); 368 TestLog& log = m_testCtx.getLog(); 369 CallLogWrapper wrapper (egl, log); 370 EGLint damageRegion[] = { 10, 10, 10, 10 }; 371 int bufferAge = -1; 372 373 wrapper.enableLogging(true); 374 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 375 { 376 tcu::ScopedLogSection(log, "Test3", "If buffer_preserved --> EGL_BAD_MATCH"); 377 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED)); 378 EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge)); 379 expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion, DE_LENGTH_OF_ARRAY(damageRegion)/4)); 380 expectError(EGL_BAD_MATCH); 381 } 382 383 return STOP; 384 } 385 386 class SetTwiceTest : public NegativePartialUpdateTest 387 { 388 public: 389 SetTwiceTest (EglTestContext& context); 390 TestCase::IterateResult iterate (void); 391 }; 392 393 SetTwiceTest::SetTwiceTest (EglTestContext& context) 394 : NegativePartialUpdateTest (context, false, SURFACETYPE_WINDOW, "set_damage_region_twice", "Call setDamageRegion() twice") 395 { 396 } 397 398 TestCase::IterateResult SetTwiceTest::iterate (void) 399 { 400 const Library& egl = m_eglTestCtx.getLibrary(); 401 TestLog& log = m_testCtx.getLog(); 402 CallLogWrapper wrapper (egl, log); 403 EGLint damageRegion[] = { 10, 10, 10, 10 }; 404 int bufferAge = -1; 405 406 wrapper.enableLogging(true); 407 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 408 { 409 tcu::ScopedLogSection(log, "Test4", "If call setDamageRegion() twice --> EGL_BAD_ACCESS"); 410 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED)); 411 EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge)); 412 expectTrue(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion, DE_LENGTH_OF_ARRAY(damageRegion)/4)); 413 expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion, DE_LENGTH_OF_ARRAY(damageRegion)/4)); 414 expectError(EGL_BAD_ACCESS); 415 } 416 417 return STOP; 418 } 419 420 421 class NoAgeTest : public NegativePartialUpdateTest 422 { 423 public: 424 NoAgeTest (EglTestContext& context); 425 TestCase::IterateResult iterate (void); 426 }; 427 428 NoAgeTest::NoAgeTest (EglTestContext& context) 429 : NegativePartialUpdateTest (context, false, SURFACETYPE_WINDOW, "set_damage_region_before_query_age", "Call setDamageRegion() without querying buffer age") 430 { 431 } 432 433 TestCase::IterateResult NoAgeTest::iterate (void) 434 { 435 const Library& egl = m_eglTestCtx.getLibrary(); 436 TestLog& log = m_testCtx.getLog(); 437 CallLogWrapper wrapper (egl, log); 438 EGLint damageRegion[] = { 10, 10, 10, 10 }; 439 440 wrapper.enableLogging(true); 441 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 442 { 443 tcu::ScopedLogSection(log, "Test5", "If buffer age is not queried --> EGL_BAD_ACCESS"); 444 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED)); 445 expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion, DE_LENGTH_OF_ARRAY(damageRegion)/4)); 446 expectError(EGL_BAD_ACCESS); 447 } 448 449 return STOP; 450 } 451 452 class PassNullTest : public NegativePartialUpdateTest 453 { 454 public: 455 PassNullTest (EglTestContext& context); 456 TestCase::IterateResult iterate (void); 457 }; 458 459 PassNullTest::PassNullTest (EglTestContext& context) 460 : NegativePartialUpdateTest (context, false, SURFACETYPE_WINDOW, "pass_null_0_as_params", "Call setDamageRegion() with (NULL, 0)") 461 { 462 } 463 464 TestCase::IterateResult PassNullTest::iterate (void) 465 { 466 const Library& egl = m_eglTestCtx.getLibrary(); 467 TestLog& log = m_testCtx.getLog(); 468 CallLogWrapper wrapper (egl, log); 469 int bufferAge = -1; 470 471 wrapper.enableLogging(true); 472 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 473 { 474 tcu::ScopedLogSection(log, "Test6", "If pass (null, 0) to setDamageRegion(), no error"); 475 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED)); 476 EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge)); 477 expectTrue(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, DE_NULL, 0)); 478 expectError(EGL_SUCCESS); 479 } 480 481 return STOP; 482 } 483 484 class NotCurrentSurfaceTest2 : public NegativePartialUpdateTest 485 { 486 public: 487 NotCurrentSurfaceTest2 (EglTestContext& context); 488 TestCase::IterateResult iterate (void); 489 }; 490 491 NotCurrentSurfaceTest2::NotCurrentSurfaceTest2 (EglTestContext& context) 492 : NegativePartialUpdateTest (context, false, SURFACETYPE_WINDOW, "not_current_surface2", "Call setDamageRegion() on pbuffer") 493 { 494 } 495 496 TestCase::IterateResult NotCurrentSurfaceTest2::iterate (void) 497 { 498 const Library& egl = m_eglTestCtx.getLibrary(); 499 const EGLConfig config = getEGLConfig(egl, m_eglDisplay, SURFACETYPE_PBUFFER, false); 500 const EGLint attribList[] = 501 { 502 EGL_WIDTH, 64, 503 EGL_HEIGHT, 64, 504 EGL_NONE 505 }; 506 const eglu::UniqueSurface dummyPbuffer (egl, m_eglDisplay, egl.createPbufferSurface(m_eglDisplay, config, attribList)); 507 TestLog& log = m_testCtx.getLog(); 508 CallLogWrapper wrapper (egl, log); 509 EGLint damageRegion[] = { 10, 10, 10, 10 }; 510 int bufferAge = -1; 511 512 wrapper.enableLogging(true); 513 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 514 515 EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED)); 516 EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge)); 517 518 { 519 tcu::ScopedLogSection(log, "Test7", "If call setDamageRegion() on a surface that is not the current draw surface --> EGL_BAD_MATCH"); 520 EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, *dummyPbuffer, *dummyPbuffer, m_eglContext)); 521 expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion, 1)); 522 expectError(EGL_BAD_MATCH); 523 } 524 { 525 tcu::ScopedLogSection(log, "Test8", "If call setDamageRegion() on a surface that is not the current draw surface --> EGL_BAD_MATCH"); 526 EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); 527 expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion, 1)); 528 expectError(EGL_BAD_MATCH); 529 } 530 if (hasExtension(egl, m_eglDisplay, "EGL_KHR_surfaceless_context")) 531 { 532 tcu::ScopedLogSection(log, "Test9", "If call setDamageRegion() on a surface that is not the current draw surface --> EGL_BAD_MATCH"); 533 EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, m_eglContext)); 534 expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion, 1)); 535 expectError(EGL_BAD_MATCH); 536 } 537 538 return STOP; 539 } 540 541 } // anonymous 542 543 NegativePartialUpdateTests::NegativePartialUpdateTests (EglTestContext& eglTestCtx) 544 : TestCaseGroup(eglTestCtx, "negative_partial_update", "Negative partial update tests") 545 { 546 } 547 548 void NegativePartialUpdateTests::init (void) 549 { 550 addChild(new NotPostableTest(m_eglTestCtx)); 551 addChild(new NotCurrentSurfaceTest(m_eglTestCtx)); 552 addChild(new BufferPreservedTest(m_eglTestCtx)); 553 addChild(new SetTwiceTest(m_eglTestCtx)); 554 addChild(new NoAgeTest(m_eglTestCtx)); 555 addChild(new PassNullTest(m_eglTestCtx)); 556 addChild(new NotCurrentSurfaceTest2(m_eglTestCtx)); 557 } 558 559 } // egl 560 } // deqp 561
