Google Git
Sign in
fuchsia / third_party / vulkan-cts / 01ec8335ac893efd940b7a7a8f12f165d79fcdd4 / . / modules / gles3 / functional / es3fNegativeShaderApiTests.cpp
blob: ef89cfa246d21439b54d0fe47ab746f1a7ddf75d [file] [log] [blame]
/*-------------------------------------------------------------------------
* drawElements Quality Program OpenGL ES 3.0 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 Shader API tests.
*//*--------------------------------------------------------------------*/
#include "es3fNegativeShaderApiTests.hpp"
#include "es3fApiCase.hpp"
#include "gluShaderProgram.hpp"
#include "gluContextInfo.hpp"
#include "deUniquePtr.hpp"
#include "glwDefs.hpp"
#include "glwEnums.hpp"
using namespace glw; // GL types
namespace deqp
{
namespace gles3
{
namespace Functional
{
using tcu::TestLog;
static const char *vertexShaderSource = "#version 300 es\n"
"void main (void)\n"
"{\n"
" gl_Position = vec4(0.0);\n"
"}\n\0";
static const char *fragmentShaderSource = "#version 300 es\n"
"layout(location = 0) out mediump vec4 fragColor;"
"void main (void)\n"
"{\n"
" fragColor = vec4(0.0);\n"
"}\n\0";
static const char *uniformTestVertSource = "#version 300 es\n"
"uniform mediump vec4 vec4_v;\n"
"uniform mediump mat4 mat4_v;\n"
"void main (void)\n"
"{\n"
" gl_Position = mat4_v * vec4_v;\n"
"}\n\0";
static const char *uniformTestFragSource = "#version 300 es\n"
"uniform mediump ivec4 ivec4_f;\n"
"uniform mediump uvec4 uvec4_f;\n"
"uniform sampler2D sampler_f;\n"
"layout(location = 0) out mediump vec4 fragColor;"
"void main (void)\n"
"{\n"
" fragColor.xy = (vec4(uvec4_f) + vec4(ivec4_f)).xy;\n"
" fragColor.zw = texture(sampler_f, vec2(0.0, 0.0)).zw;\n"
"}\n\0";
static const char *uniformBlockVertSource = "#version 300 es\n"
"layout(shared) uniform Block { lowp float var; };\n"
"void main (void)\n"
"{\n"
" gl_Position = vec4(var);\n"
"}\n\0";
NegativeShaderApiTests::NegativeShaderApiTests(Context &context)
: TestCaseGroup(context, "shader", "Negative Shader API Cases")
{
}
NegativeShaderApiTests::~NegativeShaderApiTests(void)
{
}
void NegativeShaderApiTests::init(void)
{
// Shader control commands
ES3F_ADD_API_CASE(create_shader, "Invalid glCreateShader() usage", {
m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if shaderType is not an accepted value.");
glCreateShader(-1);
expectError(GL_INVALID_ENUM);
m_log << TestLog::EndSection;
});
ES3F_ADD_API_CASE(shader_source, "Invalid glShaderSource() usage", {
// \note Shader compilation must be supported.
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
glShaderSource(1, 0, 0, 0);
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if count is less than 0.");
GLuint shader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(shader, -1, 0, 0);
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
GLuint program = glCreateProgram();
glShaderSource(program, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
glDeleteProgram(program);
glDeleteShader(shader);
});
ES3F_ADD_API_CASE(compile_shader, "Invalid glCompileShader() usage", {
// \note Shader compilation must be supported.
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
glCompileShader(9);
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
GLuint program = glCreateProgram();
glCompileShader(program);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
glDeleteProgram(program);
});
ES3F_ADD_API_CASE(delete_shader, "Invalid glDeleteShader() usage", {
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
glDeleteShader(9);
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
});
ES3F_ADD_API_CASE(shader_binary, "Invalid glShaderBinary() usage", {
std::vector<int32_t> binaryFormats;
getSupportedExtensions(GL_NUM_SHADER_BINARY_FORMATS, GL_SHADER_BINARY_FORMATS, binaryFormats);
bool shaderBinarySupported = !binaryFormats.empty();
if (!shaderBinarySupported)
m_log << TestLog::Message << "// Shader binaries not supported." << TestLog::EndMessage;
else
m_log << TestLog::Message << "// Shader binaries supported" << TestLog::EndMessage;
GLuint shaders[2];
shaders[0] = glCreateShader(GL_VERTEX_SHADER);
shaders[1] = glCreateShader(GL_VERTEX_SHADER);
m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if binaryFormat is not an accepted value.");
glShaderBinary(1, &shaders[0], -1, 0, 0);
expectError(GL_INVALID_ENUM);
m_log << TestLog::EndSection;
if (shaderBinarySupported)
{
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if the data pointed to by binary does not "
"match the format specified by binaryFormat.");
const GLbyte data = 0x005F;
glShaderBinary(1, &shaders[0], binaryFormats[0], &data, 1);
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
// Error handling is different in case of SPIRV.
const bool spirvBinary = binaryFormats[0] == GL_SHADER_BINARY_FORMAT_SPIR_V;
if (spirvBinary)
m_log << TestLog::Section("", "GL_INVALID_VALUE due to invalid data pointer.");
else
m_log << TestLog::Section(
"", "GL_INVALID_OPERATION is generated if more than one of the handles in shaders refers to the "
"same type of shader, or GL_INVALID_VALUE due to invalid data pointer.");
glShaderBinary(2, &shaders[0], binaryFormats[0], 0, 0);
if (spirvBinary)
expectError(GL_INVALID_VALUE);
else
expectError(GL_INVALID_OPERATION, GL_INVALID_VALUE);
m_log << TestLog::EndSection;
}
glDeleteShader(shaders[0]);
glDeleteShader(shaders[1]);
});
ES3F_ADD_API_CASE(attach_shader, "Invalid glAttachShader() usage", {
GLuint shader1 = glCreateShader(GL_VERTEX_SHADER);
GLuint shader2 = glCreateShader(GL_VERTEX_SHADER);
GLuint program = glCreateProgram();
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
glAttachShader(shader1, shader1);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
glAttachShader(program, program);
expectError(GL_INVALID_OPERATION);
glAttachShader(shader1, program);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
m_log << TestLog::Section(
"", "GL_INVALID_VALUE is generated if either program or shader is not a value generated by OpenGL.");
glAttachShader(program, -1);
expectError(GL_INVALID_VALUE);
glAttachShader(-1, shader1);
expectError(GL_INVALID_VALUE);
glAttachShader(-1, -1);
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is already attached to program.");
glAttachShader(program, shader1);
expectError(GL_NO_ERROR);
glAttachShader(program, shader1);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
if (glu::isContextTypeES(m_context.getRenderContext().getType()))
{
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if a shader of the same type as shader is "
"already attached to program.");
glAttachShader(program, shader2);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
}
glDeleteProgram(program);
glDeleteShader(shader1);
glDeleteShader(shader2);
});
ES3F_ADD_API_CASE(detach_shader, "Invalid glDetachShader() usage", {
GLuint shader = glCreateShader(GL_VERTEX_SHADER);
GLuint program = glCreateProgram();
m_log << TestLog::Section(
"", "GL_INVALID_VALUE is generated if either program or shader is not a value generated by OpenGL.");
glDetachShader(-1, shader);
expectError(GL_INVALID_VALUE);
glDetachShader(program, -1);
expectError(GL_INVALID_VALUE);
glDetachShader(-1, -1);
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
glDetachShader(shader, shader);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
glDetachShader(program, program);
expectError(GL_INVALID_OPERATION);
glDetachShader(shader, program);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not attached to program.");
glDetachShader(program, shader);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
glDeleteProgram(program);
glDeleteShader(shader);
});
ES3F_ADD_API_CASE(link_program, "Invalid glLinkProgram() usage", {
GLuint shader = glCreateShader(GL_VERTEX_SHADER);
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
glLinkProgram(-1);
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
glLinkProgram(shader);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
glDeleteShader(shader);
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is the currently active program "
"object and transform feedback mode is active.");
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
uint32_t buf;
uint32_t tfID;
const char *tfVarying = "gl_Position";
glGenTransformFeedbacks(1, &tfID);
glGenBuffers(1, &buf);
glUseProgram(program.getProgram());
glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
glLinkProgram(program.getProgram());
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, nullptr, GL_DYNAMIC_DRAW);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
glBeginTransformFeedback(GL_TRIANGLES);
expectError(GL_NO_ERROR);
glLinkProgram(program.getProgram());
expectError(GL_INVALID_OPERATION);
glEndTransformFeedback();
glDeleteTransformFeedbacks(1, &tfID);
glDeleteBuffers(1, &buf);
expectError(GL_NO_ERROR);
m_log << TestLog::EndSection;
});
ES3F_ADD_API_CASE(use_program, "Invalid glUseProgram() usage", {
GLuint shader = glCreateShader(GL_VERTEX_SHADER);
m_log << TestLog::Section(
"", "GL_INVALID_VALUE is generated if program is neither 0 nor a value generated by OpenGL.");
glUseProgram(-1);
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
glUseProgram(shader);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
m_log << TestLog::Section(
"", "GL_INVALID_OPERATION is generated if transform feedback mode is active and not paused.");
glu::ShaderProgram program1(m_context.getRenderContext(),
glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
glu::ShaderProgram program2(m_context.getRenderContext(),
glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
uint32_t buf;
uint32_t tfID;
const char *tfVarying = "gl_Position";
glGenTransformFeedbacks(1, &tfID);
glGenBuffers(1, &buf);
glUseProgram(program1.getProgram());
glTransformFeedbackVaryings(program1.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
glLinkProgram(program1.getProgram());
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, nullptr, GL_DYNAMIC_DRAW);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
glBeginTransformFeedback(GL_TRIANGLES);
expectError(GL_NO_ERROR);
glUseProgram(program2.getProgram());
expectError(GL_INVALID_OPERATION);
glPauseTransformFeedback();
glUseProgram(program2.getProgram());
expectError(GL_NO_ERROR);
glEndTransformFeedback();
glDeleteTransformFeedbacks(1, &tfID);
glDeleteBuffers(1, &buf);
expectError(GL_NO_ERROR);
m_log << TestLog::EndSection;
glUseProgram(0);
glDeleteShader(shader);
});
ES3F_ADD_API_CASE(delete_program, "Invalid glDeleteProgram() usage", {
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
glDeleteProgram(-1);
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
});
ES3F_ADD_API_CASE(validate_program, "Invalid glValidateProgram() usage", {
GLuint shader = glCreateShader(GL_VERTEX_SHADER);
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
glValidateProgram(-1);
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
glValidateProgram(shader);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
glDeleteShader(shader);
});
if (glu::isContextTypeES(m_context.getRenderContext().getType()))
{
ES3F_ADD_API_CASE(get_program_binary, "Invalid glGetProgramBinary() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
glu::ShaderProgram programInvalid(m_context.getRenderContext(),
glu::makeVtxFragSources(vertexShaderSource, ""));
GLenum binaryFormat = -1;
GLsizei binaryLength = -1;
GLint binaryPtr = -1;
GLint bufSize = -1;
GLint linkStatus = -1;
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if bufSize is less than the size of "
"GL_PROGRAM_BINARY_LENGTH for program.");
glGetProgramiv(program.getProgram(), GL_PROGRAM_BINARY_LENGTH, &bufSize);
expectError(GL_NO_ERROR);
glGetProgramiv(program.getProgram(), GL_LINK_STATUS, &linkStatus);
m_log << TestLog::Message << "// GL_PROGRAM_BINARY_LENGTH = " << bufSize << TestLog::EndMessage;
m_log << TestLog::Message << "// GL_LINK_STATUS = " << linkStatus << TestLog::EndMessage;
expectError(GL_NO_ERROR);
glGetProgramBinary(program.getProgram(), 0, &binaryLength, &binaryFormat, &binaryPtr);
expectError(GL_INVALID_OPERATION);
if (bufSize > 0)
{
glGetProgramBinary(program.getProgram(), bufSize - 1, &binaryLength, &binaryFormat, &binaryPtr);
expectError(GL_INVALID_OPERATION);
}
m_log << TestLog::EndSection;
m_log << TestLog::Section(
"", "GL_INVALID_OPERATION is generated if GL_LINK_STATUS for the program object is false.");
glGetProgramiv(programInvalid.getProgram(), GL_PROGRAM_BINARY_LENGTH, &bufSize);
expectError(GL_NO_ERROR);
glGetProgramiv(programInvalid.getProgram(), GL_LINK_STATUS, &linkStatus);
m_log << TestLog::Message << "// GL_PROGRAM_BINARY_LENGTH = " << bufSize << TestLog::EndMessage;
m_log << TestLog::Message << "// GL_LINK_STATUS = " << linkStatus << TestLog::EndMessage;
expectError(GL_NO_ERROR);
glGetProgramBinary(programInvalid.getProgram(), bufSize, &binaryLength, &binaryFormat, &binaryPtr);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
});
}
ES3F_ADD_API_CASE(program_binary, "Invalid glProgramBinary() usage", {
glu::ShaderProgram srcProgram(m_context.getRenderContext(),
glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
GLuint dstProgram = glCreateProgram();
GLuint unusedShader = glCreateShader(GL_VERTEX_SHADER);
GLenum binaryFormat = -1;
GLsizei binaryLength = -1;
std::vector<uint8_t> binaryBuf;
GLint bufSize = -1;
GLint linkStatus = -1;
glGetProgramiv(srcProgram.getProgram(), GL_PROGRAM_BINARY_LENGTH, &bufSize);
glGetProgramiv(srcProgram.getProgram(), GL_LINK_STATUS, &linkStatus);
m_log << TestLog::Message << "// GL_PROGRAM_BINARY_LENGTH = " << bufSize << TestLog::EndMessage;
m_log << TestLog::Message << "// GL_LINK_STATUS = " << linkStatus << TestLog::EndMessage;
TCU_CHECK(bufSize >= 0);
if (bufSize > 0)
{
binaryBuf.resize(bufSize);
glGetProgramBinary(srcProgram.getProgram(), bufSize, &binaryLength, &binaryFormat, &binaryBuf[0]);
expectError(GL_NO_ERROR);
m_log << TestLog::Section(
"", "GL_INVALID_OPERATION is generated if program is not the name of an existing program object.");
glProgramBinary(unusedShader, binaryFormat, &binaryBuf[0], binaryLength);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
m_log << TestLog::Section(
"", "GL_INVALID_ENUM is generated if binaryFormat is not a value recognized by the implementation.");
glProgramBinary(dstProgram, -1, &binaryBuf[0], binaryLength);
expectError(GL_INVALID_ENUM);
m_log << TestLog::EndSection;
}
glDeleteShader(unusedShader);
glDeleteProgram(dstProgram);
});
ES3F_ADD_API_CASE(program_parameteri, "Invalid glProgramParameteri() usage", {
GLuint program = glCreateProgram();
m_log << TestLog::Section(
"", "GL_INVALID_VALUE is generated if program is not the name of an existing program object.");
glProgramParameteri(0, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
m_log << TestLog::Section("",
"GL_INVALID_ENUM is generated if pname is not GL_PROGRAM_BINARY_RETRIEVABLE_HINT.");
glProgramParameteri(program, -1, GL_TRUE);
expectError(GL_INVALID_ENUM);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if value is not GL_FALSE or GL_TRUE.");
glProgramParameteri(program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, 2);
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
glDeleteProgram(program);
});
ES3F_ADD_API_CASE(gen_samplers, "Invalid glGenSamplers() usage", {
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
GLuint sampler;
glGenSamplers(-1, &sampler);
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
});
ES3F_ADD_API_CASE(bind_sampler, "Invalid glBindSampler() usage", {
int maxTexImageUnits;
GLuint sampler;
glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxTexImageUnits);
glGenSamplers(1, &sampler);
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if unit is greater than or equal to the value of "
"GL_MAX_COMBIED_TEXTURE_IMAGE_UNITS.");
glBindSampler(maxTexImageUnits, sampler);
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not zero or a name previously "
"returned from a call to glGenSamplers.");
glBindSampler(1, -1);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
m_log << TestLog::Section(
"", "GL_INVALID_OPERATION is generated if sampler has been deleted by a call to glDeleteSamplers.");
glDeleteSamplers(1, &sampler);
glBindSampler(1, sampler);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
});
ES3F_ADD_API_CASE(delete_samplers, "Invalid glDeleteSamplers() usage", {
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
glDeleteSamplers(-1, 0);
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
});
ES3F_ADD_API_CASE(get_sampler_parameteriv, "Invalid glGetSamplerParameteriv() usage", {
int params = -1;
GLuint sampler;
glGenSamplers(1, &sampler);
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler "
"object returned from a previous call to glGenSamplers.");
glGetSamplerParameteriv(-1, GL_TEXTURE_MAG_FILTER, &params);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not an accepted value.");
glGetSamplerParameteriv(sampler, -1, &params);
expectError(GL_INVALID_ENUM);
m_log << TestLog::EndSection;
glDeleteSamplers(1, &sampler);
});
ES3F_ADD_API_CASE(get_sampler_parameterfv, "Invalid glGetSamplerParameterfv() usage", {
float params = 0.0f;
GLuint sampler;
glGenSamplers(1, &sampler);
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler "
"object returned from a previous call to glGenSamplers.");
glGetSamplerParameterfv(-1, GL_TEXTURE_MAG_FILTER, &params);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not an accepted value.");
glGetSamplerParameterfv(sampler, -1, &params);
expectError(GL_INVALID_ENUM);
m_log << TestLog::EndSection;
glDeleteSamplers(1, &sampler);
});
ES3F_ADD_API_CASE(sampler_parameteri, "Invalid glSamplerParameteri() usage", {
GLuint sampler;
glGenSamplers(1, &sampler);
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler "
"object previously returned from a call to glGenSamplers.");
glSamplerParameteri(-1, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined constant value "
"(based on the value of pname) and does not.");
glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, -1);
expectError(GL_INVALID_ENUM);
m_log << TestLog::EndSection;
glDeleteSamplers(1, &sampler);
});
ES3F_ADD_API_CASE(sampler_parameteriv, "Invalid glSamplerParameteriv() usage", {
int params = -1;
GLuint sampler;
glGenSamplers(1, &sampler);
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler "
"object previously returned from a call to glGenSamplers.");
params = GL_CLAMP_TO_EDGE;
glSamplerParameteriv(-1, GL_TEXTURE_WRAP_S, &params);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined constant value "
"(based on the value of pname) and does not.");
params = -1;
glSamplerParameteriv(sampler, GL_TEXTURE_WRAP_S, &params);
expectError(GL_INVALID_ENUM);
m_log << TestLog::EndSection;
glDeleteSamplers(1, &sampler);
});
ES3F_ADD_API_CASE(sampler_parameterf, "Invalid glSamplerParameterf() usage", {
GLuint sampler;
glGenSamplers(1, &sampler);
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler "
"object previously returned from a call to glGenSamplers.");
glSamplerParameterf(-1, GL_TEXTURE_MIN_LOD, -1000.0f);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined constant value "
"(based on the value of pname) and does not.");
glSamplerParameterf(sampler, GL_TEXTURE_WRAP_S, -1.0f);
expectError(GL_INVALID_ENUM);
m_log << TestLog::EndSection;
glDeleteSamplers(1, &sampler);
});
ES3F_ADD_API_CASE(sampler_parameterfv, "Invalid glSamplerParameterfv() usage", {
float params = 0.0f;
GLuint sampler;
glGenSamplers(1, &sampler);
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if sampler is not the name of a sampler "
"object previously returned from a call to glGenSamplers.");
params = -1000.0f;
glSamplerParameterfv(-1, GL_TEXTURE_WRAP_S, &params);
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined constant value "
"(based on the value of pname) and does not.");
params = -1.0f;
glSamplerParameterfv(sampler, GL_TEXTURE_WRAP_S, &params);
expectError(GL_INVALID_ENUM);
m_log << TestLog::EndSection;
glDeleteSamplers(1, &sampler);
});
// Shader data commands
ES3F_ADD_API_CASE(get_attrib_location, "Invalid glGetAttribLocation() usage", {
GLuint programEmpty = glCreateProgram();
GLuint shader = glCreateShader(GL_VERTEX_SHADER);
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program has not been successfully linked.");
glBindAttribLocation(programEmpty, 0, "test");
glGetAttribLocation(programEmpty, "test");
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a program or shader object.");
glUseProgram(program.getProgram());
glBindAttribLocation(program.getProgram(), 0, "test");
expectError(GL_NO_ERROR);
glGetAttribLocation(program.getProgram(), "test");
expectError(GL_NO_ERROR);
glGetAttribLocation(-2, "test");
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
glGetAttribLocation(shader, "test");
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
glUseProgram(0);
glDeleteShader(shader);
glDeleteProgram(programEmpty);
});
ES3F_ADD_API_CASE(get_uniform_location, "Invalid glGetUniformLocation() usage", {
GLuint programEmpty = glCreateProgram();
GLuint shader = glCreateShader(GL_VERTEX_SHADER);
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program has not been successfully linked.");
glGetUniformLocation(programEmpty, "test");
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
glUseProgram(program.getProgram());
glGetUniformLocation(-2, "test");
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
glGetAttribLocation(shader, "test");
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
glUseProgram(0);
glDeleteProgram(programEmpty);
glDeleteShader(shader);
});
ES3F_ADD_API_CASE(bind_attrib_location, "Invalid glBindAttribLocation() usage", {
GLuint program = glCreateProgram();
GLuint maxIndex = m_context.getContextInfo().getInt(GL_MAX_VERTEX_ATTRIBS);
GLuint shader = glCreateShader(GL_VERTEX_SHADER);
m_log << TestLog::Section(
"", "GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
glBindAttribLocation(program, maxIndex, "test");
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
m_log << TestLog::Section("",
"GL_INVALID_OPERATION is generated if name starts with the reserved prefix \"gl_\".");
glBindAttribLocation(program, maxIndex - 1, "gl_test");
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
glBindAttribLocation(-1, maxIndex - 1, "test");
expectError(GL_INVALID_VALUE);
m_log << TestLog::EndSection;
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
glBindAttribLocation(shader, maxIndex - 1, "test");
expectError(GL_INVALID_OPERATION);
m_log << TestLog::EndSection;
glDeleteProgram(program);
glDeleteShader(shader);
});
ES3F_ADD_API_CASE(uniform_block_binding, "Invalid glUniformBlockBinding() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformBlockVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
GLint maxUniformBufferBindings;
GLint numActiveUniforms = -1;
GLint numActiveBlocks = -1;
glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUniformBufferBindings);
glGetProgramiv(program.getProgram(), GL_ACTIVE_UNIFORMS, &numActiveUniforms);
glGetProgramiv(program.getProgram(), GL_ACTIVE_UNIFORM_BLOCKS, &numActiveBlocks);
m_log << TestLog::Message << "// GL_MAX_UNIFORM_BUFFER_BINDINGS = " << maxUniformBufferBindings
<< TestLog::EndMessage;
m_log << TestLog::Message << "// GL_ACTIVE_UNIFORMS = " << numActiveUniforms << TestLog::EndMessage;
m_log << TestLog::Message << "// GL_ACTIVE_UNIFORM_BLOCKS = " << numActiveBlocks << TestLog::EndMessage;
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::Section(
"", "GL_INVALID_VALUE is generated if uniformBlockIndex is not an active uniform block index of program.");
glUniformBlockBinding(program.getProgram(), -1, 0);
expectError(GL_INVALID_VALUE);
glUniformBlockBinding(program.getProgram(), 5, 0);
expectError(GL_INVALID_VALUE);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if uniformBlockBinding is greater than or "
"equal to the value of GL_MAX_UNIFORM_BUFFER_BINDINGS.");
glUniformBlockBinding(program.getProgram(), maxUniformBufferBindings, 0);
expectError(GL_INVALID_VALUE);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section(
"", "GL_INVALID_VALUE is generated if program is not the name of a program object generated by the GL.");
glUniformBlockBinding(-1, 0, 0);
expectError(GL_INVALID_VALUE);
m_log << tcu::TestLog::EndSection;
});
// glUniform*f
ES3F_ADD_API_CASE(uniformf_invalid_program, "Invalid glUniform{1234}f() usage", {
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
glUseProgram(0);
glUniform1f(-1, 0.0f);
expectError(GL_INVALID_OPERATION);
glUniform2f(-1, 0.0f, 0.0f);
expectError(GL_INVALID_OPERATION);
glUniform3f(-1, 0.0f, 0.0f, 0.0f);
expectError(GL_INVALID_OPERATION);
glUniform4f(-1, 0.0f, 0.0f, 0.0f, 0.0f);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
});
ES3F_ADD_API_CASE(uniformf_incompatible_type, "Invalid glUniform{1234}f() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
GLint vec4_v = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
GLint ivec4_f = glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
GLint uvec4_f = glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
expectError(GL_NO_ERROR);
if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
{
m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
}
m_log << tcu::TestLog::Section("",
"GL_INVALID_OPERATION is generated if the size of the uniform variable declared "
"in the shader does not match the size indicated by the glUniform command.");
glUseProgram(program.getProgram());
glUniform1f(vec4_v, 0.0f);
expectError(GL_INVALID_OPERATION);
glUniform2f(vec4_v, 0.0f, 0.0f);
expectError(GL_INVALID_OPERATION);
glUniform3f(vec4_v, 0.0f, 0.0f, 0.0f);
expectError(GL_INVALID_OPERATION);
glUniform4f(vec4_v, 0.0f, 0.0f, 0.0f, 0.0f);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section(
"", "GL_INVALID_OPERATION is generated if glUniform{1234}f is used to load a uniform variable of type int, "
"ivec2, ivec3, ivec4, unsigned int, uvec2, uvec3, uvec4.");
glUseProgram(program.getProgram());
glUniform4f(ivec4_f, 0.0f, 0.0f, 0.0f, 0.0f);
expectError(GL_INVALID_OPERATION);
glUniform4f(uvec4_f, 0.0f, 0.0f, 0.0f, 0.0f);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command "
"other than glUniform1i and glUniform1iv.");
glUseProgram(program.getProgram());
glUniform1f(sampler_f, 0.0f);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
ES3F_ADD_API_CASE(uniformf_invalid_location, "Invalid glUniform{1234}f() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform "
"location for the current program object and location is not equal to -1.");
glUseProgram(program.getProgram());
glUniform1f(-2, 0.0f);
expectError(GL_INVALID_OPERATION);
glUniform2f(-2, 0.0f, 0.0f);
expectError(GL_INVALID_OPERATION);
glUniform3f(-2, 0.0f, 0.0f, 0.0f);
expectError(GL_INVALID_OPERATION);
glUniform4f(-2, 0.0f, 0.0f, 0.0f, 0.0f);
expectError(GL_INVALID_OPERATION);
glUseProgram(program.getProgram());
glUniform1f(-1, 0.0f);
expectError(GL_NO_ERROR);
glUniform2f(-1, 0.0f, 0.0f);
expectError(GL_NO_ERROR);
glUniform3f(-1, 0.0f, 0.0f, 0.0f);
expectError(GL_NO_ERROR);
glUniform4f(-1, 0.0f, 0.0f, 0.0f, 0.0f);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
// glUniform*fv
ES3F_ADD_API_CASE(uniformfv_invalid_program, "Invalid glUniform{1234}fv() usage", {
std::vector<GLfloat> data(4);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
glUseProgram(0);
glUniform1fv(-1, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform2fv(-1, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform3fv(-1, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform4fv(-1, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
});
ES3F_ADD_API_CASE(uniformfv_incompatible_type, "Invalid glUniform{1234}fv() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
GLint vec4_v = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
GLint ivec4_f = glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
GLint uvec4_f = glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
expectError(GL_NO_ERROR);
if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
{
m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
}
std::vector<GLfloat> data(4);
m_log << tcu::TestLog::Section("",
"GL_INVALID_OPERATION is generated if the size of the uniform variable declared "
"in the shader does not match the size indicated by the glUniform command.");
glUseProgram(program.getProgram());
glUniform1fv(vec4_v, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform2fv(vec4_v, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform3fv(vec4_v, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform4fv(vec4_v, 1, &data[0]);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section(
"", "GL_INVALID_OPERATION is generated if glUniform{1234}fv is used to load a uniform variable of type "
"int, ivec2, ivec3, ivec4, unsigned int, uvec2, uvec3, uvec4.");
glUseProgram(program.getProgram());
glUniform4fv(ivec4_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform4fv(uvec4_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command "
"other than glUniform1i and glUniform1iv.");
glUseProgram(program.getProgram());
glUniform1fv(sampler_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
ES3F_ADD_API_CASE(uniformfv_invalid_location, "Invalid glUniform{1234}fv() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
expectError(GL_NO_ERROR);
std::vector<GLfloat> data(4);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform "
"location for the current program object and location is not equal to -1.");
glUseProgram(program.getProgram());
glUniform1fv(-2, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform2fv(-2, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform3fv(-2, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform4fv(-2, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUseProgram(program.getProgram());
glUniform1fv(-1, 1, &data[0]);
expectError(GL_NO_ERROR);
glUniform2fv(-1, 1, &data[0]);
expectError(GL_NO_ERROR);
glUniform3fv(-1, 1, &data[0]);
expectError(GL_NO_ERROR);
glUniform4fv(-1, 1, &data[0]);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
ES3F_ADD_API_CASE(uniformfv_invalid_count, "Invalid glUniform{1234}fv() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
GLint vec4_v = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
expectError(GL_NO_ERROR);
if (vec4_v == -1)
{
m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
}
std::vector<GLfloat> data(8);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if count is greater than 1 and the "
"indicated uniform variable is not an array variable.");
glUseProgram(program.getProgram());
glUniform1fv(vec4_v, 2, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform2fv(vec4_v, 2, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform3fv(vec4_v, 2, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform4fv(vec4_v, 2, &data[0]);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
// glUniform*i
ES3F_ADD_API_CASE(uniformi_invalid_program, "Invalid glUniform{1234}i() usage", {
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
glUseProgram(0);
glUniform1i(-1, 0);
expectError(GL_INVALID_OPERATION);
glUniform2i(-1, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform3i(-1, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform4i(-1, 0, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
});
ES3F_ADD_API_CASE(uniformi_incompatible_type, "Invalid glUniform{1234}i() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
GLint vec4_v = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
GLint ivec4_f = glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
GLint uvec4_f = glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
expectError(GL_NO_ERROR);
if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
{
m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
}
m_log << tcu::TestLog::Section("",
"GL_INVALID_OPERATION is generated if the size of the uniform variable declared "
"in the shader does not match the size indicated by the glUniform command.");
glUseProgram(program.getProgram());
glUniform1i(ivec4_f, 0);
expectError(GL_INVALID_OPERATION);
glUniform2i(ivec4_f, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform3i(ivec4_f, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform4i(ivec4_f, 0, 0, 0, 0);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section(
"", "GL_INVALID_OPERATION is generated if glUniform{1234}i is used to load a uniform variable of type "
"unsigned int, uvec2, uvec3, uvec4, or an array of these.");
glUseProgram(program.getProgram());
glUniform1i(uvec4_f, 0);
expectError(GL_INVALID_OPERATION);
glUniform2i(uvec4_f, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform3i(uvec4_f, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform4i(uvec4_f, 0, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}i is used to load a "
"uniform variable of type float, vec2, vec3, or vec4.");
glUseProgram(program.getProgram());
glUniform1i(vec4_v, 0);
expectError(GL_INVALID_OPERATION);
glUniform2i(vec4_v, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform3i(vec4_v, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform4i(vec4_v, 0, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
ES3F_ADD_API_CASE(uniformi_invalid_location, "Invalid glUniform{1234}i() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform "
"location for the current program object and location is not equal to -1.");
glUseProgram(program.getProgram());
glUniform1i(-2, 0);
expectError(GL_INVALID_OPERATION);
glUniform2i(-2, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform3i(-2, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform4i(-2, 0, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
glUseProgram(program.getProgram());
glUniform1i(-1, 0);
expectError(GL_NO_ERROR);
glUniform2i(-1, 0, 0);
expectError(GL_NO_ERROR);
glUniform3i(-1, 0, 0, 0);
expectError(GL_NO_ERROR);
glUniform4i(-1, 0, 0, 0, 0);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
// glUniform*iv
ES3F_ADD_API_CASE(uniformiv_invalid_program, "Invalid glUniform{1234}iv() usage", {
std::vector<GLint> data(4);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
glUseProgram(0);
glUniform1iv(-1, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform2iv(-1, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform3iv(-1, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform4iv(-1, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
});
ES3F_ADD_API_CASE(uniformiv_incompatible_type, "Invalid glUniform{1234}iv() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
GLint vec4_v = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
GLint ivec4_f = glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
GLint uvec4_f = glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
expectError(GL_NO_ERROR);
if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
{
m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
}
std::vector<GLint> data(4);
m_log << tcu::TestLog::Section("",
"GL_INVALID_OPERATION is generated if the size of the uniform variable declared "
"in the shader does not match the size indicated by the glUniform command.");
glUseProgram(program.getProgram());
glUniform1iv(ivec4_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform2iv(ivec4_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform3iv(ivec4_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform4iv(ivec4_f, 1, &data[0]);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}iv is used to load a "
"uniform variable of type float, vec2, vec3, or vec4.");
glUseProgram(program.getProgram());
glUniform1iv(vec4_v, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform2iv(vec4_v, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform3iv(vec4_v, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform4iv(vec4_v, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}iv is used to load a "
"uniform variable of type unsigned int, uvec2, uvec3 or uvec4.");
glUseProgram(program.getProgram());
glUniform1iv(uvec4_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform2iv(uvec4_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform3iv(uvec4_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform4iv(uvec4_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
ES3F_ADD_API_CASE(uniformiv_invalid_location, "Invalid glUniform{1234}iv() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
expectError(GL_NO_ERROR);
std::vector<GLint> data(4);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform "
"location for the current program object and location is not equal to -1.");
glUseProgram(program.getProgram());
glUniform1iv(-2, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform2iv(-2, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform3iv(-2, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform4iv(-2, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUseProgram(program.getProgram());
glUniform1iv(-1, 1, &data[0]);
expectError(GL_NO_ERROR);
glUniform2iv(-1, 1, &data[0]);
expectError(GL_NO_ERROR);
glUniform3iv(-1, 1, &data[0]);
expectError(GL_NO_ERROR);
glUniform4iv(-1, 1, &data[0]);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
ES3F_ADD_API_CASE(uniformiv_invalid_count, "Invalid glUniform{1234}iv() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
GLint ivec4_f = glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
expectError(GL_NO_ERROR);
if (ivec4_f == -1)
{
m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
}
std::vector<GLint> data(8);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if count is greater than 1 and the "
"indicated uniform variable is not an array variable.");
glUseProgram(program.getProgram());
glUniform1iv(ivec4_f, 2, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform2iv(ivec4_f, 2, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform3iv(ivec4_f, 2, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform4iv(ivec4_f, 2, &data[0]);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
// glUniform{1234}ui
ES3F_ADD_API_CASE(uniformui_invalid_program, "Invalid glUniform{234}ui() usage", {
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
glUseProgram(0);
glUniform1ui(-1, 0);
expectError(GL_INVALID_OPERATION);
glUniform2ui(-1, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform3ui(-1, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform4ui(-1, 0, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
});
ES3F_ADD_API_CASE(uniformui_incompatible_type, "Invalid glUniform{1234}ui() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
GLint vec4_v = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
GLint ivec4_f = glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
GLint uvec4_f = glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
expectError(GL_NO_ERROR);
if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
{
m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
}
m_log << tcu::TestLog::Section("",
"GL_INVALID_OPERATION is generated if the size of the uniform variable declared "
"in the shader does not match the size indicated by the glUniform command.");
glUseProgram(program.getProgram());
glUniform1ui(uvec4_f, 0);
expectError(GL_INVALID_OPERATION);
glUniform2ui(uvec4_f, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform3ui(uvec4_f, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform4ui(uvec4_f, 0, 0, 0, 0);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}i is used to load a "
"uniform variable of type int, ivec2, ivec3, ivec4, or an array of these.");
glUseProgram(program.getProgram());
glUniform1ui(ivec4_f, 0);
expectError(GL_INVALID_OPERATION);
glUniform2ui(ivec4_f, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform3ui(ivec4_f, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform4ui(ivec4_f, 0, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}i is used to load a "
"uniform variable of type float, vec2, vec3, or vec4.");
glUseProgram(program.getProgram());
glUniform1ui(vec4_v, 0);
expectError(GL_INVALID_OPERATION);
glUniform2ui(vec4_v, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform3ui(vec4_v, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform4ui(vec4_v, 0, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command "
"other than glUniform1i and glUniform1iv.");
glUseProgram(program.getProgram());
glUniform1ui(sampler_f, 0);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
ES3F_ADD_API_CASE(uniformui_invalid_location, "Invalid glUniform{1234}ui() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform "
"location for the current program object and location is not equal to -1.");
glUseProgram(program.getProgram());
glUniform1i(-2, 0);
expectError(GL_INVALID_OPERATION);
glUniform2i(-2, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform3i(-2, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
glUniform4i(-2, 0, 0, 0, 0);
expectError(GL_INVALID_OPERATION);
glUseProgram(program.getProgram());
glUniform1i(-1, 0);
expectError(GL_NO_ERROR);
glUniform2i(-1, 0, 0);
expectError(GL_NO_ERROR);
glUniform3i(-1, 0, 0, 0);
expectError(GL_NO_ERROR);
glUniform4i(-1, 0, 0, 0, 0);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
// glUniform{1234}uiv
ES3F_ADD_API_CASE(uniformuiv_invalid_program, "Invalid glUniform{234}uiv() usage", {
std::vector<GLuint> data(4);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
glUseProgram(0);
glUniform1uiv(-1, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform2uiv(-1, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform3uiv(-1, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform4uiv(-1, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
});
ES3F_ADD_API_CASE(uniformuiv_incompatible_type, "Invalid glUniform{1234}uiv() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
GLint vec4_v = glGetUniformLocation(program.getProgram(), "vec4_v"); // vec4
GLint ivec4_f = glGetUniformLocation(program.getProgram(), "ivec4_f"); // ivec4
GLint uvec4_f = glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
expectError(GL_NO_ERROR);
if (vec4_v == -1 || ivec4_f == -1 || uvec4_f == -1 || sampler_f == -1)
{
m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
}
std::vector<GLuint> data(4);
m_log << tcu::TestLog::Section("",
"GL_INVALID_OPERATION is generated if the size of the uniform variable declared "
"in the shader does not match the size indicated by the glUniform command.");
glUseProgram(program.getProgram());
glUniform1uiv(uvec4_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform2uiv(uvec4_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform3uiv(uvec4_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform4uiv(uvec4_f, 1, &data[0]);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}uiv is used to load a "
"uniform variable of type float, vec2, vec3, or vec4.");
glUseProgram(program.getProgram());
glUniform1uiv(vec4_v, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform2uiv(vec4_v, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform3uiv(vec4_v, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform4uiv(vec4_v, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if glUniform{1234}uiv is used to load a "
"uniform variable of type int, ivec2, ivec3 or ivec4.");
glUseProgram(program.getProgram());
glUniform1uiv(ivec4_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform2uiv(ivec4_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform3uiv(ivec4_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform4uiv(ivec4_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command "
"other than glUniform1i and glUniform1iv.");
glUseProgram(program.getProgram());
glUniform1uiv(sampler_f, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
ES3F_ADD_API_CASE(uniformuiv_invalid_location, "Invalid glUniform{1234}uiv() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
expectError(GL_NO_ERROR);
std::vector<GLuint> data(4);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform "
"location for the current program object and location is not equal to -1.");
glUseProgram(program.getProgram());
glUniform1uiv(-2, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform2uiv(-2, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform3uiv(-2, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform4uiv(-2, 1, &data[0]);
expectError(GL_INVALID_OPERATION);
glUseProgram(program.getProgram());
glUniform1uiv(-1, 1, &data[0]);
expectError(GL_NO_ERROR);
glUniform2uiv(-1, 1, &data[0]);
expectError(GL_NO_ERROR);
glUniform3uiv(-1, 1, &data[0]);
expectError(GL_NO_ERROR);
glUniform4uiv(-1, 1, &data[0]);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
ES3F_ADD_API_CASE(uniformuiv_invalid_count, "Invalid glUniform{1234}uiv() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
int uvec4_f = glGetUniformLocation(program.getProgram(), "uvec4_f"); // uvec4
expectError(GL_NO_ERROR);
if (uvec4_f == -1)
{
m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
}
std::vector<GLuint> data(8);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if count is greater than 1 and the "
"indicated uniform variable is not an array variable.");
glUseProgram(program.getProgram());
glUniform1uiv(uvec4_f, 2, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform2uiv(uvec4_f, 2, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform3uiv(uvec4_f, 2, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniform4uiv(uvec4_f, 2, &data[0]);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
// glUniformMatrix*fv
ES3F_ADD_API_CASE(uniform_matrixfv_invalid_program, "Invalid glUniformMatrix{234}fv() usage", {
std::vector<GLfloat> data(16);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if there is no current program object.");
glUseProgram(0);
glUniformMatrix2fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix3fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix4fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix2x3fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix3x2fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix2x4fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix4x2fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix3x4fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix4x3fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
});
ES3F_ADD_API_CASE(uniform_matrixfv_incompatible_type, "Invalid glUniformMatrix{234}fv() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
GLint mat4_v = glGetUniformLocation(program.getProgram(), "mat4_v"); // mat4
GLint sampler_f = glGetUniformLocation(program.getProgram(), "sampler_f"); // sampler2D
expectError(GL_NO_ERROR);
if (mat4_v == -1 || sampler_f == -1)
{
m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
}
std::vector<GLfloat> data(16);
m_log << tcu::TestLog::Section("",
"GL_INVALID_OPERATION is generated if the size of the uniform variable declared "
"in the shader does not match the size indicated by the glUniform command.");
glUseProgram(program.getProgram());
glUniformMatrix2fv(mat4_v, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix3fv(mat4_v, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix4fv(mat4_v, 1, GL_FALSE, &data[0]);
expectError(GL_NO_ERROR);
glUniformMatrix2x3fv(mat4_v, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix3x2fv(mat4_v, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix2x4fv(mat4_v, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix4x2fv(mat4_v, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix3x4fv(mat4_v, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix4x3fv(mat4_v, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if a sampler is loaded using a command "
"other than glUniform1i and glUniform1iv.");
glUseProgram(program.getProgram());
glUniformMatrix2fv(sampler_f, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix3fv(sampler_f, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix4fv(sampler_f, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix2x3fv(sampler_f, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix3x2fv(sampler_f, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix2x4fv(sampler_f, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix4x2fv(sampler_f, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix3x4fv(sampler_f, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix4x3fv(sampler_f, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
ES3F_ADD_API_CASE(uniform_matrixfv_invalid_location, "Invalid glUniformMatrix{234}fv() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
expectError(GL_NO_ERROR);
std::vector<GLfloat> data(16);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if location is an invalid uniform "
"location for the current program object and location is not equal to -1.");
glUseProgram(program.getProgram());
glUniformMatrix2fv(-2, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix3fv(-2, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix4fv(-2, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix2x3fv(-2, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix3x2fv(-2, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix2x4fv(-2, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix4x2fv(-2, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix3x4fv(-2, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix4x3fv(-2, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUseProgram(program.getProgram());
glUniformMatrix2fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_NO_ERROR);
glUniformMatrix3fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_NO_ERROR);
glUniformMatrix4fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_NO_ERROR);
glUniformMatrix2x3fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_NO_ERROR);
glUniformMatrix3x2fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_NO_ERROR);
glUniformMatrix2x4fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_NO_ERROR);
glUniformMatrix4x2fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_NO_ERROR);
glUniformMatrix3x4fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_NO_ERROR);
glUniformMatrix4x3fv(-1, 1, GL_FALSE, &data[0]);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
ES3F_ADD_API_CASE(uniform_matrixfv_invalid_count, "Invalid glUniformMatrix{234}fv() usage", {
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
glUseProgram(program.getProgram());
GLint mat4_v = glGetUniformLocation(program.getProgram(), "mat4_v"); // mat4
expectError(GL_NO_ERROR);
if (mat4_v == -1)
{
m_log << TestLog::Message << "// ERROR: Failed to retrieve uniform location" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
}
std::vector<GLfloat> data(32);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if count is greater than 1 and the "
"indicated uniform variable is not an array variable.");
glUseProgram(program.getProgram());
glUniformMatrix2fv(mat4_v, 2, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix3fv(mat4_v, 2, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix4fv(mat4_v, 2, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix2x3fv(mat4_v, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix3x2fv(mat4_v, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix2x4fv(mat4_v, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix4x2fv(mat4_v, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix3x4fv(mat4_v, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
glUniformMatrix4x3fv(mat4_v, 1, GL_FALSE, &data[0]);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
});
// Transform feedback
ES3F_ADD_API_CASE(gen_transform_feedbacks, "Invalid glGenTransformFeedbacks() usage", {
m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
GLuint id;
glGenTransformFeedbacks(-1, &id);
expectError(GL_INVALID_VALUE);
m_log << tcu::TestLog::EndSection;
});
ES3F_ADD_API_CASE(bind_transform_feedback, "Invalid glBindTransformFeedback() usage", {
GLuint tfID[2];
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
uint32_t buf;
const char *tfVarying = "gl_Position";
glGenBuffers(1, &buf);
glGenTransformFeedbacks(2, tfID);
m_log << tcu::TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_TRANSFORM_FEEDBACK.");
glBindTransformFeedback(-1, tfID[0]);
expectError(GL_INVALID_ENUM);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("",
"GL_INVALID_OPERATION is generated if the transform feedback operation is "
"active on the currently bound transform feedback object, and is not paused.");
glUseProgram(program.getProgram());
glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
glLinkProgram(program.getProgram());
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID[0]);
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, nullptr, GL_DYNAMIC_DRAW);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
glBeginTransformFeedback(GL_TRIANGLES);
expectError(GL_NO_ERROR);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID[1]);
expectError(GL_INVALID_OPERATION);
glEndTransformFeedback();
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::EndSection;
glUseProgram(0);
glDeleteBuffers(1, &buf);
glDeleteTransformFeedbacks(2, tfID);
expectError(GL_NO_ERROR);
});
ES3F_ADD_API_CASE(delete_transform_feedbacks, "Invalid glDeleteTransformFeedbacks() usage", {
GLuint id;
glGenTransformFeedbacks(1, &id);
m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
glDeleteTransformFeedbacks(-1, &id);
expectError(GL_INVALID_VALUE);
m_log << tcu::TestLog::EndSection;
glDeleteTransformFeedbacks(1, &id);
});
ES3F_ADD_API_CASE(begin_transform_feedback, "Invalid glBeginTransformFeedback() usage", {
GLuint tfID[2];
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
uint32_t buf;
const char *tfVarying = "gl_Position";
glGenBuffers(1, &buf);
glGenTransformFeedbacks(2, tfID);
glUseProgram(program.getProgram());
glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
glLinkProgram(program.getProgram());
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID[0]);
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, nullptr, GL_DYNAMIC_DRAW);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::Section(
"", "GL_INVALID_ENUM is generated if primitiveMode is not one of GL_POINTS, GL_LINES, or GL_TRIANGLES.");
glBeginTransformFeedback(-1);
expectError(GL_INVALID_ENUM);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("",
"GL_INVALID_OPERATION is generated if transform feedback is already active.");
glBeginTransformFeedback(GL_TRIANGLES);
expectError(GL_NO_ERROR);
glBeginTransformFeedback(GL_POINTS);
expectError(GL_INVALID_OPERATION);
glEndTransformFeedback();
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if any binding point used in transform "
"feedback mode does not have a buffer object bound.");
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
glBeginTransformFeedback(GL_TRIANGLES);
expectError(GL_INVALID_OPERATION);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if no binding points would be used "
"because no program object is active.");
glUseProgram(0);
glBeginTransformFeedback(GL_TRIANGLES);
expectError(GL_INVALID_OPERATION);
glUseProgram(program.getProgram());
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("",
"GL_INVALID_OPERATION is generated if no binding points would be used because "
"the active program object has specified no varying variables to record.");
glTransformFeedbackVaryings(program.getProgram(), 0, 0, GL_INTERLEAVED_ATTRIBS);
glLinkProgram(program.getProgram());
expectError(GL_NO_ERROR);
glBeginTransformFeedback(GL_TRIANGLES);
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
glDeleteBuffers(1, &buf);
glDeleteTransformFeedbacks(2, tfID);
expectError(GL_NO_ERROR);
});
ES3F_ADD_API_CASE(pause_transform_feedback, "Invalid glPauseTransformFeedback() usage", {
GLuint tfID[2];
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
uint32_t buf;
const char *tfVarying = "gl_Position";
glGenBuffers(1, &buf);
glGenTransformFeedbacks(2, tfID);
glUseProgram(program.getProgram());
glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
glLinkProgram(program.getProgram());
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID[0]);
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, nullptr, GL_DYNAMIC_DRAW);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the currently bound transform "
"feedback object is not active or is paused.");
glPauseTransformFeedback();
expectError(GL_INVALID_OPERATION);
glBeginTransformFeedback(GL_TRIANGLES);
glPauseTransformFeedback();
expectError(GL_NO_ERROR);
glPauseTransformFeedback();
expectError(GL_INVALID_OPERATION);
m_log << tcu::TestLog::EndSection;
glEndTransformFeedback();
glDeleteBuffers(1, &buf);
glDeleteTransformFeedbacks(2, tfID);
expectError(GL_NO_ERROR);
});
ES3F_ADD_API_CASE(resume_transform_feedback, "Invalid glResumeTransformFeedback() usage", {
GLuint tfID[2];
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
uint32_t buf;
const char *tfVarying = "gl_Position";
glGenBuffers(1, &buf);
glGenTransformFeedbacks(2, tfID);
glUseProgram(program.getProgram());
glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
glLinkProgram(program.getProgram());
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID[0]);
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, nullptr, GL_DYNAMIC_DRAW);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the currently bound transform "
"feedback object is not active or is not paused.");
glResumeTransformFeedback();
expectError(GL_INVALID_OPERATION);
glBeginTransformFeedback(GL_TRIANGLES);
glResumeTransformFeedback();
expectError(GL_INVALID_OPERATION);
glPauseTransformFeedback();
glResumeTransformFeedback();
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::EndSection;
glEndTransformFeedback();
glDeleteBuffers(1, &buf);
glDeleteTransformFeedbacks(2, tfID);
expectError(GL_NO_ERROR);
});
ES3F_ADD_API_CASE(end_transform_feedback, "Invalid glEndTransformFeedback() usage", {
GLuint tfID;
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
uint32_t buf;
const char *tfVarying = "gl_Position";
glGenBuffers(1, &buf);
glGenTransformFeedbacks(1, &tfID);
glUseProgram(program.getProgram());
glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
glLinkProgram(program.getProgram());
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, nullptr, GL_DYNAMIC_DRAW);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback is not active.");
glEndTransformFeedback();
expectError(GL_INVALID_OPERATION);
glBeginTransformFeedback(GL_TRIANGLES);
glEndTransformFeedback();
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::EndSection;
glDeleteBuffers(1, &buf);
glDeleteTransformFeedbacks(1, &tfID);
expectError(GL_NO_ERROR);
});
ES3F_ADD_API_CASE(get_transform_feedback_varying, "Invalid glGetTransformFeedbackVarying() usage", {
GLuint tfID;
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
glu::ShaderProgram programInvalid(m_context.getRenderContext(),
glu::makeVtxFragSources(vertexShaderSource, ""));
const char *tfVarying = "gl_Position";
int maxTransformFeedbackVaryings = 0;
GLsizei length;
GLsizei size;
GLenum type;
char name[32];
glGenTransformFeedbacks(1, &tfID);
glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
expectError(GL_NO_ERROR);
glLinkProgram(program.getProgram());
expectError(GL_NO_ERROR);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::Section("",
"GL_INVALID_VALUE is generated if program is not the name of a program object.");
glGetTransformFeedbackVarying(-1, 0, 32, &length, &size, &type, &name[0]);
expectError(GL_INVALID_VALUE);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if index is greater or equal to the value of "
"GL_TRANSFORM_FEEDBACK_VARYINGS.");
glGetProgramiv(program.getProgram(), GL_TRANSFORM_FEEDBACK_VARYINGS, &maxTransformFeedbackVaryings);
glGetTransformFeedbackVarying(program.getProgram(), maxTransformFeedbackVaryings, 32, &length, &size, &type,
&name[0]);
expectError(GL_INVALID_VALUE);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section(
"", "GL_INVALID_OPERATION or GL_INVALID_VALUE is generated program has not been linked.");
glGetTransformFeedbackVarying(programInvalid.getProgram(), 0, 32, &length, &size, &type, &name[0]);
expectError(GL_INVALID_OPERATION, GL_INVALID_VALUE);
m_log << tcu::TestLog::EndSection;
glDeleteTransformFeedbacks(1, &tfID);
expectError(GL_NO_ERROR);
});
ES3F_ADD_API_CASE(transform_feedback_varyings, "Invalid glTransformFeedbackVaryings() usage", {
GLuint tfID;
glu::ShaderProgram program(m_context.getRenderContext(),
glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
const char *tfVarying = "gl_Position";
GLint maxTransformFeedbackSeparateAttribs = 0;
glGenTransformFeedbacks(1, &tfID);
expectError(GL_NO_ERROR);
m_log << tcu::TestLog::Section("",
"GL_INVALID_VALUE is generated if program is not the name of a program object.");
glTransformFeedbackVaryings(0, 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
expectError(GL_INVALID_VALUE);
m_log << tcu::TestLog::EndSection;
m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if bufferMode is GL_SEPARATE_ATTRIBS and "
"count is greater than GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS.");
glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxTransformFeedbackSeparateAttribs);
glTransformFeedbackVaryings(program.getProgram(), maxTransformFeedbackSeparateAttribs + 1, &tfVarying,
GL_SEPARATE_ATTRIBS);
expectError(GL_INVALID_VALUE);
m_log << tcu::TestLog::EndSection;
glDeleteTransformFeedbacks(1, &tfID);
expectError(GL_NO_ERROR);
});
}
} // namespace Functional
} // namespace gles3
} // namespace deqp