1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL (ES) 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 Common object lifetime tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "glsLifetimeTests.hpp" 25 26 #include "deString.h" 27 #include "deRandom.hpp" 28 #include "deSTLUtil.hpp" 29 #include "deStringUtil.hpp" 30 #include "tcuRGBA.hpp" 31 #include "tcuImageCompare.hpp" 32 #include "tcuRenderTarget.hpp" 33 #include "tcuStringTemplate.hpp" 34 #include "tcuTestLog.hpp" 35 #include "gluDrawUtil.hpp" 36 #include "gluObjectWrapper.hpp" 37 #include "gluPixelTransfer.hpp" 38 #include "gluShaderProgram.hpp" 39 #include "gluDefs.hpp" 40 #include "gluTextureUtil.hpp" 41 #include "gluStrUtil.hpp" 42 #include "glwFunctions.hpp" 43 44 #include <vector> 45 #include <map> 46 #include <algorithm> 47 #include <sstream> 48 49 namespace deqp 50 { 51 namespace gls 52 { 53 namespace LifetimeTests 54 { 55 namespace details 56 { 57 58 using std::map; 59 using std::string; 60 using std::ostringstream; 61 using de::Random; 62 using tcu::RenderTarget; 63 using tcu::RGBA; 64 using tcu::StringTemplate; 65 using tcu::TestCase; 66 typedef TestCase::IterateResult IterateResult; 67 using tcu::TestLog; 68 using tcu::ScopedLogSection; 69 using glu::Program; 70 using glu::Shader; 71 using glu::Framebuffer; 72 using glu::SHADERTYPE_VERTEX; 73 using glu::SHADERTYPE_FRAGMENT; 74 using namespace glw; 75 76 enum { VIEWPORT_SIZE = 128, FRAMEBUFFER_SIZE = 128 }; 77 78 GLint getInteger (ContextWrapper& gl, GLenum queryParam) 79 { 80 GLint ret = 0; 81 GLU_CHECK_CALL_ERROR( 82 gl.glGetIntegerv(queryParam, &ret), 83 gl.glGetError()); 84 gl.log() << TestLog::Message << "// Single integer output: " << ret << TestLog::EndMessage; 85 return ret; 86 } 87 88 #define GLSL100_SRC(BODY) ("#version 100\n" #BODY "\n") 89 90 static const char* const s_vertexShaderSrc = GLSL100_SRC( 91 attribute vec2 pos; 92 void main() 93 { 94 gl_Position = vec4(pos.xy, 0.0, 1.0); 95 } 96 ); 97 98 static const char* const s_fragmentShaderSrc = GLSL100_SRC( 99 void main() 100 { 101 gl_FragColor = vec4(1.0); 102 } 103 ); 104 105 class CheckedShader : public Shader 106 { 107 public: 108 CheckedShader (const RenderContext& renderCtx, glu::ShaderType type, const string& src) 109 : Shader (renderCtx, type) 110 { 111 const char* const srcStr = src.c_str(); 112 setSources(1, &srcStr, DE_NULL); 113 compile(); 114 TCU_CHECK(getCompileStatus()); 115 } 116 }; 117 118 class CheckedProgram : public Program 119 { 120 public: 121 CheckedProgram (const RenderContext& renderCtx, GLuint vtxShader, GLuint fragShader) 122 : Program (renderCtx) 123 { 124 attachShader(vtxShader); 125 attachShader(fragShader); 126 link(); 127 TCU_CHECK(getLinkStatus()); 128 } 129 }; 130 131 ContextWrapper::ContextWrapper (const Context& ctx) 132 : CallLogWrapper (ctx.gl(), ctx.log()) 133 , m_ctx (ctx) 134 { 135 enableLogging(true); 136 } 137 138 void SimpleBinder::bind (GLuint name) 139 { 140 (this->*m_bindFunc)(m_bindTarget, name); 141 } 142 143 GLuint SimpleBinder::getBinding (void) 144 { 145 return getInteger(*this, m_bindingParam); 146 } 147 148 GLuint SimpleType::gen (void) 149 { 150 GLuint ret; 151 (this->*m_genFunc)(1, &ret); 152 return ret; 153 } 154 155 class VertexArrayBinder : public SimpleBinder 156 { 157 public: 158 VertexArrayBinder (Context& ctx) 159 : SimpleBinder (ctx, 0, GL_NONE, GL_VERTEX_ARRAY_BINDING, true) {} 160 void bind (GLuint name) { glBindVertexArray(name); } 161 }; 162 163 class QueryBinder : public Binder 164 { 165 public: 166 QueryBinder (Context& ctx) : Binder(ctx) {} 167 void bind (GLuint name) 168 { 169 if (name != 0) 170 glBeginQuery(GL_ANY_SAMPLES_PASSED, name); 171 else 172 glEndQuery(GL_ANY_SAMPLES_PASSED); 173 } 174 GLuint getBinding (void) { return 0; } 175 }; 176 177 bool ProgramType::isDeleteFlagged (GLuint name) 178 { 179 GLint deleteFlagged = 0; 180 glGetProgramiv(name, GL_DELETE_STATUS, &deleteFlagged); 181 return deleteFlagged != 0; 182 } 183 184 bool ShaderType::isDeleteFlagged (GLuint name) 185 { 186 GLint deleteFlagged = 0; 187 glGetShaderiv(name, GL_DELETE_STATUS, &deleteFlagged); 188 return deleteFlagged != 0; 189 } 190 191 void setupFbo (const Context& ctx, GLuint seed, GLuint fbo) 192 { 193 const Functions& gl = ctx.getRenderContext().getFunctions(); 194 195 GLU_CHECK_CALL_ERROR(gl.bindFramebuffer(GL_FRAMEBUFFER, fbo), 196 gl.getError()); 197 198 if (seed == 0) 199 { 200 gl.clearColor(0.0, 0.0, 0.0, 1.0); 201 GLU_CHECK_CALL_ERROR(gl.clear(GL_COLOR_BUFFER_BIT), gl.getError()); 202 } 203 else 204 { 205 Random rnd (seed); 206 const GLsizei width = rnd.getInt(0, FRAMEBUFFER_SIZE); 207 const GLsizei height = rnd.getInt(0, FRAMEBUFFER_SIZE); 208 const GLint x = rnd.getInt(0, FRAMEBUFFER_SIZE - width); 209 const GLint y = rnd.getInt(0, FRAMEBUFFER_SIZE - height); 210 const GLfloat r1 = rnd.getFloat(); 211 const GLfloat g1 = rnd.getFloat(); 212 const GLfloat b1 = rnd.getFloat(); 213 const GLfloat a1 = rnd.getFloat(); 214 const GLfloat r2 = rnd.getFloat(); 215 const GLfloat g2 = rnd.getFloat(); 216 const GLfloat b2 = rnd.getFloat(); 217 const GLfloat a2 = rnd.getFloat(); 218 219 GLU_CHECK_CALL_ERROR(gl.clearColor(r1, g1, b1, a1), gl.getError()); 220 GLU_CHECK_CALL_ERROR(gl.clear(GL_COLOR_BUFFER_BIT), gl.getError()); 221 gl.scissor(x, y, width, height); 222 gl.enable(GL_SCISSOR_TEST); 223 gl.clearColor(r2, g2, b2, a2); 224 gl.clear(GL_COLOR_BUFFER_BIT); 225 gl.disable(GL_SCISSOR_TEST); 226 } 227 228 gl.bindFramebuffer(GL_FRAMEBUFFER, 0); 229 GLU_CHECK_ERROR(gl.getError()); 230 } 231 232 void drawFbo (const Context& ctx, GLuint fbo, Surface& dst) 233 { 234 const RenderContext& renderCtx = ctx.getRenderContext(); 235 const Functions& gl = renderCtx.getFunctions(); 236 237 GLU_CHECK_CALL_ERROR( 238 gl.bindFramebuffer(GL_FRAMEBUFFER, fbo), 239 gl.getError()); 240 241 dst.setSize(FRAMEBUFFER_SIZE, FRAMEBUFFER_SIZE); 242 glu::readPixels(renderCtx, 0, 0, dst.getAccess()); 243 GLU_EXPECT_NO_ERROR(gl.getError(), "Read pixels from framebuffer"); 244 245 GLU_CHECK_CALL_ERROR( 246 gl.bindFramebuffer(GL_FRAMEBUFFER, 0), 247 gl.getError()); 248 } 249 250 GLuint getFboAttachment (const Functions& gl, GLuint fbo, GLenum requiredType) 251 { 252 GLint type = 0, name = 0; 253 gl.bindFramebuffer(GL_FRAMEBUFFER, fbo); 254 GLU_CHECK_CALL_ERROR( 255 gl.getFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 256 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, 257 &type), 258 gl.getError()); 259 260 if (GLenum(type) != requiredType || GLenum(type) == GL_NONE) 261 return 0; 262 263 GLU_CHECK_CALL_ERROR( 264 gl.getFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 265 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, 266 &name), 267 gl.getError()); 268 gl.bindFramebuffer(GL_FRAMEBUFFER, 0); 269 GLU_CHECK_ERROR(gl.getError()); 270 271 return name; 272 } 273 274 void FboAttacher::initAttachment (GLuint seed, GLuint element) 275 { 276 Binder& binder = *getElementType().binder(); 277 Framebuffer fbo(getRenderContext()); 278 279 enableLogging(false); 280 281 binder.enableLogging(false); 282 binder.bind(element); 283 initStorage(); 284 binder.bind(0); 285 binder.enableLogging(true); 286 287 attach(element, *fbo); 288 setupFbo(getContext(), seed, *fbo); 289 detach(element, *fbo); 290 291 enableLogging(true); 292 293 log() << TestLog::Message 294 << "// Drew to " << getElementType().getName() << " " << element 295 << " with seed " << seed << "." 296 << TestLog::EndMessage; 297 } 298 299 void FboInputAttacher::drawContainer (GLuint fbo, Surface& dst) 300 { 301 drawFbo(getContext(), fbo, dst); 302 log() << TestLog::Message 303 << "// Read pixels from framebuffer " << fbo << " to output image." 304 << TestLog::EndMessage; 305 } 306 307 void FboOutputAttacher::setupContainer (GLuint seed, GLuint fbo) 308 { 309 setupFbo(getContext(), seed, fbo); 310 log() << TestLog::Message 311 << "// Drew to framebuffer " << fbo << " with seed " << seed << "." 312 << TestLog::EndMessage; 313 } 314 315 void FboOutputAttacher::drawAttachment (GLuint element, Surface& dst) 316 { 317 Framebuffer fbo(getRenderContext()); 318 m_attacher.enableLogging(false); 319 m_attacher.attach(element, *fbo); 320 drawFbo(getContext(), *fbo, dst); 321 m_attacher.detach(element, *fbo); 322 m_attacher.enableLogging(true); 323 log() << TestLog::Message 324 << "// Read pixels from " << m_attacher.getElementType().getName() << " " << element 325 << " to output image." 326 << TestLog::EndMessage; 327 GLU_CHECK_ERROR(gl().getError()); 328 } 329 330 void TextureFboAttacher::attach (GLuint texture, GLuint fbo) 331 { 332 GLU_CHECK_CALL_ERROR( 333 glBindFramebuffer(GL_FRAMEBUFFER, fbo), 334 gl().getError()); 335 GLU_CHECK_CALL_ERROR( 336 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 337 GL_TEXTURE_2D, texture, 0), 338 gl().getError()); 339 GLU_CHECK_CALL_ERROR( 340 glBindFramebuffer(GL_FRAMEBUFFER, 0), 341 gl().getError()); 342 } 343 344 void TextureFboAttacher::detach (GLuint texture, GLuint fbo) 345 { 346 DE_UNREF(texture); 347 GLU_CHECK_CALL_ERROR( 348 glBindFramebuffer(GL_FRAMEBUFFER, fbo), 349 gl().getError()); 350 GLU_CHECK_CALL_ERROR( 351 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0), 352 gl().getError()); 353 GLU_CHECK_CALL_ERROR( 354 glBindFramebuffer(GL_FRAMEBUFFER, 0), 355 gl().getError()); 356 } 357 358 GLuint TextureFboAttacher::getAttachment (GLuint fbo) 359 { 360 return getFboAttachment(gl(), fbo, GL_TEXTURE); 361 } 362 363 static bool isTextureFormatColorRenderable (const glu::RenderContext& renderCtx, const glu::TransferFormat& format) 364 { 365 const glw::Functions& gl = renderCtx.getFunctions(); 366 deUint32 curFbo = ~0u; 367 deUint32 curTex = ~0u; 368 deUint32 testFbo = 0u; 369 deUint32 testTex = 0u; 370 GLenum status = GL_NONE; 371 372 GLU_CHECK_GLW_CALL(gl, getIntegerv(GL_FRAMEBUFFER_BINDING, (deInt32*)&curFbo)); 373 GLU_CHECK_GLW_CALL(gl, getIntegerv(GL_TEXTURE_BINDING_2D, (deInt32*)&curTex)); 374 375 try 376 { 377 GLU_CHECK_GLW_CALL(gl, genTextures(1, &testTex)); 378 GLU_CHECK_GLW_CALL(gl, bindTexture(GL_TEXTURE_2D, testTex)); 379 GLU_CHECK_GLW_CALL(gl, texImage2D(GL_TEXTURE_2D, 0, format.format, FRAMEBUFFER_SIZE, FRAMEBUFFER_SIZE, 0, 380 format.format, format.dataType, DE_NULL)); 381 382 GLU_CHECK_GLW_CALL(gl, genFramebuffers(1, &testFbo)); 383 GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, testFbo)); 384 GLU_CHECK_GLW_CALL(gl, framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, testTex, 0)); 385 386 status = gl.checkFramebufferStatus(GL_FRAMEBUFFER); 387 GLU_CHECK_GLW_MSG(gl, "glCheckFramebufferStatus(GL_FRAMEBUFFER)"); 388 389 GLU_CHECK_GLW_CALL(gl, bindTexture(GL_TEXTURE_2D, curTex)); 390 GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, curFbo)); 391 392 GLU_CHECK_GLW_CALL(gl, deleteTextures(1, &testTex)); 393 GLU_CHECK_GLW_CALL(gl, deleteFramebuffers(1, &testFbo)); 394 } 395 catch (...) 396 { 397 if (testTex != 0) 398 gl.deleteTextures(1, &testTex); 399 400 if (testFbo != 0) 401 gl.deleteFramebuffers(1, &testFbo); 402 403 throw; 404 } 405 406 if (status == GL_FRAMEBUFFER_COMPLETE) 407 return true; 408 else if (status == GL_FRAMEBUFFER_UNSUPPORTED) 409 return false; 410 else 411 TCU_THROW(TestError, (std::string("glCheckFramebufferStatus() returned invalid result code ") 412 + de::toString(glu::getFramebufferStatusStr(status))).c_str()); 413 } 414 415 static glu::TransferFormat getRenderableColorTextureFormat (const glu::RenderContext& renderCtx) 416 { 417 if (glu::contextSupports(renderCtx.getType(), glu::ApiType::es(3,0))) 418 return glu::TransferFormat(GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4); 419 420 { 421 const glu::TransferFormat candidates[] = 422 { 423 glu::TransferFormat(GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4), 424 glu::TransferFormat(GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1), 425 glu::TransferFormat(GL_RGB, GL_UNSIGNED_SHORT_5_6_5), 426 glu::TransferFormat(GL_RGBA, GL_UNSIGNED_BYTE), 427 }; 428 429 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(candidates); ++ndx) 430 { 431 if (isTextureFormatColorRenderable(renderCtx, candidates[ndx])) 432 return candidates[ndx]; 433 } 434 } 435 436 return glu::TransferFormat(GL_NONE, GL_NONE); 437 } 438 439 void TextureFboAttacher::initStorage (void) 440 { 441 const glu::TransferFormat format = getRenderableColorTextureFormat(getRenderContext()); 442 443 if (format.format == GL_NONE) 444 TCU_THROW(NotSupportedError, "No renderable texture format found"); 445 446 GLU_CHECK_CALL_ERROR( 447 glTexImage2D(GL_TEXTURE_2D, 0, format.format, FRAMEBUFFER_SIZE, FRAMEBUFFER_SIZE, 0, 448 format.format, format.dataType, DE_NULL), 449 gl().getError()); 450 } 451 452 static bool isRenderbufferFormatColorRenderable (const glu::RenderContext& renderCtx, const deUint32 format) 453 { 454 const glw::Functions& gl = renderCtx.getFunctions(); 455 deUint32 curFbo = ~0u; 456 deUint32 curRbo = ~0u; 457 deUint32 testFbo = 0u; 458 deUint32 testRbo = 0u; 459 GLenum status = GL_NONE; 460 461 GLU_CHECK_GLW_CALL(gl, getIntegerv(GL_FRAMEBUFFER_BINDING, (deInt32*)&curFbo)); 462 GLU_CHECK_GLW_CALL(gl, getIntegerv(GL_RENDERBUFFER_BINDING, (deInt32*)&curRbo)); 463 464 try 465 { 466 GLU_CHECK_GLW_CALL(gl, genRenderbuffers(1, &testRbo)); 467 GLU_CHECK_GLW_CALL(gl, bindRenderbuffer(GL_RENDERBUFFER, testRbo)); 468 GLU_CHECK_GLW_CALL(gl, renderbufferStorage(GL_RENDERBUFFER, format, FRAMEBUFFER_SIZE, FRAMEBUFFER_SIZE)); 469 470 GLU_CHECK_GLW_CALL(gl, genFramebuffers(1, &testFbo)); 471 GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, testFbo)); 472 GLU_CHECK_GLW_CALL(gl, framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, testRbo)); 473 474 status = gl.checkFramebufferStatus(GL_FRAMEBUFFER); 475 GLU_CHECK_GLW_MSG(gl, "glCheckFramebufferStatus(GL_FRAMEBUFFER)"); 476 477 GLU_CHECK_GLW_CALL(gl, bindRenderbuffer(GL_RENDERBUFFER, curRbo)); 478 GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, curFbo)); 479 480 GLU_CHECK_GLW_CALL(gl, deleteRenderbuffers(1, &testRbo)); 481 GLU_CHECK_GLW_CALL(gl, deleteFramebuffers(1, &testFbo)); 482 } 483 catch (...) 484 { 485 if (testRbo != 0) 486 gl.deleteRenderbuffers(1, &testRbo); 487 488 if (testFbo != 0) 489 gl.deleteFramebuffers(1, &testFbo); 490 491 throw; 492 } 493 494 if (status == GL_FRAMEBUFFER_COMPLETE) 495 return true; 496 else if (status == GL_FRAMEBUFFER_UNSUPPORTED) 497 return false; 498 else 499 TCU_THROW(TestError, (std::string("glCheckFramebufferStatus() returned invalid result code ") 500 + de::toString(glu::getFramebufferStatusStr(status))).c_str()); 501 } 502 503 static deUint32 getRenderableColorRenderbufferFormat (const glu::RenderContext& renderCtx) 504 { 505 if (glu::contextSupports(renderCtx.getType(), glu::ApiType::es(3,0))) 506 return GL_RGBA4; 507 508 { 509 const deUint32 candidates[] = 510 { 511 GL_RGBA4, 512 GL_RGB5_A1, 513 GL_RGB565, 514 }; 515 516 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(candidates); ++ndx) 517 { 518 if (isRenderbufferFormatColorRenderable(renderCtx, candidates[ndx])) 519 return candidates[ndx]; 520 } 521 } 522 523 return GL_NONE; 524 } 525 526 void RboFboAttacher::initStorage (void) 527 { 528 const deUint32 format = getRenderableColorRenderbufferFormat(getRenderContext()); 529 530 if (format == GL_NONE) 531 TCU_THROW(TestError, "No color-renderable renderbuffer format found"); 532 533 GLU_CHECK_CALL_ERROR( 534 glRenderbufferStorage(GL_RENDERBUFFER, format, FRAMEBUFFER_SIZE, FRAMEBUFFER_SIZE), 535 gl().getError()); 536 } 537 538 void RboFboAttacher::attach (GLuint rbo, GLuint fbo) 539 { 540 GLU_CHECK_CALL_ERROR( 541 glBindFramebuffer(GL_FRAMEBUFFER, fbo), 542 gl().getError()); 543 GLU_CHECK_CALL_ERROR( 544 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo), 545 gl().getError()); 546 GLU_CHECK_CALL_ERROR( 547 glBindFramebuffer(GL_FRAMEBUFFER, 0), 548 gl().getError()); 549 } 550 551 void RboFboAttacher::detach (GLuint rbo, GLuint fbo) 552 { 553 DE_UNREF(rbo); 554 GLU_CHECK_CALL_ERROR( 555 glBindFramebuffer(GL_FRAMEBUFFER, fbo), 556 gl().getError()); 557 GLU_CHECK_CALL_ERROR( 558 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, 0), 559 gl().getError()); 560 GLU_CHECK_CALL_ERROR( 561 glBindFramebuffer(GL_FRAMEBUFFER, 0), 562 gl().getError()); 563 } 564 565 GLuint RboFboAttacher::getAttachment (GLuint fbo) 566 { 567 return getFboAttachment(gl(), fbo, GL_RENDERBUFFER); 568 } 569 570 static const char* const s_fragmentShaderTemplate = GLSL100_SRC( 571 void main() 572 { 573 gl_FragColor = vec4(${RED}, ${GREEN}, ${BLUE}, 1.0); 574 } 575 ); 576 577 void ShaderProgramAttacher::initAttachment (GLuint seed, GLuint shader) 578 { 579 using de::insert; 580 using de::floatToString; 581 582 Random rnd(seed); 583 map<string, string> params; 584 const StringTemplate sourceTmpl (s_fragmentShaderTemplate); 585 586 insert(params, "RED", floatToString(rnd.getFloat(), 4)); 587 insert(params, "GREEN", floatToString(rnd.getFloat(), 4)); 588 insert(params, "BLUE", floatToString(rnd.getFloat(), 4)); 589 590 { 591 const string source = sourceTmpl.specialize(params); 592 const char* const sourceStr = source.c_str(); 593 594 GLU_CHECK_CALL_ERROR(glShaderSource(shader, 1, &sourceStr, DE_NULL), gl().getError()); 595 GLU_CHECK_CALL_ERROR(glCompileShader(shader), gl().getError()); 596 597 { 598 GLint compileStatus = 0; 599 gl().getShaderiv(shader, GL_COMPILE_STATUS, &compileStatus); 600 TCU_CHECK_MSG(compileStatus != 0, sourceStr); 601 } 602 } 603 } 604 605 void ShaderProgramAttacher::attach (GLuint shader, GLuint program) 606 { 607 GLU_CHECK_CALL_ERROR( 608 glAttachShader(program, shader), 609 gl().getError()); 610 } 611 612 void ShaderProgramAttacher::detach (GLuint shader, GLuint program) 613 { 614 GLU_CHECK_CALL_ERROR( 615 glDetachShader(program, shader), 616 gl().getError()); 617 } 618 619 GLuint ShaderProgramAttacher::getAttachment (GLuint program) 620 { 621 GLuint shaders[2] = { 0, 0 }; 622 const GLsizei shadersLen = DE_LENGTH_OF_ARRAY(shaders); 623 GLsizei numShaders = 0; 624 GLuint ret = 0; 625 626 gl().getAttachedShaders(program, shadersLen, &numShaders, shaders); 627 628 // There should ever be at most one attached shader in normal use, but if 629 // something is wrong, the temporary vertex shader might not have been 630 // detached properly, so let's find the fragment shader explicitly. 631 for (int ndx = 0; ndx < de::min<GLsizei>(shadersLen, numShaders); ++ndx) 632 { 633 GLint shaderType = GL_NONE; 634 gl().getShaderiv(shaders[ndx], GL_SHADER_TYPE, &shaderType); 635 636 if (shaderType == GL_FRAGMENT_SHADER) 637 { 638 ret = shaders[ndx]; 639 break; 640 } 641 } 642 643 return ret; 644 } 645 646 void setViewport (const RenderContext& renderCtx, const Rectangle& rect) 647 { 648 renderCtx.getFunctions().viewport(rect.x, rect.y, rect.width, rect.height); 649 } 650 651 void readRectangle (const RenderContext& renderCtx, const Rectangle& rect, Surface& dst) 652 { 653 dst.setSize(rect.width, rect.height); 654 glu::readPixels(renderCtx, rect.x, rect.y, dst.getAccess()); 655 } 656 657 Rectangle randomViewport (const RenderContext& ctx, GLint maxWidth, GLint maxHeight, 658 Random& rnd) 659 { 660 const RenderTarget& target = ctx.getRenderTarget(); 661 const GLint width = de::min(target.getWidth(), maxWidth); 662 const GLint xOff = rnd.getInt(0, target.getWidth() - width); 663 const GLint height = de::min(target.getHeight(), maxHeight); 664 const GLint yOff = rnd.getInt(0, target.getHeight() - height); 665 666 return Rectangle(xOff, yOff, width, height); 667 } 668 669 void ShaderProgramInputAttacher::drawContainer (GLuint program, Surface& dst) 670 { 671 static const float s_vertices[6] = { -1.0, 0.0, 1.0, 1.0, 0.0, -1.0 }; 672 Random rnd (program); 673 CheckedShader vtxShader (getRenderContext(), 674 SHADERTYPE_VERTEX, s_vertexShaderSrc); 675 const Rectangle viewport = randomViewport(getRenderContext(), 676 VIEWPORT_SIZE, VIEWPORT_SIZE, rnd); 677 678 gl().attachShader(program, vtxShader.getShader()); 679 gl().linkProgram(program); 680 681 { 682 GLint linkStatus = 0; 683 gl().getProgramiv(program, GL_LINK_STATUS, &linkStatus); 684 TCU_CHECK(linkStatus != 0); 685 } 686 687 log() << TestLog::Message 688 << "// Attached a temporary vertex shader and linked program " << program 689 << TestLog::EndMessage; 690 691 setViewport(getRenderContext(), viewport); 692 log() << TestLog::Message << "// Positioned viewport randomly" << TestLog::EndMessage; 693 694 glUseProgram(program); 695 { 696 GLint posLoc = gl().getAttribLocation(program, "pos"); 697 TCU_CHECK(posLoc >= 0); 698 699 gl().enableVertexAttribArray(posLoc); 700 701 gl().clearColor(0, 0, 0, 1); 702 gl().clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 703 gl().vertexAttribPointer(posLoc, 2, GL_FLOAT, GL_FALSE, 0, s_vertices); 704 gl().drawArrays(GL_TRIANGLES, 0, 3); 705 706 gl().disableVertexAttribArray(posLoc); 707 log () << TestLog::Message << "// Drew a fixed triangle" << TestLog::EndMessage; 708 } 709 glUseProgram(0); 710 711 readRectangle(getRenderContext(), viewport, dst); 712 log() << TestLog::Message << "// Copied viewport to output image" << TestLog::EndMessage; 713 714 gl().detachShader(program, vtxShader.getShader()); 715 log() << TestLog::Message << "// Removed temporary vertex shader" << TestLog::EndMessage; 716 } 717 718 ES2Types::ES2Types (const Context& ctx) 719 : Types (ctx) 720 , m_bufferBind (ctx, &CallLogWrapper::glBindBuffer, 721 GL_ARRAY_BUFFER, GL_ARRAY_BUFFER_BINDING) 722 , m_bufferType (ctx, "buffer", &CallLogWrapper::glGenBuffers, 723 &CallLogWrapper::glDeleteBuffers, 724 &CallLogWrapper::glIsBuffer, &m_bufferBind) 725 , m_textureBind (ctx, &CallLogWrapper::glBindTexture, GL_TEXTURE_2D, GL_TEXTURE_BINDING_2D) 726 , m_textureType (ctx, "texture", &CallLogWrapper::glGenTextures, 727 &CallLogWrapper::glDeleteTextures, 728 &CallLogWrapper::glIsTexture, &m_textureBind) 729 , m_rboBind (ctx, &CallLogWrapper::glBindRenderbuffer, 730 GL_RENDERBUFFER, GL_RENDERBUFFER_BINDING) 731 , m_rboType (ctx, "renderbuffer", 732 &CallLogWrapper::glGenRenderbuffers, 733 &CallLogWrapper::glDeleteRenderbuffers, 734 &CallLogWrapper::glIsRenderbuffer, &m_rboBind) 735 , m_fboBind (ctx, &CallLogWrapper::glBindFramebuffer, 736 GL_FRAMEBUFFER, GL_FRAMEBUFFER_BINDING) 737 , m_fboType (ctx, "framebuffer", 738 &CallLogWrapper::glGenFramebuffers, 739 &CallLogWrapper::glDeleteFramebuffers, 740 &CallLogWrapper::glIsFramebuffer, &m_fboBind) 741 , m_shaderType (ctx) 742 , m_programType (ctx) 743 , m_texFboAtt (ctx, m_textureType, m_fboType) 744 , m_texFboInAtt (m_texFboAtt) 745 , m_texFboOutAtt(m_texFboAtt) 746 , m_rboFboAtt (ctx, m_rboType, m_fboType) 747 , m_rboFboInAtt (m_rboFboAtt) 748 , m_rboFboOutAtt(m_rboFboAtt) 749 , m_shaderAtt (ctx, m_shaderType, m_programType) 750 , m_shaderInAtt (m_shaderAtt) 751 { 752 Type* const types[] = 753 { 754 &m_bufferType, &m_textureType, &m_rboType, &m_fboType, &m_shaderType, &m_programType 755 }; 756 m_types.insert(m_types.end(), DE_ARRAY_BEGIN(types), DE_ARRAY_END(types)); 757 758 m_attachers.push_back(&m_texFboAtt); 759 m_attachers.push_back(&m_rboFboAtt); 760 m_attachers.push_back(&m_shaderAtt); 761 762 m_inAttachers.push_back(&m_texFboInAtt); 763 m_inAttachers.push_back(&m_rboFboInAtt); 764 m_inAttachers.push_back(&m_shaderInAtt); 765 766 m_outAttachers.push_back(&m_texFboOutAtt); 767 m_outAttachers.push_back(&m_rboFboOutAtt); 768 } 769 770 class Name 771 { 772 public: 773 Name (Type& type) : m_type(type), m_name(type.gen()) {} 774 Name (Type& type, GLuint name) : m_type(type), m_name(name) {} 775 ~Name (void) { m_type.release(m_name); } 776 GLuint operator* (void) const { return m_name; } 777 778 private: 779 Type& m_type; 780 const GLuint m_name; 781 }; 782 783 class ResultCollector 784 { 785 public: 786 ResultCollector (TestContext& testCtx); 787 bool check (bool cond, const char* msg); 788 void fail (const char* msg); 789 void warn (const char* msg); 790 ~ResultCollector (void); 791 792 private: 793 void addResult (qpTestResult result, const char* msg); 794 795 TestContext& m_testCtx; 796 TestLog& m_log; 797 qpTestResult m_result; 798 const char* m_message; 799 }; 800 801 ResultCollector::ResultCollector (TestContext& testCtx) 802 : m_testCtx (testCtx) 803 , m_log (testCtx.getLog()) 804 , m_result (QP_TEST_RESULT_PASS) 805 , m_message ("Pass") 806 { 807 } 808 809 bool ResultCollector::check (bool cond, const char* msg) 810 { 811 if (!cond) 812 fail(msg); 813 return cond; 814 } 815 816 void ResultCollector::addResult (qpTestResult result, const char* msg) 817 { 818 m_log << TestLog::Message << "// Fail: " << msg << TestLog::EndMessage; 819 if (m_result == QP_TEST_RESULT_PASS) 820 { 821 m_result = result; 822 m_message = msg; 823 } 824 else 825 { 826 if (result == QP_TEST_RESULT_FAIL) 827 m_result = result; 828 m_message = "Multiple problems, see log for details"; 829 } 830 } 831 832 void ResultCollector::fail (const char* msg) 833 { 834 addResult(QP_TEST_RESULT_FAIL, msg); 835 } 836 837 void ResultCollector::warn (const char* msg) 838 { 839 addResult(QP_TEST_RESULT_QUALITY_WARNING, msg); 840 } 841 842 ResultCollector::~ResultCollector (void) 843 { 844 m_testCtx.setTestResult(m_result, m_message); 845 } 846 847 class TestBase : public TestCase, protected CallLogWrapper 848 { 849 protected: 850 TestBase (const char* name, 851 const char* description, 852 const Context& ctx); 853 854 // Copy ContextWrapper since MI (except for CallLogWrapper) is a no-no. 855 const Context& getContext (void) const { return m_ctx; } 856 const RenderContext& getRenderContext (void) const { return m_ctx.getRenderContext(); } 857 const Functions& gl (void) const { return m_ctx.gl(); } 858 TestLog& log (void) const { return m_ctx.log(); } 859 void init (void); 860 861 Context m_ctx; 862 Random m_rnd; 863 }; 864 865 TestBase::TestBase (const char* name, const char* description, const Context& ctx) 866 : TestCase (ctx.getTestContext(), name, description) 867 , CallLogWrapper (ctx.gl(), ctx.log()) 868 , m_ctx (ctx) 869 , m_rnd (deStringHash(name)) 870 { 871 enableLogging(true); 872 } 873 874 void TestBase::init (void) 875 { 876 m_rnd = Random(deStringHash(getName())); 877 } 878 879 class LifeTest : public TestBase 880 { 881 public: 882 typedef void (LifeTest::*TestFunction) (void); 883 884 LifeTest (const char* name, 885 const char* description, 886 Type& type, 887 TestFunction test) 888 : TestBase (name, description, type.getContext()) 889 , m_type (type) 890 , m_test (test) {} 891 892 IterateResult iterate (void); 893 894 void testGen (void); 895 void testDelete (void); 896 void testBind (void); 897 void testDeleteBound (void); 898 void testBindNoGen (void); 899 void testDeleteUsed (void); 900 901 private: 902 Binder& binder (void) { return *m_type.binder(); } 903 904 Type& m_type; 905 TestFunction m_test; 906 }; 907 908 IterateResult LifeTest::iterate (void) 909 { 910 (this->*m_test)(); 911 return STOP; 912 } 913 914 void LifeTest::testGen (void) 915 { 916 ResultCollector errors (getTestContext()); 917 Name name (m_type); 918 919 if (m_type.genCreates()) 920 errors.check(m_type.exists(*name), "Gen* should have created an object, but didn't"); 921 else 922 errors.check(!m_type.exists(*name), "Gen* should not have created an object, but did"); 923 } 924 925 void LifeTest::testDelete (void) 926 { 927 ResultCollector errors (getTestContext()); 928 GLuint name = m_type.gen(); 929 930 m_type.release(name); 931 errors.check(!m_type.exists(name), "Object still exists after deletion"); 932 } 933 934 void LifeTest::testBind (void) 935 { 936 ResultCollector errors (getTestContext()); 937 Name name (m_type); 938 939 binder().bind(*name); 940 GLU_EXPECT_NO_ERROR(gl().getError(), "Bind failed"); 941 errors.check(m_type.exists(*name), "Object does not exist after binding"); 942 binder().bind(0); 943 } 944 945 void LifeTest::testDeleteBound (void) 946 { 947 const GLuint id = m_type.gen(); 948 ResultCollector errors (getTestContext()); 949 950 binder().bind(id); 951 m_type.release(id); 952 953 if (m_type.nameLingers()) 954 { 955 errors.check(gl().getError() == GL_NO_ERROR, "Deleting bound object failed"); 956 errors.check(binder().getBinding() == id, 957 "Deleting bound object did not retain binding"); 958 errors.check(m_type.exists(id), 959 "Deleting bound object made its name invalid"); 960 errors.check(m_type.isDeleteFlagged(id), 961 "Deleting bound object did not flag the object for deletion"); 962 binder().bind(0); 963 } 964 else 965 { 966 errors.check(gl().getError() == GL_NO_ERROR, "Deleting bound object failed"); 967 errors.check(binder().getBinding() == 0, 968 "Deleting bound object did not remove binding"); 969 errors.check(!m_type.exists(id), 970 "Deleting bound object did not make its name invalid"); 971 binder().bind(0); 972 } 973 974 errors.check(binder().getBinding() == 0, "Unbinding didn't remove binding"); 975 errors.check(!m_type.exists(id), "Name is still valid after deleting and unbinding"); 976 } 977 978 void LifeTest::testBindNoGen (void) 979 { 980 ResultCollector errors (getTestContext()); 981 const GLuint id = m_rnd.getUint32(); 982 983 if (!errors.check(!m_type.exists(id), "Randomly chosen identifier already exists")) 984 return; 985 986 Name name (m_type, id); 987 binder().bind(*name); 988 989 if (binder().genRequired()) 990 { 991 errors.check(glGetError() == GL_INVALID_OPERATION, 992 "Did not fail when binding a name not generated by Gen* call"); 993 errors.check(!m_type.exists(*name), 994 "Bind* created an object for a name not generated by a Gen* call"); 995 } 996 else 997 { 998 errors.check(glGetError() == GL_NO_ERROR, 999 "Failed when binding a name not generated by Gen* call"); 1000 errors.check(m_type.exists(*name), 1001 "Object was not created by the Bind* call"); 1002 } 1003 } 1004 1005 void LifeTest::testDeleteUsed (void) 1006 { 1007 ResultCollector errors(getTestContext()); 1008 GLuint programId = 0; 1009 1010 { 1011 CheckedShader vtxShader (getRenderContext(), 1012 SHADERTYPE_VERTEX, s_vertexShaderSrc); 1013 CheckedShader fragShader (getRenderContext(), 1014 SHADERTYPE_FRAGMENT, s_fragmentShaderSrc); 1015 CheckedProgram program (getRenderContext(), 1016 vtxShader.getShader(), fragShader.getShader()); 1017 1018 programId = program.getProgram(); 1019 1020 log() << TestLog::Message << "// Created and linked program " << programId 1021 << TestLog::EndMessage; 1022 GLU_CHECK_CALL_ERROR(glUseProgram(programId), gl().getError()); 1023 1024 log() << TestLog::Message << "// Deleted program " << programId 1025 << TestLog::EndMessage; 1026 } 1027 TCU_CHECK(glIsProgram(programId)); 1028 { 1029 GLint deleteFlagged = 0; 1030 glGetProgramiv(programId, GL_DELETE_STATUS, &deleteFlagged); 1031 errors.check(deleteFlagged != 0, "Program object was not flagged as deleted"); 1032 } 1033 GLU_CHECK_CALL_ERROR(glUseProgram(0), gl().getError()); 1034 errors.check(!gl().isProgram(programId), 1035 "Deleted program name still valid after being made non-current"); 1036 } 1037 1038 class AttachmentTest : public TestBase 1039 { 1040 public: 1041 typedef void (AttachmentTest::*TestFunction) (void); 1042 AttachmentTest (const char* name, 1043 const char* description, 1044 Attacher& attacher, 1045 TestFunction test) 1046 : TestBase (name, description, attacher.getContext()) 1047 , m_attacher (attacher) 1048 , m_test (test) {} 1049 IterateResult iterate (void); 1050 1051 void testDeletedNames (void); 1052 void testDeletedBinding (void); 1053 void testDeletedReattach (void); 1054 1055 private: 1056 Attacher& m_attacher; 1057 const TestFunction m_test; 1058 }; 1059 1060 IterateResult AttachmentTest::iterate (void) 1061 { 1062 (this->*m_test)(); 1063 return STOP; 1064 } 1065 1066 GLuint getAttachment (Attacher& attacher, GLuint container) 1067 { 1068 const GLuint queriedAttachment = attacher.getAttachment(container); 1069 attacher.log() << TestLog::Message 1070 << "// Result of query for " << attacher.getElementType().getName() 1071 << " attached to " << attacher.getContainerType().getName() << " " 1072 << container << ": " << queriedAttachment << "." 1073 << TestLog::EndMessage; 1074 return queriedAttachment; 1075 } 1076 1077 void AttachmentTest::testDeletedNames (void) 1078 { 1079 Type& elemType = m_attacher.getElementType(); 1080 Type& containerType = m_attacher.getContainerType(); 1081 Name container (containerType); 1082 ResultCollector errors (getTestContext()); 1083 GLuint elementId = 0; 1084 1085 { 1086 Name element(elemType); 1087 elementId = *element; 1088 m_attacher.initAttachment(0, *element); 1089 m_attacher.attach(*element, *container); 1090 errors.check(getAttachment(m_attacher, *container) == elementId, 1091 "Attachment name not returned by query even before deletion."); 1092 } 1093 1094 // "Such a container or other context may continue using the object, and 1095 // may still contain state identifying its name as being currently bound" 1096 // 1097 // We here interpret "may" to mean that whenever the container has a 1098 // deleted object attached to it, a query will return that object's former 1099 // name. 1100 errors.check(getAttachment(m_attacher, *container) == elementId, 1101 "Attachment name not returned by query after attachment was deleted."); 1102 1103 if (elemType.nameLingers()) 1104 errors.check(elemType.exists(elementId), 1105 "Attached object name no longer valid after deletion."); 1106 else 1107 errors.check(!elemType.exists(elementId), 1108 "Attached object name still valid after deletion."); 1109 1110 m_attacher.detach(elementId, *container); 1111 errors.check(getAttachment(m_attacher, *container) == 0, 1112 "Attachment name returned by query even after detachment."); 1113 errors.check(!elemType.exists(elementId), 1114 "Deleted attached object name still usable after detachment."); 1115 }; 1116 1117 class InputAttachmentTest : public TestBase 1118 { 1119 public: 1120 InputAttachmentTest (const char* name, 1121 const char* description, 1122 InputAttacher& inputAttacher) 1123 : TestBase (name, description, inputAttacher.getContext()) 1124 , m_inputAttacher (inputAttacher) {} 1125 1126 IterateResult iterate (void); 1127 1128 private: 1129 InputAttacher& m_inputAttacher; 1130 }; 1131 1132 GLuint replaceName (Type& type, GLuint oldName, TestLog& log) 1133 { 1134 const Binder* const binder = type.binder(); 1135 const bool genRequired = binder == DE_NULL || binder->genRequired(); 1136 1137 if (genRequired) 1138 return type.gen(); 1139 1140 log << TestLog::Message 1141 << "// Type does not require Gen* for binding, reusing old id " << oldName << "." 1142 << TestLog::EndMessage; 1143 1144 return oldName; 1145 } 1146 1147 IterateResult InputAttachmentTest::iterate (void) 1148 { 1149 Attacher& attacher = m_inputAttacher.getAttacher(); 1150 Type& containerType = attacher.getContainerType(); 1151 Type& elementType = attacher.getElementType(); 1152 Name container (containerType); 1153 GLuint elementId = 0; 1154 const GLuint refSeed = m_rnd.getUint32(); 1155 const GLuint newSeed = m_rnd.getUint32(); 1156 ResultCollector errors (getTestContext()); 1157 1158 Surface refSurface; // Surface from drawing with refSeed-seeded attachment 1159 Surface delSurface; // Surface from drawing with deleted refSeed attachment 1160 Surface newSurface; // Surface from drawing with newSeed-seeded attachment 1161 1162 log() << TestLog::Message 1163 << "Testing if writing to a newly created object modifies a deleted attachment" 1164 << TestLog::EndMessage; 1165 1166 { 1167 ScopedLogSection section (log(), 1168 "Write to original", "Writing to an original attachment"); 1169 const Name element (elementType); 1170 1171 elementId = *element; 1172 attacher.initAttachment(refSeed, elementId); 1173 attacher.attach(elementId, *container); 1174 m_inputAttacher.drawContainer(*container, refSurface); 1175 // element gets deleted here 1176 log() << TestLog::Message << "// Deleting attachment"; 1177 } 1178 { 1179 ScopedLogSection section (log(), "Write to new", 1180 "Writing to a new attachment after deleting the original"); 1181 const GLuint newId = replaceName(elementType, elementId, log()); 1182 const Name newElement (elementType, newId); 1183 1184 attacher.initAttachment(newSeed, newId); 1185 1186 m_inputAttacher.drawContainer(*container, delSurface); 1187 attacher.detach(elementId, *container); 1188 1189 attacher.attach(newId, *container); 1190 m_inputAttacher.drawContainer(*container, newSurface); 1191 attacher.detach(newId, *container); 1192 } 1193 { 1194 const bool surfacesMatch = tcu::pixelThresholdCompare( 1195 log(), "Reading from deleted", 1196 "Comparison result from reading from a container with a deleted attachment " 1197 "before and after writing to a fresh object.", 1198 refSurface, delSurface, RGBA(0, 0, 0, 0), tcu::COMPARE_LOG_RESULT); 1199 1200 errors.check( 1201 surfacesMatch, 1202 "Writing to a fresh object modified the container with a deleted attachment."); 1203 1204 if (!surfacesMatch) 1205 log() << TestLog::Image("New attachment", 1206 "Container state after attached to the fresh object", 1207 newSurface); 1208 } 1209 1210 return STOP; 1211 } 1212 1213 class OutputAttachmentTest : public TestBase 1214 { 1215 public: 1216 OutputAttachmentTest (const char* name, 1217 const char* description, 1218 OutputAttacher& outputAttacher) 1219 : TestBase (name, description, 1220 outputAttacher.getContext()) 1221 , m_outputAttacher (outputAttacher) {} 1222 IterateResult iterate (void); 1223 1224 private: 1225 OutputAttacher& m_outputAttacher; 1226 }; 1227 1228 IterateResult OutputAttachmentTest::iterate (void) 1229 { 1230 Attacher& attacher = m_outputAttacher.getAttacher(); 1231 Type& containerType = attacher.getContainerType(); 1232 Type& elementType = attacher.getElementType(); 1233 Name container (containerType); 1234 GLuint elementId = 0; 1235 const GLuint refSeed = m_rnd.getUint32(); 1236 const GLuint newSeed = m_rnd.getUint32(); 1237 ResultCollector errors (getTestContext()); 1238 Surface refSurface; // Surface drawn from attachment to refSeed container 1239 Surface newSurface; // Surface drawn from attachment to newSeed container 1240 Surface delSurface; // Like newSurface, after writing to a deleted attachment 1241 1242 log() << TestLog::Message 1243 << "Testing if writing to a container with a deleted attachment " 1244 << "modifies a newly created object" 1245 << TestLog::EndMessage; 1246 1247 { 1248 ScopedLogSection section (log(), "Write to existing", 1249 "Writing to a container with an existing attachment"); 1250 const Name element (elementType); 1251 1252 elementId = *element; 1253 attacher.initAttachment(0, elementId); 1254 attacher.attach(elementId, *container); 1255 1256 // For reference purposes, make note of what refSeed looks like. 1257 m_outputAttacher.setupContainer(refSeed, *container); 1258 m_outputAttacher.drawAttachment(elementId, refSurface); 1259 } 1260 { 1261 ScopedLogSection section (log(), "Write to deleted", 1262 "Writing to a container after deletion of attachment"); 1263 const GLuint newId = replaceName(elementType, elementId, log()); 1264 const Name newElement (elementType, newId); 1265 1266 log() << TestLog::Message 1267 << "Creating a new object " << newId 1268 << TestLog::EndMessage; 1269 1270 log() << TestLog::Message 1271 << "Recording state of new object before writing to container" 1272 << TestLog::EndMessage; 1273 attacher.initAttachment(newSeed, newId); 1274 m_outputAttacher.drawAttachment(newId, newSurface); 1275 1276 log() << TestLog::Message 1277 << "Writing to container" 1278 << TestLog::EndMessage; 1279 1280 // Now re-write refSeed to the container. 1281 m_outputAttacher.setupContainer(refSeed, *container); 1282 // Does it affect the newly created attachment object? 1283 m_outputAttacher.drawAttachment(newId, delSurface); 1284 } 1285 attacher.detach(elementId, *container); 1286 1287 const bool surfacesMatch = tcu::pixelThresholdCompare( 1288 log(), "Writing to deleted", 1289 "Comparison result from reading from a fresh object before and after " 1290 "writing to a container with a deleted attachment", 1291 newSurface, delSurface, RGBA(0, 0, 0, 0), tcu::COMPARE_LOG_RESULT); 1292 1293 errors.check(surfacesMatch, 1294 "Writing to container with deleted attachment modified a new object."); 1295 1296 if (!surfacesMatch) 1297 log() << TestLog::Image( 1298 "Original attachment", 1299 "Result of container modification on original attachment before deletion.", 1300 refSurface); 1301 return STOP; 1302 }; 1303 1304 struct LifeTestSpec 1305 { 1306 const char* name; 1307 LifeTest::TestFunction func; 1308 bool needBind; 1309 }; 1310 1311 MovePtr<TestCaseGroup> createLifeTestGroup (TestContext& testCtx, 1312 const LifeTestSpec& spec, 1313 const vector<Type*>& types) 1314 { 1315 MovePtr<TestCaseGroup> group(new TestCaseGroup(testCtx, spec.name, spec.name)); 1316 1317 for (vector<Type*>::const_iterator it = types.begin(); it != types.end(); ++it) 1318 { 1319 Type& type = **it; 1320 const char* name = type.getName(); 1321 if (!spec.needBind || type.binder() != DE_NULL) 1322 group->addChild(new LifeTest(name, name, type, spec.func)); 1323 } 1324 1325 return group; 1326 } 1327 1328 static const LifeTestSpec s_lifeTests[] = 1329 { 1330 { "gen", &LifeTest::testGen, false }, 1331 { "delete", &LifeTest::testDelete, false }, 1332 { "bind", &LifeTest::testBind, true }, 1333 { "delete_bound", &LifeTest::testDeleteBound, true }, 1334 { "bind_no_gen", &LifeTest::testBindNoGen, true }, 1335 }; 1336 1337 string attacherName (Attacher& attacher) 1338 { 1339 ostringstream os; 1340 os << attacher.getElementType().getName() << "_" << attacher.getContainerType().getName(); 1341 return os.str(); 1342 } 1343 1344 void addTestCases (TestCaseGroup& group, Types& types) 1345 { 1346 TestContext& testCtx = types.getTestContext(); 1347 1348 for (const LifeTestSpec* it = DE_ARRAY_BEGIN(s_lifeTests); 1349 it != DE_ARRAY_END(s_lifeTests); ++it) 1350 group.addChild(createLifeTestGroup(testCtx, *it, types.getTypes()).release()); 1351 1352 { 1353 TestCaseGroup* const delUsedGroup = 1354 new TestCaseGroup(testCtx, "delete_used", "Delete current program"); 1355 group.addChild(delUsedGroup); 1356 1357 delUsedGroup->addChild( 1358 new LifeTest("program", "program", types.getProgramType(), 1359 &LifeTest::testDeleteUsed)); 1360 } 1361 1362 { 1363 TestCaseGroup* const attGroup = new TestCaseGroup( 1364 testCtx, "attach", "Attachment tests"); 1365 group.addChild(attGroup); 1366 1367 { 1368 TestCaseGroup* const nameGroup = new TestCaseGroup( 1369 testCtx, "deleted_name", "Name of deleted attachment"); 1370 attGroup->addChild(nameGroup); 1371 1372 const vector<Attacher*>& atts = types.getAttachers(); 1373 for (vector<Attacher*>::const_iterator it = atts.begin(); it != atts.end(); ++it) 1374 { 1375 const string name = attacherName(**it); 1376 nameGroup->addChild(new AttachmentTest(name.c_str(), name.c_str(), **it, 1377 &AttachmentTest::testDeletedNames)); 1378 } 1379 } 1380 { 1381 TestCaseGroup* inputGroup = new TestCaseGroup( 1382 testCtx, "deleted_input", "Input from deleted attachment"); 1383 attGroup->addChild(inputGroup); 1384 1385 const vector<InputAttacher*>& inAtts = types.getInputAttachers(); 1386 for (vector<InputAttacher*>::const_iterator it = inAtts.begin(); 1387 it != inAtts.end(); ++it) 1388 { 1389 const string name = attacherName((*it)->getAttacher()); 1390 inputGroup->addChild(new InputAttachmentTest(name.c_str(), name.c_str(), **it)); 1391 } 1392 } 1393 { 1394 TestCaseGroup* outputGroup = new TestCaseGroup( 1395 testCtx, "deleted_output", "Output to deleted attachment"); 1396 attGroup->addChild(outputGroup); 1397 1398 const vector<OutputAttacher*>& outAtts = types.getOutputAttachers(); 1399 for (vector<OutputAttacher*>::const_iterator it = outAtts.begin(); 1400 it != outAtts.end(); ++it) 1401 { 1402 string name = attacherName((*it)->getAttacher()); 1403 outputGroup->addChild(new OutputAttachmentTest(name.c_str(), name.c_str(), 1404 **it)); 1405 } 1406 } 1407 } 1408 } 1409 1410 } // details 1411 } // LifetimeTests 1412 } // gls 1413 } // deqp 1414
