You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1491 lines
62 KiB
1491 lines
62 KiB
/*-------------------------------------------------------------------------
|
|
* drawElements Quality Program OpenGL ES 3.1 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 Negative Vertex Array API tests.
|
|
*//*--------------------------------------------------------------------*/
|
|
|
|
#include "es31fNegativeVertexArrayApiTests.hpp"
|
|
#include "gluCallLogWrapper.hpp"
|
|
#include "gluContextInfo.hpp"
|
|
#include "gluShaderProgram.hpp"
|
|
#include "glwDefs.hpp"
|
|
#include "glwEnums.hpp"
|
|
#include "tcuStringTemplate.hpp"
|
|
|
|
namespace deqp
|
|
{
|
|
|
|
using std::string;
|
|
using std::map;
|
|
|
|
namespace gles31
|
|
{
|
|
namespace Functional
|
|
{
|
|
namespace NegativeTestShared
|
|
{
|
|
|
|
using tcu::TestLog;
|
|
using glu::CallLogWrapper;
|
|
using namespace glw;
|
|
|
|
static const char* vertexShaderSource = "${GLSL_VERSION_STRING}\n"
|
|
"void main (void)\n"
|
|
"{\n"
|
|
" gl_Position = vec4(0.0);\n"
|
|
"}\n\0";
|
|
|
|
static const char* fragmentShaderSource = "${GLSL_VERSION_STRING}\n"
|
|
"layout(location = 0) out mediump vec4 fragColor;"
|
|
"void main (void)\n"
|
|
"{\n"
|
|
" fragColor = vec4(0.0);\n"
|
|
"}\n\0";
|
|
|
|
static const char* geometryShaderSource = "#version 320 es\n"
|
|
"layout(points) in;\n"
|
|
"layout(points, max_vertices = 3) out;\n"
|
|
"void main (void)\n"
|
|
"{\n"
|
|
"}\n";
|
|
|
|
// Helper class that enables tests to be executed on GL4.5 context
|
|
// and removes code redundancy in each test that requires it.
|
|
class VAOHelper
|
|
{
|
|
public:
|
|
VAOHelper(NegativeTestContext& ctx, bool isES)
|
|
: m_vao(0)
|
|
, m_ctx(ctx)
|
|
{
|
|
// tests need vao only for GL4.5 context
|
|
if (isES)
|
|
return;
|
|
|
|
m_ctx.glGenVertexArrays(1, &m_vao);
|
|
m_ctx.glBindVertexArray(m_vao);
|
|
m_ctx.glVertexAttribPointer(0, 1, GL_BYTE, GL_TRUE, 0, NULL);
|
|
m_ctx.glEnableVertexAttribArray(0);
|
|
}
|
|
|
|
~VAOHelper()
|
|
{
|
|
if (m_vao)
|
|
m_ctx.glDeleteVertexArrays(1, &m_vao);
|
|
}
|
|
|
|
private:
|
|
GLuint m_vao;
|
|
NegativeTestContext& m_ctx;
|
|
};
|
|
|
|
void vertex_attribf (NegativeTestContext& ctx)
|
|
{
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
|
|
int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
|
|
ctx.glVertexAttrib1f(maxVertexAttribs, 0.0f);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.glVertexAttrib2f(maxVertexAttribs, 0.0f, 0.0f);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.glVertexAttrib3f(maxVertexAttribs, 0.0f, 0.0f, 0.0f);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.glVertexAttrib4f(maxVertexAttribs, 0.0f, 0.0f, 0.0f, 0.0f);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void vertex_attribfv (NegativeTestContext& ctx)
|
|
{
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
|
|
int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
|
|
float v[4] = {0.0f};
|
|
ctx.glVertexAttrib1fv(maxVertexAttribs, &v[0]);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.glVertexAttrib2fv(maxVertexAttribs, &v[0]);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.glVertexAttrib3fv(maxVertexAttribs, &v[0]);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.glVertexAttrib4fv(maxVertexAttribs, &v[0]);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void vertex_attribi4 (NegativeTestContext& ctx)
|
|
{
|
|
int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
|
|
GLint valInt = 0;
|
|
GLuint valUint = 0;
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
|
|
ctx.glVertexAttribI4i(maxVertexAttribs, valInt, valInt, valInt, valInt);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.glVertexAttribI4ui(maxVertexAttribs, valUint, valUint, valUint, valUint);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void vertex_attribi4v (NegativeTestContext& ctx)
|
|
{
|
|
int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
|
|
GLint valInt[4] = { 0 };
|
|
GLuint valUint[4] = { 0 };
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
|
|
ctx.glVertexAttribI4iv(maxVertexAttribs, &valInt[0]);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.glVertexAttribI4uiv(maxVertexAttribs, &valUint[0]);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void vertex_attrib_pointer (NegativeTestContext& ctx)
|
|
{
|
|
GLuint vao = 0;
|
|
ctx.glGenVertexArrays(1, &vao);
|
|
if (glu::isContextTypeES(ctx.getRenderContext().getType()))
|
|
ctx.glBindVertexArray(0);
|
|
else
|
|
ctx.glBindVertexArray(vao);
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if type is not an accepted value.");
|
|
ctx.glVertexAttribPointer(0, 1, 0, GL_TRUE, 0, 0);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
|
|
int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
|
|
ctx.glVertexAttribPointer(maxVertexAttribs, 1, GL_BYTE, GL_TRUE, 0, 0);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if size is not 1, 2, 3, or 4.");
|
|
ctx.glVertexAttribPointer(0, 0, GL_BYTE, GL_TRUE, 0, 0);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if stride is negative.");
|
|
ctx.glVertexAttribPointer(0, 1, GL_BYTE, GL_TRUE, -1, 0);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_OPERATION is generated if type is GL_INT_2_10_10_10_REV or GL_UNSIGNED_INT_2_10_10_10_REV and size is not 4.");
|
|
ctx.glVertexAttribPointer(0, 2, GL_INT_2_10_10_10_REV, GL_TRUE, 0, 0);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
ctx.glVertexAttribPointer(0, 2, GL_UNSIGNED_INT_2_10_10_10_REV, GL_TRUE, 0, 0);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
ctx.glVertexAttribPointer(0, 4, GL_INT_2_10_10_10_REV, GL_TRUE, 0, 0);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
ctx.glVertexAttribPointer(0, 4, GL_UNSIGNED_INT_2_10_10_10_REV, GL_TRUE, 0, 0);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_OPERATION is generated a non-zero vertex array object is bound, zero is bound to the GL_ARRAY_BUFFER buffer object binding point and the pointer argument is not NULL.");
|
|
GLbyte offset = 1;
|
|
ctx.glBindVertexArray(vao);
|
|
ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.glVertexAttribPointer(0, 1, GL_BYTE, GL_TRUE, 0, &offset);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
|
|
ctx.glBindVertexArray(0);
|
|
ctx.glDeleteVertexArrays(1, &vao);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void vertex_attrib_i_pointer (NegativeTestContext& ctx)
|
|
{
|
|
GLuint vao = 0;
|
|
ctx.glGenVertexArrays(1, &vao);
|
|
if (glu::isContextTypeES(ctx.getRenderContext().getType()))
|
|
ctx.glBindVertexArray(0);
|
|
else
|
|
ctx.glBindVertexArray(vao);
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if type is not an accepted value.");
|
|
ctx.glVertexAttribIPointer(0, 1, 0, 0, 0);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.glVertexAttribIPointer(0, 4, GL_INT_2_10_10_10_REV, 0, 0);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.glVertexAttribIPointer(0, 4, GL_UNSIGNED_INT_2_10_10_10_REV, 0, 0);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
|
|
int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
|
|
ctx.glVertexAttribIPointer(maxVertexAttribs, 1, GL_BYTE, 0, 0);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if size is not 1, 2, 3, or 4.");
|
|
ctx.glVertexAttribIPointer(0, 0, GL_BYTE, 0, 0);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if stride is negative.");
|
|
ctx.glVertexAttribIPointer(0, 1, GL_BYTE, -1, 0);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_OPERATION is generated a non-zero vertex array object is bound, zero is bound to the GL_ARRAY_BUFFER buffer object binding point and the pointer argument is not NULL.");
|
|
GLbyte offset = 1;
|
|
ctx.glBindVertexArray(vao);
|
|
ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.glVertexAttribIPointer(0, 1, GL_BYTE, 0, &offset);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
|
|
ctx.glBindVertexArray(0);
|
|
ctx.glDeleteVertexArrays(1, &vao);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void vertex_attrib_format (NegativeTestContext& ctx)
|
|
{
|
|
int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
|
|
int maxVertexAttribRelativeOffset = ctx.getInteger(GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET);
|
|
GLuint vao = 0;
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if attribindex is greater than or equal to the value of MAX_VERTEX_ATTRIBS.");
|
|
ctx.glGenVertexArrays(1, &vao);
|
|
ctx.glBindVertexArray(vao);
|
|
ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
ctx.glVertexAttribFormat(maxVertexAttribs, 4, GL_FLOAT, GL_FALSE, maxVertexAttribRelativeOffset);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if size is not one of 1, 2, 3, 4.");
|
|
ctx.glGenVertexArrays(1, &vao);
|
|
ctx.glBindVertexArray(vao);
|
|
ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
ctx.glVertexAttribFormat(1, 0, GL_FLOAT, GL_FALSE, maxVertexAttribRelativeOffset);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the parameter token names allowed.");
|
|
ctx.glGenVertexArrays(1, &vao);
|
|
ctx.glBindVertexArray(vao);
|
|
ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
ctx.glVertexAttribFormat(1, 4, 1, GL_FALSE, 0);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_OPERATION is generated if type is not a token name allowed.");
|
|
ctx.glGenVertexArrays(1, &vao);
|
|
ctx.glBindVertexArray(0);
|
|
ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
ctx.glVertexAttribFormat(1, 4, GL_FLOAT, GL_FALSE, 0);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_OPERATION is generated if type is GL_INT_2_10_10_10_REV and size is not 4.");
|
|
ctx.glGenVertexArrays(1, &vao);
|
|
ctx.glBindVertexArray(vao);
|
|
ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
ctx.glVertexAttribFormat(1, 3, GL_INT_2_10_10_10_REV, GL_FALSE, 0);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_OPERATION is generated if type is GL_UNSIGNED_INT_2_10_10_10_REV and size is not 4.");
|
|
ctx.glGenVertexArrays(1, &vao);
|
|
ctx.glBindVertexArray(vao);
|
|
ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
ctx.glVertexAttribFormat(1, 3, GL_UNSIGNED_INT_2_10_10_10_REV, GL_FALSE, 0);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if relativeoffset is larger than the value of GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET.");
|
|
ctx.glGenVertexArrays(1, &vao);
|
|
ctx.glBindVertexArray(vao);
|
|
ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
ctx.glVertexAttribFormat(1, 4, GL_FLOAT, GL_FALSE, maxVertexAttribRelativeOffset + 1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void vertex_attrib_i_format (NegativeTestContext& ctx)
|
|
{
|
|
int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
|
|
int maxVertexAttribRelativeOffset = ctx.getInteger(GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET);
|
|
GLuint vao = 0;
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if attribindex is greater than or equal to the value of GL_MAX_VERTEX_ATTRIBS.");
|
|
ctx.glGenVertexArrays(1, &vao);
|
|
ctx.glBindVertexArray(vao);
|
|
ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
ctx.glVertexAttribIFormat(maxVertexAttribs, 4, GL_INT, 0);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if size is not one the values 1, 2, 3, 4.");
|
|
ctx.glGenVertexArrays(1, &vao);
|
|
ctx.glBindVertexArray(vao);
|
|
ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
ctx.glVertexAttribIFormat(1, 0, GL_INT, 0);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the parameter token names allowed.");
|
|
ctx.glGenVertexArrays(1, &vao);
|
|
ctx.glBindVertexArray(vao);
|
|
ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
ctx.glVertexAttribIFormat(1, 4, GL_FLOAT, 0);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_OPERATION is generated if type is not a token name allowed.");
|
|
ctx.glGenVertexArrays(1, &vao);
|
|
ctx.glBindVertexArray(0);
|
|
ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
ctx.glVertexAttribIFormat(1, 4, GL_INT, 0);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if relativeoffset is larger than the value of GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET.");
|
|
ctx.glGenVertexArrays(1, &vao);
|
|
ctx.glBindVertexArray(vao);
|
|
ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
ctx.glVertexAttribIFormat(1, 4, GL_INT, maxVertexAttribRelativeOffset + 1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void enable_vertex_attrib_array (NegativeTestContext& ctx)
|
|
{
|
|
int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
|
|
ctx.glEnableVertexAttribArray(maxVertexAttribs);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void disable_vertex_attrib_array (NegativeTestContext& ctx)
|
|
{
|
|
int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
|
|
ctx.glDisableVertexAttribArray(maxVertexAttribs);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void gen_vertex_arrays (NegativeTestContext& ctx)
|
|
{
|
|
GLuint arrays = 0;
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
|
|
ctx.glGenVertexArrays(-1, &arrays);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void bind_vertex_array (NegativeTestContext& ctx)
|
|
{
|
|
ctx.beginSection("GL_INVALID_OPERATION is generated if array is not zero or the name of an existing vertex array object.");
|
|
ctx.glBindVertexArray(-1);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void delete_vertex_arrays (NegativeTestContext& ctx)
|
|
{
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
|
|
ctx.glDeleteVertexArrays(-1, 0);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void vertex_attrib_divisor (NegativeTestContext& ctx)
|
|
{
|
|
int maxVertexAttribs = ctx.getInteger(GL_MAX_VERTEX_ATTRIBS);
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
|
|
ctx.glVertexAttribDivisor(maxVertexAttribs, 0);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void draw_arrays (NegativeTestContext& ctx)
|
|
{
|
|
const glu::RenderContext& rc = ctx.getRenderContext();
|
|
const bool isES32 = glu::contextSupports(rc.getType(), glu::ApiType::es(3, 2));
|
|
GLuint fbo = 0;
|
|
map<string, string> args;
|
|
args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
|
|
glu::ShaderProgram program (rc, glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
|
|
VAOHelper vao(ctx, glu::isContextTypeES(rc.getType()));
|
|
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawArrays(-1, 0, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
|
|
ctx.glDrawArrays(GL_POINTS, 0, -1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawArrays(GL_POINTS, 0, 1);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
|
|
ctx.glUseProgram(0);
|
|
}
|
|
|
|
void draw_arrays_invalid_program (NegativeTestContext& ctx)
|
|
{
|
|
GLuint fbo = 0;
|
|
VAOHelper vao(ctx, glu::isContextTypeES(ctx.getRenderContext().getType()));
|
|
|
|
ctx.glUseProgram(0);
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawArrays(-1, 0, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
|
|
ctx.glDrawArrays(GL_POINTS, 0, -1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawArrays(GL_POINTS, 0, 1);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void draw_arrays_incomplete_primitive (NegativeTestContext& ctx)
|
|
{
|
|
const glu::RenderContext& rc = ctx.getRenderContext();
|
|
const bool isES32 = glu::contextSupports(rc.getType(), glu::ApiType::es(3, 2));
|
|
GLuint fbo = 0;
|
|
map<string, string> args;
|
|
args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
|
|
glu::ShaderProgram program (rc, glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
|
|
VAOHelper vao(ctx, glu::isContextTypeES(rc.getType()));
|
|
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawArrays(-1, 0, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
|
|
ctx.glDrawArrays(GL_TRIANGLES, 0, -1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawArrays(GL_TRIANGLES, 0, 1);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
|
|
ctx.glUseProgram(0);
|
|
}
|
|
|
|
void draw_elements (NegativeTestContext& ctx)
|
|
{
|
|
const glu::RenderContext& rc = ctx.getRenderContext();
|
|
const bool isES = glu::isContextTypeES(rc.getType());
|
|
const bool isES32 = glu::contextSupports(rc.getType(), glu::ApiType::es(3, 2));
|
|
GLuint fbo = 0;
|
|
GLuint buf = 0;
|
|
GLuint tfID = 0;
|
|
GLbyte indices[1] = {0};
|
|
map<string, string> args;
|
|
args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
|
|
glu::ShaderProgram program (rc, glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
|
|
VAOHelper vao(ctx, isES);
|
|
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawElements(-1, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
|
|
ctx.glDrawElements(GL_POINTS, 1, -1, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.glDrawElements(GL_POINTS, 1, GL_FLOAT, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
|
|
ctx.glDrawElements(GL_POINTS, -1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawElements(GL_POINTS, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
|
|
if (isES && !ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
|
|
{
|
|
ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
|
|
const char* tfVarying = "gl_Position";
|
|
|
|
ctx.glGenBuffers(1, &buf);
|
|
ctx.glGenTransformFeedbacks(1, &tfID);
|
|
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
|
|
ctx.glLinkProgram(program.getProgram());
|
|
ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
|
|
ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
|
|
ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
|
|
ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
|
|
ctx.glBeginTransformFeedback(GL_POINTS);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.glDrawElements(GL_POINTS, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
|
|
ctx.glPauseTransformFeedback();
|
|
ctx.glDrawElements(GL_POINTS, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.glEndTransformFeedback();
|
|
ctx.glDeleteBuffers(1, &buf);
|
|
ctx.glDeleteTransformFeedbacks(1, &tfID);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
ctx.endSection();
|
|
}
|
|
|
|
ctx.glUseProgram(0);
|
|
}
|
|
|
|
void draw_elements_invalid_program (NegativeTestContext& ctx)
|
|
{
|
|
ctx.glUseProgram(0);
|
|
GLuint fbo = 0;
|
|
GLbyte indices[1] = {0};
|
|
VAOHelper vao(ctx, glu::isContextTypeES(ctx.getRenderContext().getType()));
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawElements(-1, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
|
|
ctx.glDrawElements(GL_POINTS, 1, -1, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.glDrawElements(GL_POINTS, 1, GL_FLOAT, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
|
|
ctx.glDrawElements(GL_POINTS, -1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawElements(GL_POINTS, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void draw_elements_incomplete_primitive (NegativeTestContext& ctx)
|
|
{
|
|
const glu::RenderContext& rc = ctx.getRenderContext();
|
|
bool isES = glu::isContextTypeES(rc.getType());
|
|
const bool isES32 = glu::contextSupports(rc.getType(), glu::ApiType::es(3, 2));
|
|
GLuint fbo = 0;
|
|
GLuint buf = 0;
|
|
GLuint tfID = 0;
|
|
GLbyte indices[1] = {0};
|
|
map<string, string> args;
|
|
args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
|
|
glu::ShaderProgram program (rc, glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
|
|
VAOHelper vao(ctx, isES);
|
|
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawElements(-1, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
|
|
ctx.glDrawElements(GL_TRIANGLES, 1, -1, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.glDrawElements(GL_TRIANGLES, 1, GL_FLOAT, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
|
|
ctx.glDrawElements(GL_TRIANGLES, -1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawElements(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
|
|
if (isES && !ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
|
|
{
|
|
ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
|
|
const char* tfVarying= "gl_Position";
|
|
|
|
ctx.glGenBuffers(1, &buf);
|
|
ctx.glGenTransformFeedbacks(1, &tfID);
|
|
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
|
|
ctx.glLinkProgram(program.getProgram());
|
|
ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
|
|
ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
|
|
ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
|
|
ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
|
|
ctx.glBeginTransformFeedback(GL_TRIANGLES);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.glDrawElements(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
|
|
ctx.glPauseTransformFeedback();
|
|
ctx.glDrawElements(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.glEndTransformFeedback();
|
|
ctx.glDeleteBuffers(1, &buf);
|
|
ctx.glDeleteTransformFeedbacks(1, &tfID);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
ctx.endSection();
|
|
}
|
|
|
|
ctx.glUseProgram(0);
|
|
}
|
|
|
|
static bool checkSupport(NegativeTestContext& ctx)
|
|
{
|
|
return contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
|
|
contextSupports(ctx.getRenderContext().getType(), glu::ApiType::core(4, 5));
|
|
}
|
|
|
|
void draw_elements_base_vertex (NegativeTestContext& ctx)
|
|
{
|
|
TCU_CHECK_AND_THROW(NotSupportedError, checkSupport(ctx), "This test requires a 3.2 context or higher context version.");
|
|
|
|
GLuint fbo = 0;
|
|
GLuint indices[1] = {0};
|
|
VAOHelper vao(ctx, glu::isContextTypeES(ctx.getRenderContext().getType()));
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawElementsBaseVertex(-1, 1, GL_UNSIGNED_INT, indices, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
|
|
ctx.glDrawElementsBaseVertex(GL_POINTS, 1, -1, indices, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.glDrawElementsBaseVertex(GL_POINTS, 1, GL_FLOAT, indices, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
|
|
ctx.glDrawElementsBaseVertex(GL_POINTS, -1, GL_UNSIGNED_INT, indices, 1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawElementsBaseVertex(GL_POINTS, 1, GL_UNSIGNED_INT, indices, 1);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void draw_elements_base_vertex_primitive_mode_mismatch (NegativeTestContext& ctx)
|
|
{
|
|
TCU_CHECK_AND_THROW(NotSupportedError, checkSupport(ctx), "This test requires a 3.2 context or higher context version.");
|
|
|
|
GLuint indices[1] = {0};
|
|
map<string, string> args;
|
|
args["GLSL_VERSION_STRING"] = getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES);
|
|
|
|
glu::ShaderProgram program(ctx.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << glu::VertexSource(tcu::StringTemplate(vertexShaderSource).specialize(args)) << glu::GeometrySource(geometryShaderSource));
|
|
|
|
ctx.beginSection("GL_INVALID_OPERATION is generated if a geometry shader is active and mode is incompatible with the input primitive type of the geometry shader in the currently installed program object.");
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.glDrawElementsBaseVertex(GL_TRIANGLES, 1, GL_UNSIGNED_INT, indices, 1);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
ctx.endSection();
|
|
|
|
ctx.glUseProgram(0);
|
|
}
|
|
|
|
void draw_arrays_instanced (NegativeTestContext& ctx)
|
|
{
|
|
const glu::RenderContext& rc = ctx.getRenderContext();
|
|
const bool isES32 = glu::contextSupports(rc.getType(), glu::ApiType::es(3, 2));
|
|
GLuint fbo = 0;
|
|
map<string, string> args;
|
|
args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
|
|
glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
|
|
VAOHelper vao (ctx, glu::isContextTypeES(rc.getType()));
|
|
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.expectError(GL_NO_ERROR);
|
|
ctx.glVertexAttribDivisor(0, 1);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawArraysInstanced(-1, 0, 1, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
|
|
ctx.glDrawArraysInstanced(GL_POINTS, 0, -1, 1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.glDrawArraysInstanced(GL_POINTS, 0, 1, -1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawArraysInstanced(GL_POINTS, 0, 1, 1);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
|
|
ctx.glUseProgram(0);
|
|
}
|
|
|
|
void draw_arrays_instanced_invalid_program (NegativeTestContext& ctx)
|
|
{
|
|
ctx.glUseProgram(0);
|
|
|
|
GLuint fbo = 0;
|
|
VAOHelper vao (ctx, glu::isContextTypeES(ctx.getRenderContext().getType()));
|
|
|
|
ctx.glVertexAttribDivisor(0, 1);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawArraysInstanced(-1, 0, 1, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
|
|
ctx.glDrawArraysInstanced(GL_POINTS, 0, -1, 1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.glDrawArraysInstanced(GL_POINTS, 0, 1, -1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawArraysInstanced(GL_POINTS, 0, 1, 1);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void draw_arrays_instanced_incomplete_primitive (NegativeTestContext& ctx)
|
|
{
|
|
const glu::RenderContext& rc = ctx.getRenderContext();
|
|
const bool isES32 = glu::contextSupports(rc.getType(), glu::ApiType::es(3, 2));
|
|
GLuint fbo = 0;
|
|
map<string, string> args;
|
|
args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
|
|
glu::ShaderProgram program (rc, glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
|
|
VAOHelper vao(ctx, glu::isContextTypeES(rc.getType()));
|
|
|
|
ctx.glVertexAttribDivisor(0, 1);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawArraysInstanced(-1, 0, 1, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
|
|
ctx.glDrawArraysInstanced(GL_TRIANGLES, 0, -1, 1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.glDrawArraysInstanced(GL_TRIANGLES, 0, 1, -1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawArraysInstanced(GL_TRIANGLES, 0, 1, 1);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
|
|
ctx.glUseProgram(0);
|
|
}
|
|
|
|
void draw_elements_instanced (NegativeTestContext& ctx)
|
|
{
|
|
const glu::RenderContext& rc = ctx.getRenderContext();
|
|
const bool isES = glu::isContextTypeES(rc.getType());
|
|
const bool isES32 = glu::contextSupports(rc.getType(), glu::ApiType::es(3, 2));
|
|
GLuint fbo = 0;
|
|
GLuint buf = 0;
|
|
GLuint tfID = 0;
|
|
GLbyte indices[1] = {0};
|
|
map<string, string> args;
|
|
args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
|
|
glu::ShaderProgram program (rc, glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
|
|
VAOHelper vao(ctx, isES);
|
|
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.glVertexAttribDivisor(0, 1);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawElementsInstanced(-1, 1, GL_UNSIGNED_BYTE, indices, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
|
|
ctx.glDrawElementsInstanced(GL_POINTS, 1, -1, indices, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_FLOAT, indices, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
|
|
ctx.glDrawElementsInstanced(GL_POINTS, -1, GL_UNSIGNED_BYTE, indices, 1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.glDrawElementsInstanced(GL_POINTS, 11, GL_UNSIGNED_BYTE, indices, -1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_UNSIGNED_BYTE, indices, 1);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
|
|
if (isES && !ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
|
|
{
|
|
ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
|
|
const char* tfVarying = "gl_Position";
|
|
|
|
ctx.glGenBuffers(1, &buf);
|
|
ctx.glGenTransformFeedbacks(1, &tfID);
|
|
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
|
|
ctx.glLinkProgram(program.getProgram());
|
|
ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
|
|
ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
|
|
ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
|
|
ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
|
|
ctx.glBeginTransformFeedback(GL_POINTS);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_UNSIGNED_BYTE, indices, 1);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
|
|
ctx.glPauseTransformFeedback();
|
|
ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_UNSIGNED_BYTE, indices, 1);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.glEndTransformFeedback();
|
|
ctx.glDeleteBuffers(1, &buf);
|
|
ctx.glDeleteTransformFeedbacks(1, &tfID);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
ctx.endSection();
|
|
}
|
|
|
|
ctx.glUseProgram(0);
|
|
}
|
|
|
|
void draw_elements_instanced_invalid_program (NegativeTestContext& ctx)
|
|
{
|
|
ctx.glUseProgram(0);
|
|
|
|
GLuint fbo = 0;
|
|
GLbyte indices[1] = {0};
|
|
VAOHelper vao(ctx, glu::isContextTypeES(ctx.getRenderContext().getType()));
|
|
|
|
ctx.glVertexAttribDivisor(0, 1);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawElementsInstanced(-1, 1, GL_UNSIGNED_BYTE, indices, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
|
|
ctx.glDrawElementsInstanced(GL_POINTS, 1, -1, indices, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_FLOAT, indices, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
|
|
ctx.glDrawElementsInstanced(GL_POINTS, -1, GL_UNSIGNED_BYTE, indices, 1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.glDrawElementsInstanced(GL_POINTS, 11, GL_UNSIGNED_BYTE, indices, -1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawElementsInstanced(GL_POINTS, 1, GL_UNSIGNED_BYTE, indices, 1);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void draw_elements_instanced_incomplete_primitive (NegativeTestContext& ctx)
|
|
{
|
|
const glu::RenderContext& rc = ctx.getRenderContext();
|
|
const bool isES = glu::isContextTypeES(rc.getType());
|
|
const bool isES32 = glu::contextSupports(rc.getType(), glu::ApiType::es(3, 2));
|
|
GLuint fbo = 0;
|
|
GLuint buf = 0;
|
|
GLuint tfID = 0;
|
|
GLbyte indices[1] = {0};
|
|
map<string, string> args;
|
|
args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
|
|
glu::ShaderProgram program (rc, glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
|
|
VAOHelper vao(ctx, isES);
|
|
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.glVertexAttribDivisor(0, 1);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawElementsInstanced(-1, 1, GL_UNSIGNED_BYTE, indices, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
|
|
ctx.glDrawElementsInstanced(GL_TRIANGLES, 1, -1, indices, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.glDrawElementsInstanced(GL_TRIANGLES, 1, GL_FLOAT, indices, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
|
|
ctx.glDrawElementsInstanced(GL_TRIANGLES, -1, GL_UNSIGNED_BYTE, indices, 1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.glDrawElementsInstanced(GL_TRIANGLES, 11, GL_UNSIGNED_BYTE, indices, -1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawElementsInstanced(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, indices, 1);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
|
|
if (isES && !ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
|
|
{
|
|
ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
|
|
const char* tfVarying= "gl_Position";
|
|
|
|
ctx.glGenBuffers(1, &buf);
|
|
ctx.glGenTransformFeedbacks(1, &tfID);
|
|
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
|
|
ctx.glLinkProgram(program.getProgram());
|
|
ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
|
|
ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
|
|
ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
|
|
ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
|
|
ctx.glBeginTransformFeedback(GL_TRIANGLES);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.glDrawElementsInstanced(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, indices, 1);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
|
|
ctx.glPauseTransformFeedback();
|
|
ctx.glDrawElementsInstanced (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, indices, 1);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.glEndTransformFeedback();
|
|
ctx.glDeleteBuffers(1, &buf);
|
|
ctx.glDeleteTransformFeedbacks(1, &tfID);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
ctx.endSection();
|
|
}
|
|
|
|
ctx.glUseProgram(0);
|
|
}
|
|
|
|
void draw_elements_instanced_base_vertex (NegativeTestContext& ctx)
|
|
{
|
|
TCU_CHECK_AND_THROW(NotSupportedError, checkSupport(ctx), "This test requires a 3.2 context or higher context version.");
|
|
|
|
const glu::RenderContext& rc = ctx.getRenderContext();
|
|
const bool isES32 = glu::contextSupports(rc.getType(), glu::ApiType::es(3, 2));
|
|
GLuint fbo = 0;
|
|
GLbyte indices[1] = {0};
|
|
map<string, string> args;
|
|
args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
|
|
glu::ShaderProgram program (rc, glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
|
|
VAOHelper vao(ctx, glu::isContextTypeES(rc.getType()));
|
|
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.glVertexAttribDivisor(0, 1);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawElementsInstancedBaseVertex(-1, 1, GL_UNSIGNED_BYTE, indices, 1, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
|
|
ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, 1, -1, indices, 1, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, 1, GL_FLOAT, indices, 1, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count or primcount are negative.");
|
|
ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, -1, GL_UNSIGNED_BYTE, indices, 1, 1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, 11, GL_UNSIGNED_BYTE, indices, -1, 1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawElementsInstancedBaseVertex(GL_POINTS, 1, GL_UNSIGNED_BYTE, indices, 1, 1);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
|
|
ctx.glUseProgram(0);
|
|
}
|
|
|
|
void draw_elements_instanced_base_vertex_primitive_mode_mismatch (NegativeTestContext& ctx)
|
|
{
|
|
TCU_CHECK_AND_THROW(NotSupportedError, checkSupport(ctx), "This test requires a 3.2 context or higher context version.");
|
|
|
|
GLuint indices[1] = {0};
|
|
map<string, string> args;
|
|
args["GLSL_VERSION_STRING"] = getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES);
|
|
glu::ShaderProgram geometryProgram(ctx.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << glu::VertexSource(tcu::StringTemplate(vertexShaderSource).specialize(args)) << glu::GeometrySource(geometryShaderSource));
|
|
|
|
ctx.beginSection("GL_INVALID_OPERATION is generated if a geometry shader is active and mode is incompatible with the input primitive type of the geometry shader in the currently installed program object.");
|
|
ctx.glUseProgram(geometryProgram.getProgram());
|
|
ctx.glDrawElementsInstancedBaseVertex(GL_TRIANGLES, 1, GL_UNSIGNED_INT, indices, 1, 1);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
ctx.endSection();
|
|
|
|
ctx.glUseProgram(0);
|
|
}
|
|
|
|
void draw_range_elements (NegativeTestContext& ctx)
|
|
{
|
|
const glu::RenderContext& rc = ctx.getRenderContext();
|
|
const bool isES = glu::isContextTypeES(rc.getType());
|
|
const bool isES32 = glu::contextSupports(rc.getType(), glu::ApiType::es(3, 2));
|
|
GLuint fbo = 0;
|
|
GLuint buf = 0;
|
|
GLuint tfID = 0;
|
|
GLbyte indices[1] = {0};
|
|
map<string, string> args;
|
|
args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
|
|
glu::ShaderProgram program (rc, glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
|
|
VAOHelper vao(ctx, isES);
|
|
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawRangeElements(-1, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
|
|
ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, -1, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_FLOAT, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
|
|
ctx.glDrawRangeElements(GL_POINTS, 0, 1, -1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if end < start.");
|
|
ctx.glDrawRangeElements(GL_POINTS, 1, 0, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
|
|
if (isES && !ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
|
|
{
|
|
ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
|
|
const char* tfVarying= "gl_Position";
|
|
|
|
ctx.glGenBuffers(1, &buf);
|
|
ctx.glGenTransformFeedbacks(1, &tfID);
|
|
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
|
|
ctx.glLinkProgram(program.getProgram());
|
|
ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
|
|
ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
|
|
ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
|
|
ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
|
|
ctx.glBeginTransformFeedback(GL_POINTS);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
|
|
ctx.glPauseTransformFeedback();
|
|
ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.glEndTransformFeedback();
|
|
ctx.glDeleteBuffers(1, &buf);
|
|
ctx.glDeleteTransformFeedbacks(1, &tfID);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
ctx.endSection();
|
|
}
|
|
|
|
ctx.glUseProgram(0);
|
|
}
|
|
|
|
void draw_range_elements_invalid_program (NegativeTestContext& ctx)
|
|
{
|
|
ctx.glUseProgram(0);
|
|
|
|
GLuint fbo = 0;
|
|
GLbyte indices[1] = {0};
|
|
VAOHelper vao(ctx, glu::isContextTypeES(ctx.getRenderContext().getType()));
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawRangeElements(-1, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
|
|
ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, -1, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_FLOAT, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
|
|
ctx.glDrawRangeElements(GL_POINTS, 0, 1, -1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if end < start.");
|
|
ctx.glDrawRangeElements(GL_POINTS, 1, 0, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawRangeElements(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
}
|
|
|
|
void draw_range_elements_incomplete_primitive (NegativeTestContext& ctx)
|
|
{
|
|
const glu::RenderContext& rc = ctx.getRenderContext();
|
|
const bool isES = glu::isContextTypeES(rc.getType());
|
|
const bool isES32 = glu::contextSupports(rc.getType(), glu::ApiType::es(3, 2));
|
|
GLuint fbo = 0;
|
|
GLuint buf = 0;
|
|
GLuint tfID = 0;
|
|
GLbyte indices[1] = {0};
|
|
map<string, string> args;
|
|
args["GLSL_VERSION_STRING"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
|
|
glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
|
|
VAOHelper vao(ctx, isES);
|
|
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawRangeElements(-1, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
|
|
ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, -1, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, GL_FLOAT, indices);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
|
|
ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, -1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if end < start.");
|
|
ctx.glDrawRangeElements(GL_TRIANGLES, 1, 0, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
|
|
if (isES && !ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
|
|
{
|
|
ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
|
|
const char* tfVarying = "gl_Position";
|
|
|
|
ctx.glGenBuffers(1, &buf);
|
|
ctx.glGenTransformFeedbacks(1, &tfID);
|
|
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
|
|
ctx.glLinkProgram(program.getProgram());
|
|
ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
|
|
ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
|
|
ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
|
|
ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
|
|
ctx.glBeginTransformFeedback(GL_TRIANGLES);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
|
|
ctx.glPauseTransformFeedback();
|
|
ctx.glDrawRangeElements(GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, indices);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.glEndTransformFeedback();
|
|
ctx.glDeleteBuffers(1, &buf);
|
|
ctx.glDeleteTransformFeedbacks(1, &tfID);
|
|
ctx.expectError(GL_NO_ERROR);
|
|
ctx.endSection();
|
|
}
|
|
|
|
ctx.glUseProgram(0);
|
|
}
|
|
|
|
void draw_range_elements_base_vertex (NegativeTestContext& ctx)
|
|
{
|
|
TCU_CHECK_AND_THROW(NotSupportedError, checkSupport(ctx), "This test requires a 3.2 context or higher context version.");
|
|
|
|
GLuint fbo = 0;
|
|
GLbyte indices[1] = {0};
|
|
map<string, string> args;
|
|
args["GLSL_VERSION_STRING"] = getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES);
|
|
const glu::RenderContext& rc = ctx.getRenderContext();
|
|
glu::ShaderProgram program (rc, glu::makeVtxFragSources(tcu::StringTemplate(vertexShaderSource).specialize(args), tcu::StringTemplate(fragmentShaderSource).specialize(args)));
|
|
VAOHelper vao(ctx, glu::isContextTypeES(rc.getType()));
|
|
|
|
ctx.glUseProgram(program.getProgram());
|
|
ctx.expectError(GL_NO_ERROR);
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if mode is not an accepted value.");
|
|
ctx.glDrawRangeElementsBaseVertex(-1, 0, 1, 1, GL_UNSIGNED_BYTE, indices, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_ENUM is generated if type is not one of the accepted values.");
|
|
ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 0, 1, 1, -1, indices, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 0, 1, 1, GL_FLOAT, indices, 1);
|
|
ctx.expectError(GL_INVALID_ENUM);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
|
|
ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 0, 1, -1, GL_UNSIGNED_BYTE, indices, 1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_VALUE is generated if end < start.");
|
|
ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 1, 0, 1, GL_UNSIGNED_BYTE, indices, 1);
|
|
ctx.expectError(GL_INVALID_VALUE);
|
|
ctx.endSection();
|
|
|
|
ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
|
|
ctx.glGenFramebuffers(1, &fbo);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
ctx.glDrawRangeElementsBaseVertex(GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, indices, 1);
|
|
ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
ctx.glDeleteFramebuffers(1, &fbo);
|
|
ctx.endSection();
|
|
|
|
ctx.glUseProgram(0);
|
|
}
|
|
|
|
void draw_range_elements_base_vertex_primitive_mode_mismatch (NegativeTestContext& ctx)
|
|
{
|
|
TCU_CHECK_AND_THROW(NotSupportedError, checkSupport(ctx), "This test requires a 3.2 context or higher context version.");
|
|
|
|
GLuint indices[1] = {0};
|
|
map<string, string> args;
|
|
args["GLSL_VERSION_STRING"] = getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES);
|
|
glu::ShaderProgram geometryProgram(ctx.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << glu::VertexSource(tcu::StringTemplate(vertexShaderSource).specialize(args)) << glu::GeometrySource(geometryShaderSource));
|
|
|
|
ctx.beginSection("GL_INVALID_OPERATION is generated if a geometry shader is active and mode is incompatible with the input primitive type of the geometry shader in the currently installed program object.");
|
|
ctx.glUseProgram(geometryProgram.getProgram());
|
|
ctx.glDrawRangeElementsBaseVertex(GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_INT, indices, 1);
|
|
ctx.expectError(GL_INVALID_OPERATION);
|
|
ctx.endSection();
|
|
|
|
ctx.glUseProgram(0);
|
|
}
|
|
|
|
std::vector<FunctionContainer> getNegativeVertexArrayApiTestFunctions ()
|
|
{
|
|
FunctionContainer funcs[] =
|
|
{
|
|
{vertex_attribf, "vertex_attribf", "Invalid glVertexAttrib{1234}f() usage" },
|
|
{vertex_attribfv, "vertex_attribfv", "Invalid glVertexAttrib{1234}fv() usage" },
|
|
{vertex_attribi4, "vertex_attribi4", "Invalid glVertexAttribI4{i|ui}f() usage" },
|
|
{vertex_attribi4v, "vertex_attribi4v", "Invalid glVertexAttribI4{i|ui}fv() usage" },
|
|
{vertex_attrib_pointer, "vertex_attrib_pointer", "Invalid glVertexAttribPointer() usage" },
|
|
{vertex_attrib_i_pointer, "vertex_attrib_i_pointer", "Invalid glVertexAttribPointer() usage" },
|
|
{vertex_attrib_format, "vertex_attrib_format", "Invalid glVertexAttribFormat() usage" },
|
|
{vertex_attrib_i_format, "vertex_attrib_i_format", "Invalid glVertexAttribIFormat() usage" },
|
|
{enable_vertex_attrib_array, "enable_vertex_attrib_array", "Invalid glEnableVertexAttribArray() usage" },
|
|
{disable_vertex_attrib_array, "disable_vertex_attrib_array", "Invalid glDisableVertexAttribArray() usage" },
|
|
{gen_vertex_arrays, "gen_vertex_arrays", "Invalid glGenVertexArrays() usage" },
|
|
{bind_vertex_array, "bind_vertex_array", "Invalid glBindVertexArray() usage" },
|
|
{delete_vertex_arrays, "delete_vertex_arrays", "Invalid glDeleteVertexArrays() usage" },
|
|
{vertex_attrib_divisor, "vertex_attrib_divisor", "Invalid glVertexAttribDivisor() usage" },
|
|
{draw_arrays, "draw_arrays", "Invalid glDrawArrays() usage" },
|
|
{draw_arrays_invalid_program, "draw_arrays_invalid_program", "Invalid glDrawArrays() usage" },
|
|
{draw_arrays_incomplete_primitive, "draw_arrays_incomplete_primitive", "Invalid glDrawArrays() usage" },
|
|
{draw_elements, "draw_elements", "Invalid glDrawElements() usage" },
|
|
{draw_elements_base_vertex, "draw_elements_base_vertex", "Invalid glDrawElementsBaseVertex() usage" },
|
|
{draw_elements_base_vertex_primitive_mode_mismatch, "draw_elements_base_vertex_primitive_mode_mismatch", "Invalid glDrawElementsBaseVertex() usage" },
|
|
{draw_elements_invalid_program, "draw_elements_invalid_program", "Invalid glDrawElements() usage" },
|
|
{draw_elements_incomplete_primitive, "draw_elements_incomplete_primitive", "Invalid glDrawElements() usage" },
|
|
{draw_arrays_instanced, "draw_arrays_instanced", "Invalid glDrawArraysInstanced() usage" },
|
|
{draw_arrays_instanced_invalid_program, "draw_arrays_instanced_invalid_program", "Invalid glDrawArraysInstanced() usage" },
|
|
{draw_arrays_instanced_incomplete_primitive, "draw_arrays_instanced_incomplete_primitive", "Invalid glDrawArraysInstanced() usage" },
|
|
{draw_elements_instanced, "draw_elements_instanced", "Invalid glDrawElementsInstanced() usage" },
|
|
{draw_elements_instanced_invalid_program, "draw_elements_instanced_invalid_program", "Invalid glDrawElementsInstanced() usage" },
|
|
{draw_elements_instanced_incomplete_primitive, "draw_elements_instanced_incomplete_primitive", "Invalid glDrawElementsInstanced() usage" },
|
|
{draw_elements_instanced_base_vertex, "draw_elements_instanced_base_vertex", "Invalid glDrawElementsInstancedBaseVertex() usage" },
|
|
{draw_elements_instanced_base_vertex_primitive_mode_mismatch, "draw_elements_instanced_base_vertex_primitive_mode_mismatch", "Invalid glDrawElementsInstancedBaseVertex() usage" },
|
|
{draw_range_elements, "draw_range_elements", "Invalid glDrawRangeElements() usage" },
|
|
{draw_range_elements_invalid_program, "draw_range_elements_invalid_program", "Invalid glDrawRangeElements() usage" },
|
|
{draw_range_elements_incomplete_primitive, "draw_range_elements_incomplete_primitive", "Invalid glDrawRangeElements() usage" },
|
|
{draw_range_elements_base_vertex, "draw_range_elements_base_vertex", "Invalid glDrawRangeElementsBaseVertex() usage" },
|
|
{draw_range_elements_base_vertex_primitive_mode_mismatch, "draw_range_elements_base_vertex_primitive_mode_mismatch", "Invalid glDrawRangeElementsBaseVertex() usage" },
|
|
};
|
|
|
|
return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
|
|
}
|
|
|
|
} // NegativeTestShared
|
|
} // Functional
|
|
} // gles31
|
|
} // deqp
|