modules/gles2/functional/es2fNegativeStateApiTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 2.0 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Negative GL State API tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es2fNegativeStateApiTests.hpp"
  25 #include "es2fApiCase.hpp"
  26 #include "gluShaderProgram.hpp"
  27 #include "deMemory.h"
  28
  29 #include "glwEnums.hpp"
  30 #include "glwDefs.hpp"
  31
  32 using namespace glw; // GL types
  33
  34 namespace deqp
  35 {
  36 namespace gles2
  37 {
  38 namespace Functional
  39 {
  40
  41 using tcu::TestLog;
  42
  43 static const char* uniformTestVertSource        =       "uniform mediump vec4 vTest;\n"
  44                                                                                                 "void main (void)\n"
  45                                                                                                 "{\n"
  46                                                                                                 "       gl_Position = vTest;\n"
  47                                                                                                 "}\n\0";
  48 static const char* uniformTestFragSource        =       "uniform mediump ivec4 fTest;\n"
  49                                                                                                 "void main (void)\n"
  50                                                                                                 "{\n"
  51                                                                                                 "       gl_FragColor = vec4(fTest);\n"
  52                                                                                                 "}\n\0";
  53
  54 NegativeStateApiTests::NegativeStateApiTests (Context& context)
  55         : TestCaseGroup(context, "state", "Negative GL State API Cases")
  56 {
  57 }
  58
  59 NegativeStateApiTests::~NegativeStateApiTests (void)
  60 {
  61 }
  62
  63 void NegativeStateApiTests::init (void)
  64 {
  65         // Enabling & disabling states
  66
  67         ES2F_ADD_API_CASE(enable, "Invalid glEnable() usage",
  68                 {
  69                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if cap is not one of the allowed values.");
  70                         glEnable(-1);
  71                         expectError(GL_INVALID_ENUM);
  72                         m_log << TestLog::EndSection;
  73                 });
  74         ES2F_ADD_API_CASE(disable, "Invalid glDisable() usage",
  75                 {
  76                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if cap is not one of the allowed values.");
  77                         glDisable(-1);
  78                         expectError(GL_INVALID_ENUM);
  79                         m_log << TestLog::EndSection;
  80                 });
  81
  82         // Simple state queries
  83
  84         ES2F_ADD_API_CASE(get_booleanv, "Invalid glGetBooleanv() usage",
  85                 {
  86                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not one of the allowed values.");
  87                         GLboolean params[1] = { GL_FALSE };
  88                         glGetBooleanv(-1, &params[0]);
  89                         expectError(GL_INVALID_ENUM);
  90                         m_log << TestLog::EndSection;
  91                 });
  92         ES2F_ADD_API_CASE(get_floatv, "Invalid glGetFloatv() usage",
  93                 {
  94                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not one of the allowed values.");
  95                         GLfloat params[1] = { 0.0f };
  96                         glGetFloatv(-1, &params[0]);
  97                         expectError(GL_INVALID_ENUM);
  98                         m_log << TestLog::EndSection;
  99                 });
 100         ES2F_ADD_API_CASE(get_integerv, "Invalid glGetIntegerv() usage",
 101                 {
 102                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not one of the allowed values.");
 103                         GLint params[1] = { 0 };
 104                         glGetIntegerv(-1, &params[0]);
 105                         expectError(GL_INVALID_ENUM);
 106                         m_log << TestLog::EndSection;
 107                 });
 108         ES2F_ADD_API_CASE(get_string, "Invalid glGetString() usage",
 109                 {
 110                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if name is not an accepted value.");
 111                         glGetString(0);
 112                         expectError(GL_INVALID_ENUM);
 113                         m_log << TestLog::EndSection;
 114                 });
 115
 116         // Enumerated state queries: Shaders
 117
 118         ES2F_ADD_API_CASE(get_attached_shaders, "Invalid glGetAttachedShaders() usage",
 119                 {
 120                         GLuint shaders[1]       = { 0 };
 121                         GLuint shaderObject = glCreateShader(GL_VERTEX_SHADER);
 122                         GLuint program          = glCreateProgram();
 123                         GLsizei count[1]        = { -1 };
 124
 125                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 126                         glGetAttachedShaders(-1, 1, &count[0], &shaders[0]);
 127                         expectError(GL_INVALID_VALUE);
 128                         m_log << TestLog::EndSection;
 129
 130                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 131                         glGetAttachedShaders(shaderObject, 1, &count[0], &shaders[0]);
 132                         expectError(GL_INVALID_OPERATION);
 133                         m_log << TestLog::EndSection;
 134
 135                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if maxCount is less than 0.");
 136                         glGetAttachedShaders(program, -1, &count[0], &shaders[0]);
 137                         expectError(GL_INVALID_VALUE);
 138                         m_log << TestLog::EndSection;
 139
 140                         glDeleteShader(shaderObject);
 141                         glDeleteProgram(program);
 142                 });
 143         ES2F_ADD_API_CASE(get_shaderiv, "Invalid glGetShaderiv() usage",
 144                 {
 145                         GLboolean shaderCompilerSupported;
 146                         glGetBooleanv(GL_SHADER_COMPILER, &shaderCompilerSupported);
 147                         if (!shaderCompilerSupported)
 148                                 m_log << TestLog::Message << "// Shader compiler not supported, always expect GL_INVALID_OPERATION" << TestLog::EndMessage;
 149                         else
 150                                 m_log << TestLog::Message << "// Shader compiler supported" << TestLog::EndMessage;
 151
 152                         GLuint shader   = glCreateShader(GL_VERTEX_SHADER);
 153                         GLuint program  = glCreateProgram();
 154                         GLint param[1]  = { -1 };
 155
 156                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not an accepted value.");
 157                         glGetShaderiv(shader, -1, &param[0]);
 158                         expectError(GL_INVALID_ENUM);
 159                         m_log << TestLog::EndSection;
 160
 161                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
 162                         glGetShaderiv(-1, GL_SHADER_TYPE, &param[0]);
 163                         expectError(GL_INVALID_VALUE);
 164                         m_log << TestLog::EndSection;
 165
 166                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if pname is GL_COMPILE_STATUS, GL_INFO_LOG_LENGTH, or GL_SHADER_SOURCE_LENGTH but a shader compiler is not supported.");
 167                         glGetShaderiv(shader, GL_COMPILE_STATUS, &param[0]);
 168                         expectError(shaderCompilerSupported ? GL_NO_ERROR : GL_INVALID_OPERATION);
 169                         glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &param[0]);
 170                         expectError(shaderCompilerSupported ? GL_NO_ERROR : GL_INVALID_OPERATION);
 171                         glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &param[0]);
 172                         expectError(shaderCompilerSupported ? GL_NO_ERROR : GL_INVALID_OPERATION);
 173                         m_log << TestLog::EndSection;
 174
 175                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader does not refer to a shader object.");
 176                         glGetShaderiv(program, GL_SHADER_TYPE, &param[0]);
 177                         expectError(GL_INVALID_OPERATION);
 178                         m_log << TestLog::EndSection;
 179
 180                         glDeleteShader(shader);
 181                         glDeleteProgram(program);
 182                 });
 183         ES2F_ADD_API_CASE(get_shader_info_log, "Invalid glGetShaderInfoLog() usage",
 184                 {
 185                         GLuint shader   = glCreateShader(GL_VERTEX_SHADER);
 186                         GLuint program  = glCreateProgram();
 187                         GLsizei length[1] = { -1 };
 188                         char infoLog[128];
 189
 190                         deMemset(&infoLog[0], 0, sizeof(infoLog));
 191
 192                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
 193                         glGetShaderInfoLog(-1, 128, &length[0], &infoLog[0]);
 194                         expectError(GL_INVALID_VALUE);
 195                         m_log << TestLog::EndSection;
 196
 197                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
 198                         glGetShaderInfoLog(program, 128, &length[0], &infoLog[0]);
 199                         expectError(GL_INVALID_OPERATION);
 200                         m_log << TestLog::EndSection;
 201
 202                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if maxLength is less than 0.");
 203                         glGetShaderInfoLog(shader, -1, &length[0], &infoLog[0]);
 204                         expectError(GL_INVALID_VALUE);
 205                         m_log << TestLog::EndSection;
 206
 207                         glDeleteShader(shader);
 208                         glDeleteProgram(program);
 209                 });
 210         ES2F_ADD_API_CASE(get_shader_precision_format, "Invalid glGetShaderPrecisionFormat() usage",
 211                 {
 212                         GLboolean shaderCompilerSupported;
 213                         glGetBooleanv(GL_SHADER_COMPILER, &shaderCompilerSupported);
 214                         if (!shaderCompilerSupported)
 215                                 m_log << TestLog::Message << "// Shader compiler not supported, always expect GL_INVALID_OPERATION" << TestLog::EndMessage;
 216                         else
 217                                 m_log << TestLog::Message << "// Shader compiler supported" << TestLog::EndMessage;
 218
 219                         GLint range[2];
 220                         range[0] = -1;
 221                         range[1] = -1;
 222                         GLint precision[1] = { -1 };
 223
 224                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if shaderType or precisionType is not an accepted value.");
 225                         glGetShaderPrecisionFormat (-1, GL_MEDIUM_FLOAT, &range[0], &precision[0]);
 226                         expectError(shaderCompilerSupported ? GL_INVALID_ENUM : GL_INVALID_OPERATION);
 227                         glGetShaderPrecisionFormat (GL_VERTEX_SHADER, -1, &range[0], &precision[0]);
 228                         expectError(shaderCompilerSupported ? GL_INVALID_ENUM : GL_INVALID_OPERATION);
 229                         glGetShaderPrecisionFormat (-1, -1, &range[0], &precision[0]);
 230                         expectError(shaderCompilerSupported ? GL_INVALID_ENUM : GL_INVALID_OPERATION);
 231                         m_log << TestLog::EndSection;
 232
 233                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if a shader compiler is not supported.");
 234                         glGetShaderPrecisionFormat (GL_VERTEX_SHADER, GL_MEDIUM_FLOAT, &range[0], &precision[0]);
 235                         expectError(shaderCompilerSupported ? GL_NO_ERROR : GL_INVALID_OPERATION);
 236                         m_log << TestLog::EndSection;
 237                 });
 238         ES2F_ADD_API_CASE(get_shader_source, "Invalid glGetShaderSource() usage",
 239                 {
 240                         GLsizei length[1] = { -1 };
 241                         char source[1] = { 0 };
 242                         GLuint program  = glCreateProgram();
 243                         GLuint shader   = glCreateShader(GL_VERTEX_SHADER);
 244
 245                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if shader is not a value generated by OpenGL.");
 246                         glGetShaderSource(-1, 1, &length[0], &source[0]);
 247                         expectError(GL_INVALID_VALUE);
 248                         m_log << TestLog::EndSection;
 249
 250                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if shader is not a shader object.");
 251                         glGetShaderSource(program, 1, &length[0], &source[0]);
 252                         expectError(GL_INVALID_OPERATION);
 253                         m_log << TestLog::EndSection;
 254
 255                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if bufSize is less than 0.");
 256                         glGetShaderSource(shader, -1, &length[0], &source[0]);
 257                         expectError(GL_INVALID_VALUE);
 258                         m_log << TestLog::EndSection;
 259
 260                         glDeleteProgram(program);
 261                         glDeleteShader(shader);
 262                 });
 263
 264         // Enumerated state queries: Programs
 265
 266         ES2F_ADD_API_CASE(get_programiv, "Invalid glGetProgramiv() usage",
 267                 {
 268                         GLuint program  = glCreateProgram();
 269                         GLuint shader   = glCreateShader(GL_VERTEX_SHADER);
 270                         GLint params[1] = { -1 };
 271
 272                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not an accepted value.");
 273                         glGetProgramiv(program, -1, &params[0]);
 274                         expectError(GL_INVALID_ENUM);
 275                         m_log << TestLog::EndSection;
 276
 277                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 278                         glGetProgramiv(-1, GL_LINK_STATUS, &params[0]);
 279                         expectError(GL_INVALID_VALUE);
 280                         m_log << TestLog::EndSection;
 281
 282                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program does not refer to a program object.");
 283                         glGetProgramiv(shader, GL_LINK_STATUS, &params[0]);
 284                         expectError(GL_INVALID_OPERATION);
 285                         m_log << TestLog::EndSection;
 286
 287                         glDeleteProgram(program);
 288                         glDeleteShader(shader);
 289                 });
 290         ES2F_ADD_API_CASE(get_program_info_log, "Invalid glGetProgramInfoLog() usage",
 291                 {
 292                         GLuint program  = glCreateProgram();
 293                         GLuint shader   = glCreateShader(GL_VERTEX_SHADER);
 294                         GLsizei length[1] = { -1 };
 295                         char infoLog[1] = { 0 };
 296
 297                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 298                         glGetProgramInfoLog (-1, 1, &length[0], &infoLog[0]);
 299                         expectError(GL_INVALID_VALUE);
 300                         m_log << TestLog::EndSection;
 301
 302                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 303                         glGetProgramInfoLog (shader, 1, &length[0], &infoLog[0]);
 304                         expectError(GL_INVALID_OPERATION);
 305                         m_log << TestLog::EndSection;
 306
 307                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if maxLength is less than 0.");
 308                         glGetProgramInfoLog (program, -1, &length[0], &infoLog[0]);
 309                         expectError(GL_INVALID_VALUE);
 310                         m_log << TestLog::EndSection;
 311
 312                         glDeleteProgram(program);
 313                         glDeleteShader(shader);
 314                 });
 315
 316         // Enumerated state queries: Shader variables
 317
 318         ES2F_ADD_API_CASE(get_tex_parameterfv, "Invalid glGetTexParameterfv() usage",
 319                 {
 320                         GLfloat params[1] = { 0.0f };
 321
 322                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not an accepted value.");
 323                         glGetTexParameterfv (-1, GL_TEXTURE_MAG_FILTER, &params[0]);
 324                         expectError(GL_INVALID_ENUM);
 325                         glGetTexParameterfv (GL_TEXTURE_2D, -1, &params[0]);
 326                         expectError(GL_INVALID_ENUM);
 327                         glGetTexParameterfv (-1, -1, &params[0]);
 328                         expectError(GL_INVALID_ENUM);
 329                         m_log << TestLog::EndSection;
 330                 });
 331         ES2F_ADD_API_CASE(get_tex_parameteriv, "Invalid glGetTexParameteriv() usage",
 332                 {
 333                         GLint params[1] = { -1 };
 334
 335                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not an accepted value.");
 336                         glGetTexParameteriv (-1, GL_TEXTURE_MAG_FILTER, &params[0]);
 337                         expectError(GL_INVALID_ENUM);
 338                         glGetTexParameteriv (GL_TEXTURE_2D, -1, &params[0]);
 339                         expectError(GL_INVALID_ENUM);
 340                         glGetTexParameteriv (-1, -1, &params[0]);
 341                         expectError(GL_INVALID_ENUM);
 342                         m_log << TestLog::EndSection;
 343                 });
 344         ES2F_ADD_API_CASE(get_uniformfv, "Invalid glGetUniformfv() usage",
 345                 {
 346                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 347                         glUseProgram(program.getProgram());
 348
 349                         GLint vUnif = glGetUniformLocation(program.getProgram(), "vTest");      // vec4
 350                         GLint fUnif = glGetUniformLocation(program.getProgram(), "fTest");      // ivec4
 351                         if (vUnif == -1 || fUnif == -1)
 352                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
 353
 354                         GLuint shader           = glCreateShader(GL_VERTEX_SHADER);
 355                         GLuint programEmpty = glCreateProgram();
 356                         GLfloat params[4];
 357
 358                         deMemset(&params[0], 0, sizeof(params));
 359
 360                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 361                         glGetUniformfv (-1, vUnif, &params[0]);
 362                         expectError(GL_INVALID_VALUE);
 363                         m_log << TestLog::EndSection;
 364
 365                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 366                         glGetUniformfv (shader, vUnif, &params[0]);
 367                         expectError(GL_INVALID_OPERATION);
 368                         m_log << TestLog::EndSection;
 369
 370                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program has not been successfully linked.");
 371                         glGetUniformfv (programEmpty, vUnif, &params[0]);
 372                         expectError(GL_INVALID_OPERATION);
 373                         m_log << TestLog::EndSection;
 374
 375                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if location does not correspond to a valid uniform variable location for the specified program object.");
 376                         glGetUniformfv (program.getProgram(), de::max(vUnif, fUnif)+1, &params[0]);
 377                         expectError(GL_INVALID_OPERATION);
 378                         m_log << TestLog::EndSection;
 379
 380                         glDeleteShader(shader);
 381                         glDeleteProgram(programEmpty);
 382                 });
 383         ES2F_ADD_API_CASE(get_uniformiv, "Invalid glGetUniformiv() usage",
 384                 {
 385                         glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(uniformTestVertSource, uniformTestFragSource));
 386                         glUseProgram(program.getProgram());
 387
 388                         GLint vUnif = glGetUniformLocation(program.getProgram(), "vTest");      // vec4
 389                         GLint fUnif = glGetUniformLocation(program.getProgram(), "fTest");      // ivec4
 390                         if (vUnif == -1 || fUnif == -1)
 391                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to retrieve uniform location");
 392
 393                         GLuint shader           = glCreateShader(GL_VERTEX_SHADER);
 394                         GLuint programEmpty = glCreateProgram();
 395                         GLint params[4];
 396
 397                         deMemset(&params[0], 0, sizeof(params));
 398
 399                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
 400                         glGetUniformiv (-1, vUnif, &params[0]);
 401                         expectError(GL_INVALID_VALUE);
 402                         m_log << TestLog::EndSection;
 403
 404                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program is not a program object.");
 405                         glGetUniformiv (shader, vUnif, &params[0]);
 406                         expectError(GL_INVALID_OPERATION);
 407                         m_log << TestLog::EndSection;
 408
 409                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if program has not been successfully linked.");
 410                         glGetUniformiv (programEmpty, vUnif, &params[0]);
 411                         expectError(GL_INVALID_OPERATION);
 412                         m_log << TestLog::EndSection;
 413
 414                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if location does not correspond to a valid uniform variable location for the specified program object.");
 415                         glGetUniformiv (program.getProgram(), de::max(vUnif, fUnif)+1, &params[0]);
 416                         expectError(GL_INVALID_OPERATION);
 417                         m_log << TestLog::EndSection;
 418
 419                         glDeleteShader(shader);
 420                         glDeleteProgram(programEmpty);
 421                 });
 422         ES2F_ADD_API_CASE(get_vertex_attribfv, "Invalid glGetVertexAttribfv() usage",
 423                 {
 424                         GLfloat params[1];
 425
 426                         deMemset(&params[0], 0, sizeof(params));
 427
 428                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not an accepted value.");
 429                         glGetVertexAttribfv(0, -1, &params[0]);
 430                         expectError(GL_INVALID_ENUM);
 431                         m_log << TestLog::EndSection;
 432
 433                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
 434                         GLint maxVertexAttribs;
 435                         glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs);
 436                         glGetVertexAttribfv(maxVertexAttribs, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &params[0]);
 437                         expectError(GL_INVALID_VALUE);
 438                         m_log << TestLog::EndSection;
 439                 });
 440         ES2F_ADD_API_CASE(get_vertex_attribiv, "Invalid glGetVertexAttribiv() usage",
 441                 {
 442                         GLint params[1];
 443
 444                         deMemset(&params[0], 0, sizeof(params));
 445
 446                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not an accepted value.");
 447                         glGetVertexAttribiv(0, -1, &params[0]);
 448                         expectError(GL_INVALID_ENUM);
 449                         m_log << TestLog::EndSection;
 450
 451                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
 452                         GLint maxVertexAttribs;
 453                         glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs);
 454                         glGetVertexAttribiv(maxVertexAttribs, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &params[0]);
 455                         expectError(GL_INVALID_VALUE);
 456                         m_log << TestLog::EndSection;
 457                 });
 458         ES2F_ADD_API_CASE(get_vertex_attrib_pointerv, "Invalid glGetVertexAttribPointerv() usage",
 459                 {
 460                         GLvoid* ptr[1] = { DE_NULL };
 461
 462                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not an accepted value.");
 463                         glGetVertexAttribPointerv(0, -1, &ptr[0]);
 464                         expectError(GL_INVALID_ENUM);
 465                         m_log << TestLog::EndSection;
 466
 467                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.");
 468                         GLint maxVertexAttribs;
 469                         glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs);
 470                         glGetVertexAttribPointerv(maxVertexAttribs, GL_VERTEX_ATTRIB_ARRAY_POINTER, &ptr[0]);
 471                         expectError(GL_INVALID_VALUE);
 472                         m_log << TestLog::EndSection;
 473                 });
 474
 475         // Enumerated state queries: Buffers
 476
 477         ES2F_ADD_API_CASE(get_buffer_parameteriv, "Invalid glGetBufferParameteriv() usage",
 478                 {
 479                         GLint params[1];
 480                         GLuint buf;
 481                         glGenBuffers(1, &buf);
 482                         glBindBuffer(GL_ARRAY_BUFFER, buf);
 483
 484                         deMemset(&params[0], 0, sizeof(params));
 485
 486                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or value is not an accepted value.");
 487                         glGetBufferParameteriv(-1, GL_BUFFER_SIZE, &params[0]);
 488                         expectError(GL_INVALID_ENUM);
 489                         glGetBufferParameteriv(GL_ARRAY_BUFFER , -1, &params[0]);
 490                         expectError(GL_INVALID_ENUM);
 491                         glGetBufferParameteriv(-1, -1, &params[0]);
 492                         expectError(GL_INVALID_ENUM);
 493                         m_log << TestLog::EndSection;
 494
 495                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the reserved buffer object name 0 is bound to target.");
 496                         glBindBuffer(GL_ARRAY_BUFFER, 0);
 497                         glGetBufferParameteriv(GL_ARRAY_BUFFER, GL_BUFFER_SIZE, &params[0]);
 498                         expectError(GL_INVALID_OPERATION);
 499                         m_log << TestLog::EndSection;
 500
 501                         glDeleteBuffers(1, &buf);
 502                 });
 503         ES2F_ADD_API_CASE(get_framebuffer_attachment_parameteriv, "Invalid glGetFramebufferAttachmentParameteriv() usage",
 504                 {
 505                         GLint params[1] = { -1 };
 506                         GLuint fbo;
 507                         glGenFramebuffers(1, &fbo);
 508                         glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 509
 510                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_FRAMEBUFFER.");
 511                         glGetFramebufferAttachmentParameteriv(-1, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &params[0]);
 512                         expectError(GL_INVALID_ENUM);
 513                         m_log << TestLog::EndSection;
 514
 515                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if there is no attached object at the named attachment point and pname is not GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE.");
 516                         glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &params[0]);
 517                         expectError(GL_INVALID_ENUM);
 518                         m_log << TestLog::EndSection;
 519
 520                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if the attached object at the named attachment point is incompatible with pname.");
 521                         GLint attachmentObjectType = -1;
 522                         glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &attachmentObjectType);
 523                         expectError(GL_NO_ERROR);
 524
 525                         if (attachmentObjectType == GL_RENDERBUFFER)
 526                                 glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL, &params[0]);
 527                         else if (attachmentObjectType == GL_TEXTURE)
 528                                 glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, -1, &params[0]);
 529                         else if (attachmentObjectType == GL_NONE)
 530                                 glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &params[0]);
 531                         else
 532                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid return value from glGetFramebufferAttachmentParameteriv()");
 533
 534                         expectError(GL_INVALID_ENUM);
 535                         m_log << TestLog::EndSection;
 536
 537                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the default framebuffer object name 0 is bound.");
 538                         glBindFramebuffer(GL_FRAMEBUFFER, 0);
 539                         glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &params[0]);
 540                         expectError(GL_INVALID_OPERATION);
 541                         m_log << TestLog::EndSection;
 542
 543                         glDeleteFramebuffers(1, &fbo);
 544                 });
 545         ES2F_ADD_API_CASE(get_renderbuffer_parameteriv, "Invalid glGetRenderbufferParameteriv() usage",
 546                 {
 547                         GLint params[1];
 548                         GLuint rbo;
 549                         glGenRenderbuffers(1, &rbo);
 550                         glBindRenderbuffer(GL_RENDERBUFFER, rbo);
 551
 552                         deMemset(&params[0], 0, sizeof(params));
 553
 554                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_RENDERBUFFER.");
 555                         glGetRenderbufferParameteriv(-1, GL_RENDERBUFFER_WIDTH, &params[0]);
 556                         expectError(GL_INVALID_ENUM);
 557                         m_log << TestLog::EndSection;
 558
 559                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not one of the allowed values.");
 560                         glGetRenderbufferParameteriv(GL_RENDERBUFFER, -1, &params[0]);
 561                         expectError(GL_INVALID_ENUM);
 562                         m_log << TestLog::EndSection;
 563
 564                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the reserved renderbuffer object name 0 is bound.");
 565                         glBindRenderbuffer(GL_RENDERBUFFER, 0);
 566                         glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, &params[0]);
 567                         expectError(GL_INVALID_OPERATION);
 568                         m_log << TestLog::EndSection;
 569
 570                         glDeleteRenderbuffers(1, &rbo);
 571                 });
 572
 573         // Enumerated boolean state queries
 574
 575         ES2F_ADD_API_CASE(get_is_enabled, "Invalid glIsEnabled() usage",
 576                 {
 577                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if cap is not an accepted value.");
 578                         glIsEnabled(-1);
 579                         expectError(GL_INVALID_ENUM);
 580                         glIsEnabled(GL_TRIANGLES);
 581                         expectError(GL_INVALID_ENUM);
 582                         m_log << TestLog::EndSection;
 583                 });
 584
 585         // Hints
 586
 587         ES2F_ADD_API_CASE(hint, "Invalid glHint() usage",
 588                 {
 589                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if either target or mode is not an accepted value.");
 590                         glHint(GL_GENERATE_MIPMAP_HINT, -1);
 591                         expectError(GL_INVALID_ENUM);
 592                         glHint(-1, GL_FASTEST);
 593                         expectError(GL_INVALID_ENUM);
 594                         glHint(-1, -1);
 595                         expectError(GL_INVALID_ENUM);
 596                         m_log << TestLog::EndSection;
 597                 });
 598
 599         // Named object usage
 600
 601         ES2F_ADD_API_CASE(is_buffer, "Invalid glIsBuffer() usage",
 602                 {
 603                         GLuint          buffer = 0;
 604                         GLboolean       isBuffer;
 605
 606                         m_log << TestLog::Section("", "A name returned by glGenBuffers, but not yet associated with a buffer object by calling glBindBuffer, is not the name of a buffer object.");
 607                         isBuffer                = glIsBuffer(buffer);
 608                         checkBooleans   (isBuffer, GL_FALSE);
 609
 610                         glGenBuffers    (1, &buffer);
 611                         isBuffer                = glIsBuffer(buffer);
 612                         checkBooleans   (isBuffer, GL_FALSE);
 613
 614                         glBindBuffer    (GL_ARRAY_BUFFER, buffer);
 615                         isBuffer                = glIsBuffer(buffer);
 616                         checkBooleans   (isBuffer, GL_TRUE);
 617
 618                         glBindBuffer    (GL_ARRAY_BUFFER, 0);
 619                         glDeleteBuffers (1, &buffer);
 620                         isBuffer                = glIsBuffer(buffer);
 621                         checkBooleans   (isBuffer, GL_FALSE);
 622                         m_log << TestLog::EndSection;
 623
 624                         expectError                     (GL_NO_ERROR);
 625                 });
 626         ES2F_ADD_API_CASE(is_framebuffer, "Invalid glIsFramebuffer() usage",
 627                 {
 628                         GLuint          fbo = 0;
 629                         GLboolean       isFbo;
 630
 631                         m_log << TestLog::Section("", "A name returned by glGenFramebuffers, but not yet bound through a call to glBindFramebuffer is not the name of a framebuffer object.");
 632                         isFbo                           = glIsFramebuffer(fbo);
 633                         checkBooleans           (isFbo, GL_FALSE);
 634
 635                         glGenFramebuffers       (1, &fbo);
 636                         isFbo                           = glIsFramebuffer(fbo);
 637                         checkBooleans           (isFbo, GL_FALSE);
 638
 639                         glBindFramebuffer       (GL_FRAMEBUFFER, fbo);
 640                         isFbo                           = glIsFramebuffer(fbo);
 641                         checkBooleans           (isFbo, GL_TRUE);
 642
 643                         glBindFramebuffer       (GL_FRAMEBUFFER, 0);
 644                         glDeleteFramebuffers(1, &fbo);
 645                         isFbo                           = glIsFramebuffer(fbo);
 646                         checkBooleans           (isFbo, GL_FALSE);
 647                         m_log << TestLog::EndSection;
 648
 649                         expectError                     (GL_NO_ERROR);
 650                 });
 651         ES2F_ADD_API_CASE(is_program, "Invalid glIsProgram() usage",
 652                 {
 653                         GLuint          program = 0;
 654                         GLboolean       isProgram;
 655
 656                         m_log << TestLog::Section("", "A name created with glCreateProgram, and not yet deleted with glDeleteProgram is a name of a program object.");
 657                         isProgram                       = glIsProgram(program);
 658                         checkBooleans           (isProgram, GL_FALSE);
 659
 660                         program                         = glCreateProgram();
 661                         isProgram                       = glIsProgram(program);
 662                         checkBooleans           (isProgram, GL_TRUE);
 663
 664                         glDeleteProgram         (program);
 665                         isProgram                       = glIsProgram(program);
 666                         checkBooleans           (isProgram, GL_FALSE);
 667                         m_log << TestLog::EndSection;
 668
 669                         expectError                     (GL_NO_ERROR);
 670                 });
 671         ES2F_ADD_API_CASE(is_renderbuffer, "Invalid glIsRenderbuffer() usage",
 672                 {
 673                         GLuint          rbo = 0;
 674                         GLboolean       isRbo;
 675
 676                         m_log << TestLog::Section("", "A name returned by glGenRenderbuffers, but not yet bound through a call to glBindRenderbuffer or glFramebufferRenderbuffer is not the name of a renderbuffer object.");
 677                         isRbo                                   = glIsRenderbuffer(rbo);
 678                         checkBooleans                   (isRbo, GL_FALSE);
 679
 680                         glGenRenderbuffers              (1, &rbo);
 681                         isRbo                                   = glIsRenderbuffer(rbo);
 682                         checkBooleans                   (isRbo, GL_FALSE);
 683
 684                         glBindRenderbuffer              (GL_RENDERBUFFER, rbo);
 685                         isRbo                                   = glIsRenderbuffer(rbo);
 686                         checkBooleans                   (isRbo, GL_TRUE);
 687
 688                         glBindRenderbuffer              (GL_RENDERBUFFER, 0);
 689                         glDeleteRenderbuffers   (1, &rbo);
 690                         isRbo                                   = glIsRenderbuffer(rbo);
 691                         checkBooleans                   (isRbo, GL_FALSE);
 692                         m_log << TestLog::EndSection;
 693
 694                         expectError                     (GL_NO_ERROR);
 695                 });
 696         ES2F_ADD_API_CASE(is_shader, "Invalid glIsShader() usage",
 697                 {
 698                         GLuint          shader = 0;
 699                         GLboolean       isShader;
 700
 701                         m_log << TestLog::Section("", "A name created with glCreateShader, and not yet deleted with glDeleteShader is a name of a shader object.");
 702                         isShader                        = glIsProgram(shader);
 703                         checkBooleans           (isShader, GL_FALSE);
 704
 705                         shader                          = glCreateShader(GL_VERTEX_SHADER);
 706                         isShader                        = glIsShader(shader);
 707                         checkBooleans           (isShader, GL_TRUE);
 708
 709                         glDeleteShader          (shader);
 710                         isShader                        = glIsShader(shader);
 711                         checkBooleans           (isShader, GL_FALSE);
 712                         m_log << TestLog::EndSection;
 713
 714                         expectError                     (GL_NO_ERROR);
 715                 });
 716         ES2F_ADD_API_CASE(is_texture, "Invalid glIsTexture() usage",
 717                 {
 718                         GLuint          texture = 0;
 719                         GLboolean       isTexture;
 720
 721                         m_log << TestLog::Section("", "A name returned by glGenTextures, but not yet bound through a call to glBindTexture is not the name of a texture.");
 722                         isTexture                       = glIsTexture(texture);
 723                         checkBooleans           (isTexture, GL_FALSE);
 724
 725                         glGenTextures           (1, &texture);
 726                         isTexture                       = glIsTexture(texture);
 727                         checkBooleans           (isTexture, GL_FALSE);
 728
 729                         glBindTexture           (GL_TEXTURE_2D, texture);
 730                         isTexture                       = glIsTexture(texture);
 731                         checkBooleans           (isTexture, GL_TRUE);
 732
 733                         glBindTexture           (GL_TEXTURE_2D, 0);
 734                         glDeleteTextures        (1, &texture);
 735                         isTexture                       = glIsTexture(texture);
 736                         checkBooleans           (isTexture, GL_FALSE);
 737                         m_log << TestLog::EndSection;
 738
 739                         expectError                     (GL_NO_ERROR);
 740                 });
 741 }
 742
 743 } // Functional
 744 } // gles2
 745 } // deqp