| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL (ES) Module |
| * ----------------------------------------------- |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Common object lifetime tests. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "glsLifetimeTests.hpp" |
| |
| #include "deString.h" |
| #include "deRandom.hpp" |
| #include "deSTLUtil.hpp" |
| #include "deStringUtil.hpp" |
| #include "tcuRGBA.hpp" |
| #include "tcuImageCompare.hpp" |
| #include "tcuRenderTarget.hpp" |
| #include "tcuStringTemplate.hpp" |
| #include "tcuTestLog.hpp" |
| #include "gluDrawUtil.hpp" |
| #include "gluObjectWrapper.hpp" |
| #include "gluPixelTransfer.hpp" |
| #include "gluShaderProgram.hpp" |
| #include "gluDefs.hpp" |
| #include "gluTextureUtil.hpp" |
| #include "gluStrUtil.hpp" |
| #include "glwFunctions.hpp" |
| |
| #include <vector> |
| #include <map> |
| #include <algorithm> |
| #include <sstream> |
| |
| namespace deqp |
| { |
| namespace gls |
| { |
| namespace LifetimeTests |
| { |
| namespace details |
| { |
| |
| using std::map; |
| using std::string; |
| using std::ostringstream; |
| using de::Random; |
| using tcu::RenderTarget; |
| using tcu::RGBA; |
| using tcu::StringTemplate; |
| using tcu::TestCase; |
| typedef TestCase::IterateResult IterateResult; |
| using tcu::TestLog; |
| using tcu::ScopedLogSection; |
| using glu::Program; |
| using glu::Shader; |
| using glu::Framebuffer; |
| using glu::SHADERTYPE_VERTEX; |
| using glu::SHADERTYPE_FRAGMENT; |
| using namespace glw; |
| |
| enum { VIEWPORT_SIZE = 128, FRAMEBUFFER_SIZE = 128 }; |
| |
| GLint getInteger (ContextWrapper& gl, GLenum queryParam) |
| { |
| GLint ret = 0; |
| GLU_CHECK_CALL_ERROR( |
| gl.glGetIntegerv(queryParam, &ret), |
| gl.glGetError()); |
| gl.log() << TestLog::Message << "// Single integer output: " << ret << TestLog::EndMessage; |
| return ret; |
| } |
| |
| #define GLSL100_SRC(BODY) ("#version 100\n" #BODY "\n") |
| |
| static const char* const s_vertexShaderSrc = GLSL100_SRC( |
| attribute vec2 pos; |
| void main() |
| { |
| gl_Position = vec4(pos.xy, 0.0, 1.0); |
| } |
| ); |
| |
| static const char* const s_fragmentShaderSrc = GLSL100_SRC( |
| void main() |
| { |
| gl_FragColor = vec4(1.0); |
| } |
| ); |
| |
| class CheckedShader : public Shader |
| { |
| public: |
| CheckedShader (const RenderContext& renderCtx, glu::ShaderType type, const string& src) |
| : Shader (renderCtx, type) |
| { |
| const char* const srcStr = src.c_str(); |
| setSources(1, &srcStr, DE_NULL); |
| compile(); |
| TCU_CHECK(getCompileStatus()); |
| } |
| }; |
| |
| class CheckedProgram : public Program |
| { |
| public: |
| CheckedProgram (const RenderContext& renderCtx, GLuint vtxShader, GLuint fragShader) |
| : Program (renderCtx) |
| { |
| attachShader(vtxShader); |
| attachShader(fragShader); |
| link(); |
| TCU_CHECK(getLinkStatus()); |
| } |
| }; |
| |
| ContextWrapper::ContextWrapper (const Context& ctx) |
| : CallLogWrapper (ctx.gl(), ctx.log()) |
| , m_ctx (ctx) |
| { |
| enableLogging(true); |
| } |
| |
| void SimpleBinder::bind (GLuint name) |
| { |
| (this->*m_bindFunc)(m_bindTarget, name); |
| } |
| |
| GLuint SimpleBinder::getBinding (void) |
| { |
| return getInteger(*this, m_bindingParam); |
| } |
| |
| GLuint SimpleType::gen (void) |
| { |
| GLuint ret; |
| (this->*m_genFunc)(1, &ret); |
| return ret; |
| } |
| |
| class VertexArrayBinder : public SimpleBinder |
| { |
| public: |
| VertexArrayBinder (Context& ctx) |
| : SimpleBinder (ctx, 0, GL_NONE, GL_VERTEX_ARRAY_BINDING, true) {} |
| void bind (GLuint name) { glBindVertexArray(name); } |
| }; |
| |
| class QueryBinder : public Binder |
| { |
| public: |
| QueryBinder (Context& ctx) : Binder(ctx) {} |
| void bind (GLuint name) |
| { |
| if (name != 0) |
| glBeginQuery(GL_ANY_SAMPLES_PASSED, name); |
| else |
| glEndQuery(GL_ANY_SAMPLES_PASSED); |
| } |
| GLuint getBinding (void) { return 0; } |
| }; |
| |
| bool ProgramType::isDeleteFlagged (GLuint name) |
| { |
| GLint deleteFlagged = 0; |
| glGetProgramiv(name, GL_DELETE_STATUS, &deleteFlagged); |
| return deleteFlagged != 0; |
| } |
| |
| bool ShaderType::isDeleteFlagged (GLuint name) |
| { |
| GLint deleteFlagged = 0; |
| glGetShaderiv(name, GL_DELETE_STATUS, &deleteFlagged); |
| return deleteFlagged != 0; |
| } |
| |
| void setupFbo (const Context& ctx, GLuint seed, GLuint fbo) |
| { |
| const Functions& gl = ctx.getRenderContext().getFunctions(); |
| |
| GLU_CHECK_CALL_ERROR(gl.bindFramebuffer(GL_FRAMEBUFFER, fbo), |
| gl.getError()); |
| |
| if (seed == 0) |
| { |
| gl.clearColor(0.0, 0.0, 0.0, 1.0); |
| GLU_CHECK_CALL_ERROR(gl.clear(GL_COLOR_BUFFER_BIT), gl.getError()); |
| } |
| else |
| { |
| Random rnd (seed); |
| const GLsizei width = rnd.getInt(0, FRAMEBUFFER_SIZE); |
| const GLsizei height = rnd.getInt(0, FRAMEBUFFER_SIZE); |
| const GLint x = rnd.getInt(0, FRAMEBUFFER_SIZE - width); |
| const GLint y = rnd.getInt(0, FRAMEBUFFER_SIZE - height); |
| const GLfloat r1 = rnd.getFloat(); |
| const GLfloat g1 = rnd.getFloat(); |
| const GLfloat b1 = rnd.getFloat(); |
| const GLfloat a1 = rnd.getFloat(); |
| const GLfloat r2 = rnd.getFloat(); |
| const GLfloat g2 = rnd.getFloat(); |
| const GLfloat b2 = rnd.getFloat(); |
| const GLfloat a2 = rnd.getFloat(); |
| |
| GLU_CHECK_CALL_ERROR(gl.clearColor(r1, g1, b1, a1), gl.getError()); |
| GLU_CHECK_CALL_ERROR(gl.clear(GL_COLOR_BUFFER_BIT), gl.getError()); |
| gl.scissor(x, y, width, height); |
| gl.enable(GL_SCISSOR_TEST); |
| gl.clearColor(r2, g2, b2, a2); |
| gl.clear(GL_COLOR_BUFFER_BIT); |
| gl.disable(GL_SCISSOR_TEST); |
| } |
| |
| gl.bindFramebuffer(GL_FRAMEBUFFER, 0); |
| GLU_CHECK_ERROR(gl.getError()); |
| } |
| |
| void drawFbo (const Context& ctx, GLuint fbo, Surface& dst) |
| { |
| const RenderContext& renderCtx = ctx.getRenderContext(); |
| const Functions& gl = renderCtx.getFunctions(); |
| |
| GLU_CHECK_CALL_ERROR( |
| gl.bindFramebuffer(GL_FRAMEBUFFER, fbo), |
| gl.getError()); |
| |
| dst.setSize(FRAMEBUFFER_SIZE, FRAMEBUFFER_SIZE); |
| glu::readPixels(renderCtx, 0, 0, dst.getAccess()); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Read pixels from framebuffer"); |
| |
| GLU_CHECK_CALL_ERROR( |
| gl.bindFramebuffer(GL_FRAMEBUFFER, 0), |
| gl.getError()); |
| } |
| |
| GLuint getFboAttachment (const Functions& gl, GLuint fbo, GLenum requiredType) |
| { |
| GLint type = 0, name = 0; |
| gl.bindFramebuffer(GL_FRAMEBUFFER, fbo); |
| GLU_CHECK_CALL_ERROR( |
| gl.getFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, |
| GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, |
| &type), |
| gl.getError()); |
| |
| if (GLenum(type) != requiredType || GLenum(type) == GL_NONE) |
| return 0; |
| |
| GLU_CHECK_CALL_ERROR( |
| gl.getFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, |
| GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, |
| &name), |
| gl.getError()); |
| gl.bindFramebuffer(GL_FRAMEBUFFER, 0); |
| GLU_CHECK_ERROR(gl.getError()); |
| |
| return name; |
| } |
| |
| void FboAttacher::initAttachment (GLuint seed, GLuint element) |
| { |
| Binder& binder = *getElementType().binder(); |
| Framebuffer fbo(getRenderContext()); |
| |
| enableLogging(false); |
| |
| binder.enableLogging(false); |
| binder.bind(element); |
| initStorage(); |
| binder.bind(0); |
| binder.enableLogging(true); |
| |
| attach(element, *fbo); |
| setupFbo(getContext(), seed, *fbo); |
| detach(element, *fbo); |
| |
| enableLogging(true); |
| |
| log() << TestLog::Message |
| << "// Drew to " << getElementType().getName() << " " << element |
| << " with seed " << seed << "." |
| << TestLog::EndMessage; |
| } |
| |
| void FboInputAttacher::drawContainer (GLuint fbo, Surface& dst) |
| { |
| drawFbo(getContext(), fbo, dst); |
| log() << TestLog::Message |
| << "// Read pixels from framebuffer " << fbo << " to output image." |
| << TestLog::EndMessage; |
| } |
| |
| void FboOutputAttacher::setupContainer (GLuint seed, GLuint fbo) |
| { |
| setupFbo(getContext(), seed, fbo); |
| log() << TestLog::Message |
| << "// Drew to framebuffer " << fbo << " with seed " << seed << "." |
| << TestLog::EndMessage; |
| } |
| |
| void FboOutputAttacher::drawAttachment (GLuint element, Surface& dst) |
| { |
| Framebuffer fbo(getRenderContext()); |
| m_attacher.enableLogging(false); |
| m_attacher.attach(element, *fbo); |
| drawFbo(getContext(), *fbo, dst); |
| m_attacher.detach(element, *fbo); |
| m_attacher.enableLogging(true); |
| log() << TestLog::Message |
| << "// Read pixels from " << m_attacher.getElementType().getName() << " " << element |
| << " to output image." |
| << TestLog::EndMessage; |
| GLU_CHECK_ERROR(gl().getError()); |
| } |
| |
| void TextureFboAttacher::attach (GLuint texture, GLuint fbo) |
| { |
| GLU_CHECK_CALL_ERROR( |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo), |
| gl().getError()); |
| GLU_CHECK_CALL_ERROR( |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, |
| GL_TEXTURE_2D, texture, 0), |
| gl().getError()); |
| GLU_CHECK_CALL_ERROR( |
| glBindFramebuffer(GL_FRAMEBUFFER, 0), |
| gl().getError()); |
| } |
| |
| void TextureFboAttacher::detach (GLuint texture, GLuint fbo) |
| { |
| DE_UNREF(texture); |
| GLU_CHECK_CALL_ERROR( |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo), |
| gl().getError()); |
| GLU_CHECK_CALL_ERROR( |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0), |
| gl().getError()); |
| GLU_CHECK_CALL_ERROR( |
| glBindFramebuffer(GL_FRAMEBUFFER, 0), |
| gl().getError()); |
| } |
| |
| GLuint TextureFboAttacher::getAttachment (GLuint fbo) |
| { |
| return getFboAttachment(gl(), fbo, GL_TEXTURE); |
| } |
| |
| static bool isTextureFormatColorRenderable (const glu::RenderContext& renderCtx, const glu::TransferFormat& format) |
| { |
| const glw::Functions& gl = renderCtx.getFunctions(); |
| deUint32 curFbo = ~0u; |
| deUint32 curTex = ~0u; |
| deUint32 testFbo = 0u; |
| deUint32 testTex = 0u; |
| GLenum status = GL_NONE; |
| |
| GLU_CHECK_GLW_CALL(gl, getIntegerv(GL_FRAMEBUFFER_BINDING, (deInt32*)&curFbo)); |
| GLU_CHECK_GLW_CALL(gl, getIntegerv(GL_TEXTURE_BINDING_2D, (deInt32*)&curTex)); |
| |
| try |
| { |
| GLU_CHECK_GLW_CALL(gl, genTextures(1, &testTex)); |
| GLU_CHECK_GLW_CALL(gl, bindTexture(GL_TEXTURE_2D, testTex)); |
| GLU_CHECK_GLW_CALL(gl, texImage2D(GL_TEXTURE_2D, 0, format.format, FRAMEBUFFER_SIZE, FRAMEBUFFER_SIZE, 0, |
| format.format, format.dataType, DE_NULL)); |
| |
| GLU_CHECK_GLW_CALL(gl, genFramebuffers(1, &testFbo)); |
| GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, testFbo)); |
| GLU_CHECK_GLW_CALL(gl, framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, testTex, 0)); |
| |
| status = gl.checkFramebufferStatus(GL_FRAMEBUFFER); |
| GLU_CHECK_GLW_MSG(gl, "glCheckFramebufferStatus(GL_FRAMEBUFFER)"); |
| |
| GLU_CHECK_GLW_CALL(gl, bindTexture(GL_TEXTURE_2D, curTex)); |
| GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, curFbo)); |
| |
| GLU_CHECK_GLW_CALL(gl, deleteTextures(1, &testTex)); |
| GLU_CHECK_GLW_CALL(gl, deleteFramebuffers(1, &testFbo)); |
| } |
| catch (...) |
| { |
| if (testTex != 0) |
| gl.deleteTextures(1, &testTex); |
| |
| if (testFbo != 0) |
| gl.deleteFramebuffers(1, &testFbo); |
| |
| throw; |
| } |
| |
| if (status == GL_FRAMEBUFFER_COMPLETE) |
| return true; |
| else if (status == GL_FRAMEBUFFER_UNSUPPORTED) |
| return false; |
| else |
| TCU_THROW(TestError, (std::string("glCheckFramebufferStatus() returned invalid result code ") |
| + de::toString(glu::getFramebufferStatusStr(status))).c_str()); |
| } |
| |
| static glu::TransferFormat getRenderableColorTextureFormat (const glu::RenderContext& renderCtx) |
| { |
| if (glu::contextSupports(renderCtx.getType(), glu::ApiType::es(3,0))) |
| return glu::TransferFormat(GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4); |
| |
| { |
| const glu::TransferFormat candidates[] = |
| { |
| glu::TransferFormat(GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4), |
| glu::TransferFormat(GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1), |
| glu::TransferFormat(GL_RGB, GL_UNSIGNED_SHORT_5_6_5), |
| glu::TransferFormat(GL_RGBA, GL_UNSIGNED_BYTE), |
| }; |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(candidates); ++ndx) |
| { |
| if (isTextureFormatColorRenderable(renderCtx, candidates[ndx])) |
| return candidates[ndx]; |
| } |
| } |
| |
| return glu::TransferFormat(GL_NONE, GL_NONE); |
| } |
| |
| void TextureFboAttacher::initStorage (void) |
| { |
| const glu::TransferFormat format = getRenderableColorTextureFormat(getRenderContext()); |
| |
| if (format.format == GL_NONE) |
| TCU_THROW(NotSupportedError, "No renderable texture format found"); |
| |
| GLU_CHECK_CALL_ERROR( |
| glTexImage2D(GL_TEXTURE_2D, 0, format.format, FRAMEBUFFER_SIZE, FRAMEBUFFER_SIZE, 0, |
| format.format, format.dataType, DE_NULL), |
| gl().getError()); |
| } |
| |
| static bool isRenderbufferFormatColorRenderable (const glu::RenderContext& renderCtx, const deUint32 format) |
| { |
| const glw::Functions& gl = renderCtx.getFunctions(); |
| deUint32 curFbo = ~0u; |
| deUint32 curRbo = ~0u; |
| deUint32 testFbo = 0u; |
| deUint32 testRbo = 0u; |
| GLenum status = GL_NONE; |
| |
| GLU_CHECK_GLW_CALL(gl, getIntegerv(GL_FRAMEBUFFER_BINDING, (deInt32*)&curFbo)); |
| GLU_CHECK_GLW_CALL(gl, getIntegerv(GL_RENDERBUFFER_BINDING, (deInt32*)&curRbo)); |
| |
| try |
| { |
| GLU_CHECK_GLW_CALL(gl, genRenderbuffers(1, &testRbo)); |
| GLU_CHECK_GLW_CALL(gl, bindRenderbuffer(GL_RENDERBUFFER, testRbo)); |
| GLU_CHECK_GLW_CALL(gl, renderbufferStorage(GL_RENDERBUFFER, format, FRAMEBUFFER_SIZE, FRAMEBUFFER_SIZE)); |
| |
| GLU_CHECK_GLW_CALL(gl, genFramebuffers(1, &testFbo)); |
| GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, testFbo)); |
| GLU_CHECK_GLW_CALL(gl, framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, testRbo)); |
| |
| status = gl.checkFramebufferStatus(GL_FRAMEBUFFER); |
| GLU_CHECK_GLW_MSG(gl, "glCheckFramebufferStatus(GL_FRAMEBUFFER)"); |
| |
| GLU_CHECK_GLW_CALL(gl, bindRenderbuffer(GL_RENDERBUFFER, curRbo)); |
| GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, curFbo)); |
| |
| GLU_CHECK_GLW_CALL(gl, deleteRenderbuffers(1, &testRbo)); |
| GLU_CHECK_GLW_CALL(gl, deleteFramebuffers(1, &testFbo)); |
| } |
| catch (...) |
| { |
| if (testRbo != 0) |
| gl.deleteRenderbuffers(1, &testRbo); |
| |
| if (testFbo != 0) |
| gl.deleteFramebuffers(1, &testFbo); |
| |
| throw; |
| } |
| |
| if (status == GL_FRAMEBUFFER_COMPLETE) |
| return true; |
| else if (status == GL_FRAMEBUFFER_UNSUPPORTED) |
| return false; |
| else |
| TCU_THROW(TestError, (std::string("glCheckFramebufferStatus() returned invalid result code ") |
| + de::toString(glu::getFramebufferStatusStr(status))).c_str()); |
| } |
| |
| static deUint32 getRenderableColorRenderbufferFormat (const glu::RenderContext& renderCtx) |
| { |
| if (glu::contextSupports(renderCtx.getType(), glu::ApiType::es(3,0))) |
| return GL_RGBA4; |
| |
| { |
| const deUint32 candidates[] = |
| { |
| GL_RGBA4, |
| GL_RGB5_A1, |
| GL_RGB565, |
| }; |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(candidates); ++ndx) |
| { |
| if (isRenderbufferFormatColorRenderable(renderCtx, candidates[ndx])) |
| return candidates[ndx]; |
| } |
| } |
| |
| return GL_NONE; |
| } |
| |
| void RboFboAttacher::initStorage (void) |
| { |
| const deUint32 format = getRenderableColorRenderbufferFormat(getRenderContext()); |
| |
| if (format == GL_NONE) |
| TCU_THROW(TestError, "No color-renderable renderbuffer format found"); |
| |
| GLU_CHECK_CALL_ERROR( |
| glRenderbufferStorage(GL_RENDERBUFFER, format, FRAMEBUFFER_SIZE, FRAMEBUFFER_SIZE), |
| gl().getError()); |
| } |
| |
| void RboFboAttacher::attach (GLuint rbo, GLuint fbo) |
| { |
| GLU_CHECK_CALL_ERROR( |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo), |
| gl().getError()); |
| GLU_CHECK_CALL_ERROR( |
| glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo), |
| gl().getError()); |
| GLU_CHECK_CALL_ERROR( |
| glBindFramebuffer(GL_FRAMEBUFFER, 0), |
| gl().getError()); |
| } |
| |
| void RboFboAttacher::detach (GLuint rbo, GLuint fbo) |
| { |
| DE_UNREF(rbo); |
| GLU_CHECK_CALL_ERROR( |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo), |
| gl().getError()); |
| GLU_CHECK_CALL_ERROR( |
| glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, 0), |
| gl().getError()); |
| GLU_CHECK_CALL_ERROR( |
| glBindFramebuffer(GL_FRAMEBUFFER, 0), |
| gl().getError()); |
| } |
| |
| GLuint RboFboAttacher::getAttachment (GLuint fbo) |
| { |
| return getFboAttachment(gl(), fbo, GL_RENDERBUFFER); |
| } |
| |
| static const char* const s_fragmentShaderTemplate = GLSL100_SRC( |
| void main() |
| { |
| gl_FragColor = vec4(${RED}, ${GREEN}, ${BLUE}, 1.0); |
| } |
| ); |
| |
| void ShaderProgramAttacher::initAttachment (GLuint seed, GLuint shader) |
| { |
| using de::insert; |
| using de::floatToString; |
| |
| Random rnd(seed); |
| map<string, string> params; |
| const StringTemplate sourceTmpl (s_fragmentShaderTemplate); |
| |
| insert(params, "RED", floatToString(rnd.getFloat(), 4)); |
| insert(params, "GREEN", floatToString(rnd.getFloat(), 4)); |
| insert(params, "BLUE", floatToString(rnd.getFloat(), 4)); |
| |
| { |
| const string source = sourceTmpl.specialize(params); |
| const char* const sourceStr = source.c_str(); |
| |
| GLU_CHECK_CALL_ERROR(glShaderSource(shader, 1, &sourceStr, DE_NULL), gl().getError()); |
| GLU_CHECK_CALL_ERROR(glCompileShader(shader), gl().getError()); |
| |
| { |
| GLint compileStatus = 0; |
| gl().getShaderiv(shader, GL_COMPILE_STATUS, &compileStatus); |
| TCU_CHECK_MSG(compileStatus != 0, sourceStr); |
| } |
| } |
| } |
| |
| void ShaderProgramAttacher::attach (GLuint shader, GLuint program) |
| { |
| GLU_CHECK_CALL_ERROR( |
| glAttachShader(program, shader), |
| gl().getError()); |
| } |
| |
| void ShaderProgramAttacher::detach (GLuint shader, GLuint program) |
| { |
| GLU_CHECK_CALL_ERROR( |
| glDetachShader(program, shader), |
| gl().getError()); |
| } |
| |
| GLuint ShaderProgramAttacher::getAttachment (GLuint program) |
| { |
| GLuint shaders[2] = { 0, 0 }; |
| const GLsizei shadersLen = DE_LENGTH_OF_ARRAY(shaders); |
| GLsizei numShaders = 0; |
| GLuint ret = 0; |
| |
| gl().getAttachedShaders(program, shadersLen, &numShaders, shaders); |
| |
| // There should ever be at most one attached shader in normal use, but if |
| // something is wrong, the temporary vertex shader might not have been |
| // detached properly, so let's find the fragment shader explicitly. |
| for (int ndx = 0; ndx < de::min<GLsizei>(shadersLen, numShaders); ++ndx) |
| { |
| GLint shaderType = GL_NONE; |
| gl().getShaderiv(shaders[ndx], GL_SHADER_TYPE, &shaderType); |
| |
| if (shaderType == GL_FRAGMENT_SHADER) |
| { |
| ret = shaders[ndx]; |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| void setViewport (const RenderContext& renderCtx, const Rectangle& rect) |
| { |
| renderCtx.getFunctions().viewport(rect.x, rect.y, rect.width, rect.height); |
| } |
| |
| void readRectangle (const RenderContext& renderCtx, const Rectangle& rect, Surface& dst) |
| { |
| dst.setSize(rect.width, rect.height); |
| glu::readPixels(renderCtx, rect.x, rect.y, dst.getAccess()); |
| } |
| |
| Rectangle randomViewport (const RenderContext& ctx, GLint maxWidth, GLint maxHeight, |
| Random& rnd) |
| { |
| const RenderTarget& target = ctx.getRenderTarget(); |
| const GLint width = de::min(target.getWidth(), maxWidth); |
| const GLint xOff = rnd.getInt(0, target.getWidth() - width); |
| const GLint height = de::min(target.getHeight(), maxHeight); |
| const GLint yOff = rnd.getInt(0, target.getHeight() - height); |
| |
| return Rectangle(xOff, yOff, width, height); |
| } |
| |
| void ShaderProgramInputAttacher::drawContainer (GLuint program, Surface& dst) |
| { |
| static const float s_vertices[6] = { -1.0, 0.0, 1.0, 1.0, 0.0, -1.0 }; |
| Random rnd (program); |
| CheckedShader vtxShader (getRenderContext(), |
| SHADERTYPE_VERTEX, s_vertexShaderSrc); |
| const Rectangle viewport = randomViewport(getRenderContext(), |
| VIEWPORT_SIZE, VIEWPORT_SIZE, rnd); |
| |
| gl().attachShader(program, vtxShader.getShader()); |
| gl().linkProgram(program); |
| |
| { |
| GLint linkStatus = 0; |
| gl().getProgramiv(program, GL_LINK_STATUS, &linkStatus); |
| TCU_CHECK(linkStatus != 0); |
| } |
| |
| log() << TestLog::Message |
| << "// Attached a temporary vertex shader and linked program " << program |
| << TestLog::EndMessage; |
| |
| setViewport(getRenderContext(), viewport); |
| log() << TestLog::Message << "// Positioned viewport randomly" << TestLog::EndMessage; |
| |
| glUseProgram(program); |
| { |
| GLint posLoc = gl().getAttribLocation(program, "pos"); |
| TCU_CHECK(posLoc >= 0); |
| |
| gl().enableVertexAttribArray(posLoc); |
| |
| gl().clearColor(0, 0, 0, 1); |
| gl().clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); |
| gl().vertexAttribPointer(posLoc, 2, GL_FLOAT, GL_FALSE, 0, s_vertices); |
| gl().drawArrays(GL_TRIANGLES, 0, 3); |
| |
| gl().disableVertexAttribArray(posLoc); |
| log () << TestLog::Message << "// Drew a fixed triangle" << TestLog::EndMessage; |
| } |
| glUseProgram(0); |
| |
| readRectangle(getRenderContext(), viewport, dst); |
| log() << TestLog::Message << "// Copied viewport to output image" << TestLog::EndMessage; |
| |
| gl().detachShader(program, vtxShader.getShader()); |
| log() << TestLog::Message << "// Removed temporary vertex shader" << TestLog::EndMessage; |
| } |
| |
| ES2Types::ES2Types (const Context& ctx) |
| : Types (ctx) |
| , m_bufferBind (ctx, &CallLogWrapper::glBindBuffer, |
| GL_ARRAY_BUFFER, GL_ARRAY_BUFFER_BINDING) |
| , m_bufferType (ctx, "buffer", &CallLogWrapper::glGenBuffers, |
| &CallLogWrapper::glDeleteBuffers, |
| &CallLogWrapper::glIsBuffer, &m_bufferBind) |
| , m_textureBind (ctx, &CallLogWrapper::glBindTexture, GL_TEXTURE_2D, GL_TEXTURE_BINDING_2D) |
| , m_textureType (ctx, "texture", &CallLogWrapper::glGenTextures, |
| &CallLogWrapper::glDeleteTextures, |
| &CallLogWrapper::glIsTexture, &m_textureBind) |
| , m_rboBind (ctx, &CallLogWrapper::glBindRenderbuffer, |
| GL_RENDERBUFFER, GL_RENDERBUFFER_BINDING) |
| , m_rboType (ctx, "renderbuffer", |
| &CallLogWrapper::glGenRenderbuffers, |
| &CallLogWrapper::glDeleteRenderbuffers, |
| &CallLogWrapper::glIsRenderbuffer, &m_rboBind) |
| , m_fboBind (ctx, &CallLogWrapper::glBindFramebuffer, |
| GL_FRAMEBUFFER, GL_FRAMEBUFFER_BINDING) |
| , m_fboType (ctx, "framebuffer", |
| &CallLogWrapper::glGenFramebuffers, |
| &CallLogWrapper::glDeleteFramebuffers, |
| &CallLogWrapper::glIsFramebuffer, &m_fboBind) |
| , m_shaderType (ctx) |
| , m_programType (ctx) |
| , m_texFboAtt (ctx, m_textureType, m_fboType) |
| , m_texFboInAtt (m_texFboAtt) |
| , m_texFboOutAtt(m_texFboAtt) |
| , m_rboFboAtt (ctx, m_rboType, m_fboType) |
| , m_rboFboInAtt (m_rboFboAtt) |
| , m_rboFboOutAtt(m_rboFboAtt) |
| , m_shaderAtt (ctx, m_shaderType, m_programType) |
| , m_shaderInAtt (m_shaderAtt) |
| { |
| Type* const types[] = |
| { |
| &m_bufferType, &m_textureType, &m_rboType, &m_fboType, &m_shaderType, &m_programType |
| }; |
| m_types.insert(m_types.end(), DE_ARRAY_BEGIN(types), DE_ARRAY_END(types)); |
| |
| m_attachers.push_back(&m_texFboAtt); |
| m_attachers.push_back(&m_rboFboAtt); |
| m_attachers.push_back(&m_shaderAtt); |
| |
| m_inAttachers.push_back(&m_texFboInAtt); |
| m_inAttachers.push_back(&m_rboFboInAtt); |
| m_inAttachers.push_back(&m_shaderInAtt); |
| |
| m_outAttachers.push_back(&m_texFboOutAtt); |
| m_outAttachers.push_back(&m_rboFboOutAtt); |
| } |
| |
| class Name |
| { |
| public: |
| Name (Type& type) : m_type(type), m_name(type.gen()) {} |
| Name (Type& type, GLuint name) : m_type(type), m_name(name) {} |
| ~Name (void) { m_type.release(m_name); } |
| GLuint operator* (void) const { return m_name; } |
| |
| private: |
| Type& m_type; |
| const GLuint m_name; |
| }; |
| |
| class ResultCollector |
| { |
| public: |
| ResultCollector (TestContext& testCtx); |
| bool check (bool cond, const char* msg); |
| void fail (const char* msg); |
| void warn (const char* msg); |
| ~ResultCollector (void); |
| |
| private: |
| void addResult (qpTestResult result, const char* msg); |
| |
| TestContext& m_testCtx; |
| TestLog& m_log; |
| qpTestResult m_result; |
| const char* m_message; |
| }; |
| |
| ResultCollector::ResultCollector (TestContext& testCtx) |
| : m_testCtx (testCtx) |
| , m_log (testCtx.getLog()) |
| , m_result (QP_TEST_RESULT_PASS) |
| , m_message ("Pass") |
| { |
| } |
| |
| bool ResultCollector::check (bool cond, const char* msg) |
| { |
| if (!cond) |
| fail(msg); |
| return cond; |
| } |
| |
| void ResultCollector::addResult (qpTestResult result, const char* msg) |
| { |
| m_log << TestLog::Message << "// Fail: " << msg << TestLog::EndMessage; |
| if (m_result == QP_TEST_RESULT_PASS) |
| { |
| m_result = result; |
| m_message = msg; |
| } |
| else |
| { |
| if (result == QP_TEST_RESULT_FAIL) |
| m_result = result; |
| m_message = "Multiple problems, see log for details"; |
| } |
| } |
| |
| void ResultCollector::fail (const char* msg) |
| { |
| addResult(QP_TEST_RESULT_FAIL, msg); |
| } |
| |
| void ResultCollector::warn (const char* msg) |
| { |
| addResult(QP_TEST_RESULT_QUALITY_WARNING, msg); |
| } |
| |
| ResultCollector::~ResultCollector (void) |
| { |
| m_testCtx.setTestResult(m_result, m_message); |
| } |
| |
| class TestBase : public TestCase, protected CallLogWrapper |
| { |
| protected: |
| TestBase (const char* name, |
| const char* description, |
| const Context& ctx); |
| |
| // Copy ContextWrapper since MI (except for CallLogWrapper) is a no-no. |
| const Context& getContext (void) const { return m_ctx; } |
| const RenderContext& getRenderContext (void) const { return m_ctx.getRenderContext(); } |
| const Functions& gl (void) const { return m_ctx.gl(); } |
| TestLog& log (void) const { return m_ctx.log(); } |
| void init (void); |
| |
| Context m_ctx; |
| Random m_rnd; |
| }; |
| |
| TestBase::TestBase (const char* name, const char* description, const Context& ctx) |
| : TestCase (ctx.getTestContext(), name, description) |
| , CallLogWrapper (ctx.gl(), ctx.log()) |
| , m_ctx (ctx) |
| , m_rnd (deStringHash(name)) |
| { |
| enableLogging(true); |
| } |
| |
| void TestBase::init (void) |
| { |
| m_rnd = Random(deStringHash(getName())); |
| } |
| |
| class LifeTest : public TestBase |
| { |
| public: |
| typedef void (LifeTest::*TestFunction) (void); |
| |
| LifeTest (const char* name, |
| const char* description, |
| Type& type, |
| TestFunction test) |
| : TestBase (name, description, type.getContext()) |
| , m_type (type) |
| , m_test (test) {} |
| |
| IterateResult iterate (void); |
| |
| void testGen (void); |
| void testDelete (void); |
| void testBind (void); |
| void testDeleteBound (void); |
| void testBindNoGen (void); |
| void testDeleteUsed (void); |
| |
| private: |
| Binder& binder (void) { return *m_type.binder(); } |
| |
| Type& m_type; |
| TestFunction m_test; |
| }; |
| |
| IterateResult LifeTest::iterate (void) |
| { |
| (this->*m_test)(); |
| return STOP; |
| } |
| |
| void LifeTest::testGen (void) |
| { |
| ResultCollector errors (getTestContext()); |
| Name name (m_type); |
| |
| if (m_type.genCreates()) |
| errors.check(m_type.exists(*name), "Gen* should have created an object, but didn't"); |
| else |
| errors.check(!m_type.exists(*name), "Gen* should not have created an object, but did"); |
| } |
| |
| void LifeTest::testDelete (void) |
| { |
| ResultCollector errors (getTestContext()); |
| GLuint name = m_type.gen(); |
| |
| m_type.release(name); |
| errors.check(!m_type.exists(name), "Object still exists after deletion"); |
| } |
| |
| void LifeTest::testBind (void) |
| { |
| ResultCollector errors (getTestContext()); |
| Name name (m_type); |
| |
| binder().bind(*name); |
| GLU_EXPECT_NO_ERROR(gl().getError(), "Bind failed"); |
| errors.check(m_type.exists(*name), "Object does not exist after binding"); |
| binder().bind(0); |
| } |
| |
| void LifeTest::testDeleteBound (void) |
| { |
| const GLuint id = m_type.gen(); |
| ResultCollector errors (getTestContext()); |
| |
| binder().bind(id); |
| m_type.release(id); |
| |
| if (m_type.nameLingers()) |
| { |
| errors.check(gl().getError() == GL_NO_ERROR, "Deleting bound object failed"); |
| errors.check(binder().getBinding() == id, |
| "Deleting bound object did not retain binding"); |
| errors.check(m_type.exists(id), |
| "Deleting bound object made its name invalid"); |
| errors.check(m_type.isDeleteFlagged(id), |
| "Deleting bound object did not flag the object for deletion"); |
| binder().bind(0); |
| } |
| else |
| { |
| errors.check(gl().getError() == GL_NO_ERROR, "Deleting bound object failed"); |
| errors.check(binder().getBinding() == 0, |
| "Deleting bound object did not remove binding"); |
| errors.check(!m_type.exists(id), |
| "Deleting bound object did not make its name invalid"); |
| binder().bind(0); |
| } |
| |
| errors.check(binder().getBinding() == 0, "Unbinding didn't remove binding"); |
| errors.check(!m_type.exists(id), "Name is still valid after deleting and unbinding"); |
| } |
| |
| void LifeTest::testBindNoGen (void) |
| { |
| ResultCollector errors (getTestContext()); |
| const GLuint id = m_rnd.getUint32(); |
| |
| if (!errors.check(!m_type.exists(id), "Randomly chosen identifier already exists")) |
| return; |
| |
| Name name (m_type, id); |
| binder().bind(*name); |
| |
| if (binder().genRequired()) |
| { |
| errors.check(glGetError() == GL_INVALID_OPERATION, |
| "Did not fail when binding a name not generated by Gen* call"); |
| errors.check(!m_type.exists(*name), |
| "Bind* created an object for a name not generated by a Gen* call"); |
| } |
| else |
| { |
| errors.check(glGetError() == GL_NO_ERROR, |
| "Failed when binding a name not generated by Gen* call"); |
| errors.check(m_type.exists(*name), |
| "Object was not created by the Bind* call"); |
| } |
| } |
| |
| void LifeTest::testDeleteUsed (void) |
| { |
| ResultCollector errors(getTestContext()); |
| GLuint programId = 0; |
| |
| { |
| CheckedShader vtxShader (getRenderContext(), |
| SHADERTYPE_VERTEX, s_vertexShaderSrc); |
| CheckedShader fragShader (getRenderContext(), |
| SHADERTYPE_FRAGMENT, s_fragmentShaderSrc); |
| CheckedProgram program (getRenderContext(), |
| vtxShader.getShader(), fragShader.getShader()); |
| |
| programId = program.getProgram(); |
| |
| log() << TestLog::Message << "// Created and linked program " << programId |
| << TestLog::EndMessage; |
| GLU_CHECK_CALL_ERROR(glUseProgram(programId), gl().getError()); |
| |
| log() << TestLog::Message << "// Deleted program " << programId |
| << TestLog::EndMessage; |
| } |
| TCU_CHECK(glIsProgram(programId)); |
| { |
| GLint deleteFlagged = 0; |
| glGetProgramiv(programId, GL_DELETE_STATUS, &deleteFlagged); |
| errors.check(deleteFlagged != 0, "Program object was not flagged as deleted"); |
| } |
| GLU_CHECK_CALL_ERROR(glUseProgram(0), gl().getError()); |
| errors.check(!gl().isProgram(programId), |
| "Deleted program name still valid after being made non-current"); |
| } |
| |
| class AttachmentTest : public TestBase |
| { |
| public: |
| typedef void (AttachmentTest::*TestFunction) (void); |
| AttachmentTest (const char* name, |
| const char* description, |
| Attacher& attacher, |
| TestFunction test) |
| : TestBase (name, description, attacher.getContext()) |
| , m_attacher (attacher) |
| , m_test (test) {} |
| IterateResult iterate (void); |
| |
| void testDeletedNames (void); |
| void testDeletedBinding (void); |
| void testDeletedReattach (void); |
| |
| private: |
| Attacher& m_attacher; |
| const TestFunction m_test; |
| }; |
| |
| IterateResult AttachmentTest::iterate (void) |
| { |
| (this->*m_test)(); |
| return STOP; |
| } |
| |
| GLuint getAttachment (Attacher& attacher, GLuint container) |
| { |
| const GLuint queriedAttachment = attacher.getAttachment(container); |
| attacher.log() << TestLog::Message |
| << "// Result of query for " << attacher.getElementType().getName() |
| << " attached to " << attacher.getContainerType().getName() << " " |
| << container << ": " << queriedAttachment << "." |
| << TestLog::EndMessage; |
| return queriedAttachment; |
| } |
| |
| void AttachmentTest::testDeletedNames (void) |
| { |
| Type& elemType = m_attacher.getElementType(); |
| Type& containerType = m_attacher.getContainerType(); |
| Name container (containerType); |
| ResultCollector errors (getTestContext()); |
| GLuint elementId = 0; |
| |
| { |
| Name element(elemType); |
| elementId = *element; |
| m_attacher.initAttachment(0, *element); |
| m_attacher.attach(*element, *container); |
| errors.check(getAttachment(m_attacher, *container) == elementId, |
| "Attachment name not returned by query even before deletion."); |
| } |
| |
| // "Such a container or other context may continue using the object, and |
| // may still contain state identifying its name as being currently bound" |
| // |
| // We here interpret "may" to mean that whenever the container has a |
| // deleted object attached to it, a query will return that object's former |
| // name. |
| errors.check(getAttachment(m_attacher, *container) == elementId, |
| "Attachment name not returned by query after attachment was deleted."); |
| |
| if (elemType.nameLingers()) |
| errors.check(elemType.exists(elementId), |
| "Attached object name no longer valid after deletion."); |
| else |
| errors.check(!elemType.exists(elementId), |
| "Attached object name still valid after deletion."); |
| |
| m_attacher.detach(elementId, *container); |
| errors.check(getAttachment(m_attacher, *container) == 0, |
| "Attachment name returned by query even after detachment."); |
| errors.check(!elemType.exists(elementId), |
| "Deleted attached object name still usable after detachment."); |
| }; |
| |
| class InputAttachmentTest : public TestBase |
| { |
| public: |
| InputAttachmentTest (const char* name, |
| const char* description, |
| InputAttacher& inputAttacher) |
| : TestBase (name, description, inputAttacher.getContext()) |
| , m_inputAttacher (inputAttacher) {} |
| |
| IterateResult iterate (void); |
| |
| private: |
| InputAttacher& m_inputAttacher; |
| }; |
| |
| GLuint replaceName (Type& type, GLuint oldName, TestLog& log) |
| { |
| const Binder* const binder = type.binder(); |
| const bool genRequired = binder == DE_NULL || binder->genRequired(); |
| |
| if (genRequired) |
| return type.gen(); |
| |
| log << TestLog::Message |
| << "// Type does not require Gen* for binding, reusing old id " << oldName << "." |
| << TestLog::EndMessage; |
| |
| return oldName; |
| } |
| |
| IterateResult InputAttachmentTest::iterate (void) |
| { |
| Attacher& attacher = m_inputAttacher.getAttacher(); |
| Type& containerType = attacher.getContainerType(); |
| Type& elementType = attacher.getElementType(); |
| Name container (containerType); |
| GLuint elementId = 0; |
| const GLuint refSeed = m_rnd.getUint32(); |
| const GLuint newSeed = m_rnd.getUint32(); |
| ResultCollector errors (getTestContext()); |
| |
| Surface refSurface; // Surface from drawing with refSeed-seeded attachment |
| Surface delSurface; // Surface from drawing with deleted refSeed attachment |
| Surface newSurface; // Surface from drawing with newSeed-seeded attachment |
| |
| log() << TestLog::Message |
| << "Testing if writing to a newly created object modifies a deleted attachment" |
| << TestLog::EndMessage; |
| |
| { |
| ScopedLogSection section (log(), |
| "Write to original", "Writing to an original attachment"); |
| const Name element (elementType); |
| |
| elementId = *element; |
| attacher.initAttachment(refSeed, elementId); |
| attacher.attach(elementId, *container); |
| m_inputAttacher.drawContainer(*container, refSurface); |
| // element gets deleted here |
| log() << TestLog::Message << "// Deleting attachment"; |
| } |
| { |
| ScopedLogSection section (log(), "Write to new", |
| "Writing to a new attachment after deleting the original"); |
| const GLuint newId = replaceName(elementType, elementId, log()); |
| const Name newElement (elementType, newId); |
| |
| attacher.initAttachment(newSeed, newId); |
| |
| m_inputAttacher.drawContainer(*container, delSurface); |
| attacher.detach(elementId, *container); |
| |
| attacher.attach(newId, *container); |
| m_inputAttacher.drawContainer(*container, newSurface); |
| attacher.detach(newId, *container); |
| } |
| { |
| const bool surfacesMatch = tcu::pixelThresholdCompare( |
| log(), "Reading from deleted", |
| "Comparison result from reading from a container with a deleted attachment " |
| "before and after writing to a fresh object.", |
| refSurface, delSurface, RGBA(0, 0, 0, 0), tcu::COMPARE_LOG_RESULT); |
| |
| errors.check( |
| surfacesMatch, |
| "Writing to a fresh object modified the container with a deleted attachment."); |
| |
| if (!surfacesMatch) |
| log() << TestLog::Image("New attachment", |
| "Container state after attached to the fresh object", |
| newSurface); |
| } |
| |
| return STOP; |
| } |
| |
| class OutputAttachmentTest : public TestBase |
| { |
| public: |
| OutputAttachmentTest (const char* name, |
| const char* description, |
| OutputAttacher& outputAttacher) |
| : TestBase (name, description, |
| outputAttacher.getContext()) |
| , m_outputAttacher (outputAttacher) {} |
| IterateResult iterate (void); |
| |
| private: |
| OutputAttacher& m_outputAttacher; |
| }; |
| |
| IterateResult OutputAttachmentTest::iterate (void) |
| { |
| Attacher& attacher = m_outputAttacher.getAttacher(); |
| Type& containerType = attacher.getContainerType(); |
| Type& elementType = attacher.getElementType(); |
| Name container (containerType); |
| GLuint elementId = 0; |
| const GLuint refSeed = m_rnd.getUint32(); |
| const GLuint newSeed = m_rnd.getUint32(); |
| ResultCollector errors (getTestContext()); |
| Surface refSurface; // Surface drawn from attachment to refSeed container |
| Surface newSurface; // Surface drawn from attachment to newSeed container |
| Surface delSurface; // Like newSurface, after writing to a deleted attachment |
| |
| log() << TestLog::Message |
| << "Testing if writing to a container with a deleted attachment " |
| << "modifies a newly created object" |
| << TestLog::EndMessage; |
| |
| { |
| ScopedLogSection section (log(), "Write to existing", |
| "Writing to a container with an existing attachment"); |
| const Name element (elementType); |
| |
| elementId = *element; |
| attacher.initAttachment(0, elementId); |
| attacher.attach(elementId, *container); |
| |
| // For reference purposes, make note of what refSeed looks like. |
| m_outputAttacher.setupContainer(refSeed, *container); |
| m_outputAttacher.drawAttachment(elementId, refSurface); |
| } |
| { |
| ScopedLogSection section (log(), "Write to deleted", |
| "Writing to a container after deletion of attachment"); |
| const GLuint newId = replaceName(elementType, elementId, log()); |
| const Name newElement (elementType, newId); |
| |
| log() << TestLog::Message |
| << "Creating a new object " << newId |
| << TestLog::EndMessage; |
| |
| log() << TestLog::Message |
| << "Recording state of new object before writing to container" |
| << TestLog::EndMessage; |
| attacher.initAttachment(newSeed, newId); |
| m_outputAttacher.drawAttachment(newId, newSurface); |
| |
| log() << TestLog::Message |
| << "Writing to container" |
| << TestLog::EndMessage; |
| |
| // Now re-write refSeed to the container. |
| m_outputAttacher.setupContainer(refSeed, *container); |
| // Does it affect the newly created attachment object? |
| m_outputAttacher.drawAttachment(newId, delSurface); |
| } |
| attacher.detach(elementId, *container); |
| |
| const bool surfacesMatch = tcu::pixelThresholdCompare( |
| log(), "Writing to deleted", |
| "Comparison result from reading from a fresh object before and after " |
| "writing to a container with a deleted attachment", |
| newSurface, delSurface, RGBA(0, 0, 0, 0), tcu::COMPARE_LOG_RESULT); |
| |
| errors.check(surfacesMatch, |
| "Writing to container with deleted attachment modified a new object."); |
| |
| if (!surfacesMatch) |
| log() << TestLog::Image( |
| "Original attachment", |
| "Result of container modification on original attachment before deletion.", |
| refSurface); |
| return STOP; |
| }; |
| |
| struct LifeTestSpec |
| { |
| const char* name; |
| LifeTest::TestFunction func; |
| bool needBind; |
| }; |
| |
| MovePtr<TestCaseGroup> createLifeTestGroup (TestContext& testCtx, |
| const LifeTestSpec& spec, |
| const vector<Type*>& types) |
| { |
| MovePtr<TestCaseGroup> group(new TestCaseGroup(testCtx, spec.name, spec.name)); |
| |
| for (vector<Type*>::const_iterator it = types.begin(); it != types.end(); ++it) |
| { |
| Type& type = **it; |
| const char* name = type.getName(); |
| if (!spec.needBind || type.binder() != DE_NULL) |
| group->addChild(new LifeTest(name, name, type, spec.func)); |
| } |
| |
| return group; |
| } |
| |
| static const LifeTestSpec s_lifeTests[] = |
| { |
| { "gen", &LifeTest::testGen, false }, |
| { "delete", &LifeTest::testDelete, false }, |
| { "bind", &LifeTest::testBind, true }, |
| { "delete_bound", &LifeTest::testDeleteBound, true }, |
| { "bind_no_gen", &LifeTest::testBindNoGen, true }, |
| }; |
| |
| string attacherName (Attacher& attacher) |
| { |
| ostringstream os; |
| os << attacher.getElementType().getName() << "_" << attacher.getContainerType().getName(); |
| return os.str(); |
| } |
| |
| void addTestCases (TestCaseGroup& group, Types& types) |
| { |
| TestContext& testCtx = types.getTestContext(); |
| |
| for (const LifeTestSpec* it = DE_ARRAY_BEGIN(s_lifeTests); |
| it != DE_ARRAY_END(s_lifeTests); ++it) |
| group.addChild(createLifeTestGroup(testCtx, *it, types.getTypes()).release()); |
| |
| { |
| TestCaseGroup* const delUsedGroup = |
| new TestCaseGroup(testCtx, "delete_used", "Delete current program"); |
| group.addChild(delUsedGroup); |
| |
| delUsedGroup->addChild( |
| new LifeTest("program", "program", types.getProgramType(), |
| &LifeTest::testDeleteUsed)); |
| } |
| |
| { |
| TestCaseGroup* const attGroup = new TestCaseGroup( |
| testCtx, "attach", "Attachment tests"); |
| group.addChild(attGroup); |
| |
| { |
| TestCaseGroup* const nameGroup = new TestCaseGroup( |
| testCtx, "deleted_name", "Name of deleted attachment"); |
| attGroup->addChild(nameGroup); |
| |
| const vector<Attacher*>& atts = types.getAttachers(); |
| for (vector<Attacher*>::const_iterator it = atts.begin(); it != atts.end(); ++it) |
| { |
| const string name = attacherName(**it); |
| nameGroup->addChild(new AttachmentTest(name.c_str(), name.c_str(), **it, |
| &AttachmentTest::testDeletedNames)); |
| } |
| } |
| { |
| TestCaseGroup* inputGroup = new TestCaseGroup( |
| testCtx, "deleted_input", "Input from deleted attachment"); |
| attGroup->addChild(inputGroup); |
| |
| const vector<InputAttacher*>& inAtts = types.getInputAttachers(); |
| for (vector<InputAttacher*>::const_iterator it = inAtts.begin(); |
| it != inAtts.end(); ++it) |
| { |
| const string name = attacherName((*it)->getAttacher()); |
| inputGroup->addChild(new InputAttachmentTest(name.c_str(), name.c_str(), **it)); |
| } |
| } |
| { |
| TestCaseGroup* outputGroup = new TestCaseGroup( |
| testCtx, "deleted_output", "Output to deleted attachment"); |
| attGroup->addChild(outputGroup); |
| |
| const vector<OutputAttacher*>& outAtts = types.getOutputAttachers(); |
| for (vector<OutputAttacher*>::const_iterator it = outAtts.begin(); |
| it != outAtts.end(); ++it) |
| { |
| string name = attacherName((*it)->getAttacher()); |
| outputGroup->addChild(new OutputAttachmentTest(name.c_str(), name.c_str(), |
| **it)); |
| } |
| } |
| } |
| } |
| |
| } // details |
| } // LifetimeTests |
| } // gls |
| } // deqp |