blob: fb34551e70bb6aa2dcdc8af2383bd5f29087b5ed [file] [log] [blame]
/*-------------------------------------------------------------------------
* 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