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.
1022 lines
41 KiB
1022 lines
41 KiB
/*-------------------------------------------------------------------------
|
|
* drawElements Quality Program OpenGL ES 2.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 "es2fNegativeShaderApiTests.hpp"
|
|
#include "es2fApiCase.hpp"
|
|
#include "gluShaderProgram.hpp"
|
|
#include "gluContextInfo.hpp"
|
|
|
|
#include "glwDefs.hpp"
|
|
#include "glwEnums.hpp"
|
|
|
|
#include "deStringUtil.hpp"
|
|
|
|
using namespace glw; // GL types
|
|
|
|
namespace deqp
|
|
{
|
|
namespace gles2
|
|
{
|
|
namespace Functional
|
|
{
|
|
|
|
static const char* vertexShaderSource = "void main (void) { gl_Position = vec4(0.0); }\n\0";
|
|
static const char* fragmentShaderSource = "void main (void) { gl_FragColor = vec4(0.0); }\n\0";
|
|
|
|
static const char* uniformTestVertSource = "uniform mediump vec4 vTest;\n"
|
|
"uniform mediump mat4 vMatrix;\n"
|
|
"void main (void)\n"
|
|
"{\n"
|
|
" gl_Position = vMatrix * vTest;\n"
|
|
"}\n\0";
|
|
static const char* uniformTestFragSource = "uniform mediump ivec4 fTest;\n"
|
|
"uniform sampler2D fSampler;\n"
|
|
"void main (void)\n"
|
|
"{\n"
|
|
" gl_FragColor.xy = vec4(fTest).xy;\n"
|
|
" gl_FragColor.zw = texture2D(fSampler, vec2(0.0, 0.0)).zw;\n"
|
|
"}\n\0";
|
|
|
|
using tcu::TestLog;
|
|
|
|
NegativeShaderApiTests::NegativeShaderApiTests (Context& context)
|
|
: TestCaseGroup(context, "shader", "Negative Shader API Cases")
|
|
{
|
|
}
|
|
|
|
NegativeShaderApiTests::~NegativeShaderApiTests (void)
|
|
{
|
|
}
|
|
|
|
void NegativeShaderApiTests::init (void)
|
|
{
|
|
ES2F_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;
|
|
});
|
|
ES2F_ADD_API_CASE(shader_source, "Invalid glShaderSource() usage",
|
|
{
|
|
GLboolean shaderCompilerSupported;
|
|
glGetBooleanv(GL_SHADER_COMPILER, &shaderCompilerSupported);
|
|
if (!shaderCompilerSupported)
|
|
m_log << TestLog::Message << "// Shader compiler not supported, always expect GL_INVALID_OPERATION" << TestLog::EndMessage;
|
|
else
|
|
m_log << TestLog::Message << "// Shader compiler supported" << TestLog::EndMessage;
|
|
|
|
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
|
|
glShaderSource(1, 0, 0, 0);
|
|
expectError(shaderCompilerSupported ? GL_INVALID_VALUE : GL_INVALID_OPERATION);
|
|
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(shaderCompilerSupported ? GL_INVALID_VALUE : GL_INVALID_OPERATION);
|
|
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);
|
|
});
|
|
ES2F_ADD_API_CASE(compile_shader, "Invalid glCompileShader() usage",
|
|
{
|
|
GLboolean shaderCompilerSupported;
|
|
glGetBooleanv(GL_SHADER_COMPILER, &shaderCompilerSupported);
|
|
if (!shaderCompilerSupported)
|
|
m_log << TestLog::Message << "// Shader compiler not supported, always expect GL_INVALID_OPERATION" << TestLog::EndMessage;
|
|
else
|
|
m_log << TestLog::Message << "// Shader compiler supported" << TestLog::EndMessage;
|
|
|
|
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
|
|
glCompileShader(9);
|
|
expectError(shaderCompilerSupported ? GL_INVALID_VALUE : GL_INVALID_OPERATION);
|
|
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);
|
|
});
|
|
ES2F_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;
|
|
});
|
|
ES2F_ADD_API_CASE(shader_binary, "Invalid glShaderBinary() usage",
|
|
{
|
|
std::vector<deInt32> binaryFormats;
|
|
getSupportedExtensions(GL_NUM_SHADER_BINARY_FORMATS, GL_SHADER_BINARY_FORMATS, binaryFormats);
|
|
deBool 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);
|
|
GLuint program = glCreateProgram();
|
|
|
|
m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if binaryformat is not a supported format returned in GL_SHADER_BINARY_FORMATS.");
|
|
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 any value in shaders is not a value generated by OpenGL.");
|
|
shaders[0] = 137;
|
|
glShaderBinary(1, &shaders[0], binaryFormats[0], 0, 0);
|
|
expectError(shaderBinarySupported ? GL_INVALID_VALUE : GL_INVALID_OPERATION);
|
|
m_log << TestLog::EndSection;
|
|
|
|
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n or length is negative.");
|
|
shaders[0] = glCreateShader(GL_VERTEX_SHADER);
|
|
glShaderBinary(-1, &shaders[0], binaryFormats[0], 0, 0);
|
|
expectError(GL_INVALID_OPERATION, GL_INVALID_VALUE);
|
|
glShaderBinary(1, &shaders[0], binaryFormats[0], 0, -1);
|
|
expectError(GL_INVALID_OPERATION, GL_INVALID_VALUE);
|
|
m_log << TestLog::EndSection;
|
|
|
|
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if any value in shaders is not a shader object.");
|
|
glShaderBinary(1, &program, binaryFormats[0], 0, 0);
|
|
expectError(GL_INVALID_OPERATION, GL_INVALID_VALUE);
|
|
m_log << TestLog::EndSection;
|
|
|
|
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if there is more than one vertex shader object handle or more than one fragment shader object handle in shaders.");
|
|
shaders[0] = glCreateShader(GL_VERTEX_SHADER);
|
|
shaders[1] = glCreateShader(GL_VERTEX_SHADER);
|
|
glShaderBinary(2, &shaders[0], binaryFormats[0], 0, 1);
|
|
expectError(GL_INVALID_OPERATION, GL_INVALID_VALUE);
|
|
m_log << TestLog::EndSection;
|
|
}
|
|
|
|
glDeleteShader(shaders[0]);
|
|
glDeleteShader(shaders[1]);
|
|
glDeleteProgram(program);
|
|
|
|
// \note: The format of the data pointed to by binary does not match binaryformat.
|
|
});
|
|
ES2F_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, or if another shader object of the same type as shader is already attached to program.");
|
|
glAttachShader(program, shader1);
|
|
expectError(GL_NO_ERROR);
|
|
glAttachShader(program, shader1);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glAttachShader(program, shader2);
|
|
expectError(GL_INVALID_OPERATION);
|
|
m_log << TestLog::EndSection;
|
|
|
|
glDeleteProgram(program);
|
|
glDeleteShader(shader1);
|
|
glDeleteShader(shader2);
|
|
});
|
|
ES2F_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);
|
|
});
|
|
ES2F_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);
|
|
});
|
|
ES2F_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;
|
|
|
|
glUseProgram(0);
|
|
glDeleteShader(shader);
|
|
});
|
|
ES2F_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;
|
|
});
|
|
ES2F_ADD_API_CASE(get_active_attrib, "Invalid glGetActiveAttrib() usage",
|
|
{
|
|
GLuint shader = glCreateShader(GL_VERTEX_SHADER);
|
|
glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
|
|
glUseProgram(program.getProgram());
|
|
|
|
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
|
|
glGetActiveAttrib(-1, 0, 0, 0, 0, 0, 0);
|
|
expectError(GL_INVALID_VALUE);
|
|
m_log << TestLog::EndSection;
|
|
|
|
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
|
|
glGetActiveAttrib(shader, 0, 0, 0, 0, 0, 0);
|
|
expectError(GL_INVALID_OPERATION);
|
|
m_log << TestLog::EndSection;
|
|
|
|
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if index is greater than or equal to the number of active attribute variables in program.");
|
|
glGetActiveAttrib(program.getProgram(), 0, 0, 0, 0, 0, 0);
|
|
expectError(GL_INVALID_VALUE);
|
|
m_log << TestLog::EndSection;
|
|
|
|
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if bufSize is less than 0.");
|
|
glGetActiveAttrib(program.getProgram(), 0, -1, 0, 0, 0, 0);
|
|
expectError(GL_INVALID_VALUE);
|
|
m_log << TestLog::EndSection;
|
|
|
|
glUseProgram(0);
|
|
glDeleteShader(shader);
|
|
});
|
|
ES2F_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);
|
|
});
|
|
ES2F_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);
|
|
});
|
|
ES2F_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);
|
|
});
|
|
ES2F_ADD_API_CASE(get_active_uniform, "Invalid glGetActiveUniform() usage",
|
|
{
|
|
GLuint shader = glCreateShader(GL_VERTEX_SHADER);
|
|
glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
|
|
|
|
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
|
|
glGetActiveUniform(-1, 0, 0, 0, 0, 0, 0);
|
|
expectError(GL_INVALID_VALUE);
|
|
m_log << TestLog::EndSection;
|
|
|
|
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
|
|
glGetActiveUniform(shader, 0, 0, 0, 0, 0, 0);
|
|
expectError(GL_INVALID_OPERATION);
|
|
m_log << TestLog::EndSection;
|
|
|
|
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if index is greater than or equal to the number of active attribute variables in program.");
|
|
glUseProgram(program.getProgram());
|
|
glGetActiveUniform(program.getProgram(), 5, 0, 0, 0, 0, 0);
|
|
expectError(GL_INVALID_VALUE);
|
|
m_log << TestLog::EndSection;
|
|
|
|
m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if bufSize is less than 0.");
|
|
glGetActiveUniform(program.getProgram(), 0, -1, 0, 0, 0, 0);
|
|
expectError(GL_INVALID_VALUE);
|
|
m_log << TestLog::EndSection;
|
|
|
|
glUseProgram(0);
|
|
glDeleteShader(shader);
|
|
});
|
|
ES2F_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);
|
|
});
|
|
|
|
ES2F_ADD_API_CASE(release_shader_compiler, "Invalid glReleaseShaderCompiler() usage",
|
|
{
|
|
GLboolean shaderCompilerSupported;
|
|
glGetBooleanv(GL_SHADER_COMPILER, &shaderCompilerSupported);
|
|
|
|
m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if a shader compiler is not supported.");
|
|
glReleaseShaderCompiler();
|
|
expectError(shaderCompilerSupported ? GL_NONE : GL_INVALID_OPERATION);
|
|
m_log << TestLog::EndSection;
|
|
});
|
|
|
|
// glUniform*f
|
|
|
|
ES2F_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;
|
|
});
|
|
ES2F_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 vUnif = glGetUniformLocation(program.getProgram(), "vTest"); // vec4
|
|
GLint fUnif = glGetUniformLocation(program.getProgram(), "fTest"); // ivec4
|
|
GLint fSampler = glGetUniformLocation(program.getProgram(), "fSampler"); // sampler2D
|
|
|
|
if (vUnif == -1 || fUnif == -1 || fSampler == -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(vUnif, 0.0f);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform2f(vUnif, 0.0f, 0.0f);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform3f(vUnif, 0.0f, 0.0f, 0.0f);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform4f(vUnif, 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 one of the floating-point variants of this function is used to load a uniform variable of type int, ivec2, ivec3, or ivec4.");
|
|
glUseProgram(program.getProgram());
|
|
glUniform4f(fUnif, 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(fSampler, 0.0f);
|
|
expectError(GL_INVALID_OPERATION);
|
|
m_log << tcu::TestLog::EndSection;
|
|
|
|
glUseProgram(0);
|
|
});
|
|
ES2F_ADD_API_CASE(uniformf_invalid_location, "Invalid glUniform{1234}f() usage",
|
|
{
|
|
glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
|
|
glUseProgram(program.getProgram());
|
|
|
|
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
|
|
|
|
ES2F_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;
|
|
});
|
|
ES2F_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 vUnif = glGetUniformLocation(program.getProgram(), "vTest"); // vec4
|
|
GLint fUnif = glGetUniformLocation(program.getProgram(), "fTest"); // ivec4
|
|
GLint fSampler = glGetUniformLocation(program.getProgram(), "fSampler"); // sampler2D
|
|
|
|
if (vUnif == -1 || fUnif == -1 || fSampler == -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(vUnif, 1, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform2fv(vUnif, 1, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform3fv(vUnif, 1, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform4fv(vUnif, 1, &data[0]);
|
|
expectError(GL_NO_ERROR);
|
|
m_log << tcu::TestLog::EndSection;
|
|
|
|
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if one of the floating-point variants of this function is used to load a uniform variable of type int, ivec2, ivec3, or ivec4.");
|
|
glUseProgram(program.getProgram());
|
|
glUniform4fv(fUnif, 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(fSampler, 1, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
m_log << tcu::TestLog::EndSection;
|
|
|
|
glUseProgram(0);
|
|
});
|
|
ES2F_ADD_API_CASE(uniformfv_invalid_location, "Invalid glUniform{1234}fv() usage",
|
|
{
|
|
glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
|
|
glUseProgram(program.getProgram());
|
|
|
|
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);
|
|
});
|
|
ES2F_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 vUnif = glGetUniformLocation(program.getProgram(), "vTest"); // vec4
|
|
|
|
if (vUnif == -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(vUnif, 2, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform2fv(vUnif, 2, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform3fv(vUnif, 2, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform4fv(vUnif, 2, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
m_log << tcu::TestLog::EndSection;
|
|
|
|
glUseProgram(0);
|
|
});
|
|
|
|
// glUniform*i
|
|
|
|
ES2F_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;
|
|
});
|
|
ES2F_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 vUnif = glGetUniformLocation(program.getProgram(), "vTest"); // vec4
|
|
GLint fUnif = glGetUniformLocation(program.getProgram(), "fTest"); // ivec4
|
|
GLint fSampler = glGetUniformLocation(program.getProgram(), "fSampler"); // sampler2D
|
|
|
|
if (vUnif == -1 || fUnif == -1 || fSampler == -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(fUnif, 0);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform2i(fUnif, 0, 0);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform3i(fUnif, 0, 0, 0);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform4i(fUnif, 0, 0, 0, 0);
|
|
expectError(GL_NO_ERROR);
|
|
m_log << tcu::TestLog::EndSection;
|
|
|
|
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if one of the integer variants of this function is used to load a uniform variable of type float, vec2, vec3, or vec4.");
|
|
glUseProgram(program.getProgram());
|
|
glUniform4i(vUnif, 0, 0, 0, 0);
|
|
expectError(GL_INVALID_OPERATION);
|
|
m_log << tcu::TestLog::EndSection;
|
|
|
|
glUseProgram(0);
|
|
});
|
|
ES2F_ADD_API_CASE(uniformi_invalid_location, "Invalid glUniform{1234}i() usage",
|
|
{
|
|
glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
|
|
glUseProgram(program.getProgram());
|
|
|
|
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
|
|
|
|
ES2F_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;
|
|
});
|
|
ES2F_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 vUnif = glGetUniformLocation(program.getProgram(), "vTest"); // vec4
|
|
GLint fUnif = glGetUniformLocation(program.getProgram(), "fTest"); // ivec4
|
|
GLint fSampler = glGetUniformLocation(program.getProgram(), "fSampler"); // sampler2D
|
|
|
|
if (vUnif == -1 || fUnif == -1 || fSampler == -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(fUnif, 1, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform2iv(fUnif, 1, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform3iv(fUnif, 1, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform4iv(fUnif, 1, &data[0]);
|
|
expectError(GL_NO_ERROR);
|
|
m_log << tcu::TestLog::EndSection;
|
|
|
|
m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if one of the integer variants of this function is used to load a uniform variable of type float, vec2, vec3, or vec4.");
|
|
glUseProgram(program.getProgram());
|
|
glUniform4iv(vUnif, 1, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
m_log << tcu::TestLog::EndSection;
|
|
|
|
glUseProgram(0);
|
|
});
|
|
ES2F_ADD_API_CASE(uniformiv_invalid_location, "Invalid glUniform{1234}iv() usage",
|
|
{
|
|
glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
|
|
glUseProgram(program.getProgram());
|
|
|
|
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);
|
|
});
|
|
ES2F_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 fUnif = glGetUniformLocation(program.getProgram(), "fTest"); // ivec4
|
|
|
|
if (fUnif == -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(fUnif, 2, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform2iv(fUnif, 2, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform3iv(fUnif, 2, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniform4iv(fUnif, 2, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
m_log << tcu::TestLog::EndSection;
|
|
|
|
glUseProgram(0);
|
|
});
|
|
|
|
// glUniformMatrix*fv
|
|
|
|
ES2F_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);
|
|
m_log << tcu::TestLog::EndSection;
|
|
});
|
|
ES2F_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 vMatUnif = glGetUniformLocation(program.getProgram(), "vMatrix"); // mat4
|
|
GLint fSamplerUnif = glGetUniformLocation(program.getProgram(), "fSampler"); // sampler2D
|
|
|
|
m_log << program;
|
|
|
|
if (vMatUnif == -1 || fSamplerUnif == -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(vMatUnif, 1, GL_FALSE, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniformMatrix3fv(vMatUnif, 1, GL_FALSE, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniformMatrix4fv(vMatUnif, 1, GL_FALSE, &data[0]);
|
|
expectError(GL_NO_ERROR);
|
|
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());
|
|
glUniformMatrix4fv(fSamplerUnif, 1, GL_FALSE, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
m_log << tcu::TestLog::EndSection;
|
|
|
|
glUseProgram(0);
|
|
});
|
|
ES2F_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());
|
|
|
|
m_log << program;
|
|
|
|
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);
|
|
|
|
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);
|
|
m_log << tcu::TestLog::EndSection;
|
|
|
|
glUseProgram(0);
|
|
});
|
|
ES2F_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 vMatUnif = glGetUniformLocation(program.getProgram(), "vMatrix"); // mat4
|
|
|
|
m_log << program;
|
|
|
|
if (vMatUnif == -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(vMatUnif, 2, GL_FALSE, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniformMatrix3fv(vMatUnif, 2, GL_FALSE, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
glUniformMatrix4fv(vMatUnif, 2, GL_FALSE, &data[0]);
|
|
expectError(GL_INVALID_OPERATION);
|
|
m_log << tcu::TestLog::EndSection;
|
|
|
|
glUseProgram(0);
|
|
});
|
|
ES2F_ADD_API_CASE(uniform_matrixfv_invalid_transpose, "Invalid glUniformMatrix{234}fv() usage",
|
|
{
|
|
if (de::beginsWith((const char*)glGetString(GL_VERSION), "OpenGL ES 2.0 "))
|
|
{
|
|
DE_ASSERT(m_context.getRenderContext().getType().getMajorVersion() < 3);
|
|
DE_ASSERT(m_context.getRenderContext().getType().getMinorVersion() == 0);
|
|
DE_ASSERT(m_context.getRenderContext().getType().getProfile() == glu::PROFILE_ES);
|
|
|
|
glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
|
|
glUseProgram(program.getProgram());
|
|
|
|
m_log << program;
|
|
|
|
std::vector<GLfloat> data(16);
|
|
|
|
m_log << tcu::TestLog::Section("", "GL_INVALID_VALUE is generated if transpose is not GL_FALSE.");
|
|
glUseProgram(program.getProgram());
|
|
glUniformMatrix2fv(0, 1, GL_TRUE, &data[0]);
|
|
expectError(GL_INVALID_VALUE);
|
|
glUniformMatrix3fv(0, 1, GL_TRUE, &data[0]);
|
|
expectError(GL_INVALID_VALUE);
|
|
glUniformMatrix4fv(0, 1, GL_TRUE, &data[0]);
|
|
expectError(GL_INVALID_VALUE);
|
|
m_log << tcu::TestLog::EndSection;
|
|
|
|
glUseProgram(0);
|
|
}
|
|
});
|
|
}
|
|
|
|
} // Functional
|
|
} // gles2
|
|
} // deqp
|