modules/gles31/functional/es31fNegativeTextureApiTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.1 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 Texture API tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fNegativeTextureApiTests.hpp"
  25 #include "es31fNegativeTestShared.hpp"
  26
  27 #include "gluCallLogWrapper.hpp"
  28 #include "gluContextInfo.hpp"
  29 #include "gluRenderContext.hpp"
  30
  31 #include "glwDefs.hpp"
  32 #include "glwEnums.hpp"
  33
  34 namespace deqp
  35 {
  36 namespace gles31
  37 {
  38 namespace Functional
  39 {
  40 namespace NegativeTestShared
  41 {
  42
  43 using tcu::TestLog;
  44 using glu::CallLogWrapper;
  45 using namespace glw;
  46
  47 static inline int divRoundUp (int a, int b)
  48 {
  49         return a/b + (a%b != 0 ? 1 : 0);
  50 }
  51
  52 static inline int etc2DataSize (int width, int height)
  53 {
  54         return (int)(divRoundUp(width, 4) * divRoundUp(height, 4) * sizeof(deUint64));
  55 }
  56
  57 static inline int etc2EacDataSize (int width, int height)
  58 {
  59         return 2 * etc2DataSize(width, height);
  60 }
  61
  62 static deUint32 cubeFaceToGLFace (tcu::CubeFace face)
  63 {
  64         switch (face)
  65         {
  66                 case tcu::CUBEFACE_NEGATIVE_X: return GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
  67                 case tcu::CUBEFACE_POSITIVE_X: return GL_TEXTURE_CUBE_MAP_POSITIVE_X;
  68                 case tcu::CUBEFACE_NEGATIVE_Y: return GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
  69                 case tcu::CUBEFACE_POSITIVE_Y: return GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
  70                 case tcu::CUBEFACE_NEGATIVE_Z: return GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
  71                 case tcu::CUBEFACE_POSITIVE_Z: return GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
  72                 default:
  73                         DE_ASSERT(DE_FALSE);
  74                         return GL_NONE;
  75         }
  76 }
  77
  78 #define FOR_CUBE_FACES(FACE_GL_VAR, BODY)                                                                                               \
  79         do                                                                                                                                                                      \
  80         {                                                                                                                                                                       \
  81                 for (int faceIterTcu = 0; faceIterTcu < tcu::CUBEFACE_LAST; faceIterTcu++)              \
  82                 {                                                                                                                                                               \
  83                         const GLenum FACE_GL_VAR = cubeFaceToGLFace((tcu::CubeFace)faceIterTcu);        \
  84                         BODY                                                                                                                                            \
  85                 }                                                                                                                                                               \
  86         } while (false)
  87
  88
  89 // glActiveTexture
  90
  91 void activetexture (NegativeTestContext& ctx)
  92 {
  93         ctx.beginSection("GL_INVALID_ENUM is generated if texture is not one of GL_TEXTUREi, where i ranges from 0 to (GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1).");
  94         ctx.glActiveTexture(-1);
  95         ctx.expectError(GL_INVALID_ENUM);
  96         int numMaxTextureUnits = ctx.getInteger(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS);
  97         ctx.glActiveTexture(GL_TEXTURE0 + numMaxTextureUnits);
  98         ctx.expectError(GL_INVALID_ENUM);
  99         ctx.endSection();
 100 }
 101
 102 // glBindTexture
 103
 104 void bindtexture (NegativeTestContext& ctx)
 105 {
 106         GLuint texture[5];
 107         ctx.glGenTextures(5, texture);
 108
 109         ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the allowable values.");
 110         ctx.glBindTexture(0, 1);
 111         ctx.expectError(GL_INVALID_ENUM);
 112         ctx.glBindTexture(GL_FRAMEBUFFER, 1);
 113         ctx.expectError(GL_INVALID_ENUM);
 114         ctx.endSection();
 115
 116         ctx.beginSection("GL_INVALID_OPERATION is generated if texture was previously created with a target that doesn't match that of target.");
 117         ctx.glBindTexture(GL_TEXTURE_2D, texture[0]);
 118         ctx.expectError(GL_NO_ERROR);
 119         ctx.glBindTexture(GL_TEXTURE_CUBE_MAP, texture[0]);
 120         ctx.expectError(GL_INVALID_OPERATION);
 121         ctx.glBindTexture(GL_TEXTURE_3D, texture[0]);
 122         ctx.expectError(GL_INVALID_OPERATION);
 123         ctx.glBindTexture(GL_TEXTURE_2D_ARRAY, texture[0]);
 124         ctx.expectError(GL_INVALID_OPERATION);
 125
 126         ctx.glBindTexture(GL_TEXTURE_CUBE_MAP, texture[1]);
 127         ctx.expectError(GL_NO_ERROR);
 128         ctx.glBindTexture(GL_TEXTURE_2D, texture[1]);
 129         ctx.expectError(GL_INVALID_OPERATION);
 130         ctx.glBindTexture(GL_TEXTURE_3D, texture[1]);
 131         ctx.expectError(GL_INVALID_OPERATION);
 132         ctx.glBindTexture(GL_TEXTURE_2D_ARRAY, texture[1]);
 133         ctx.expectError(GL_INVALID_OPERATION);
 134
 135         ctx.glBindTexture(GL_TEXTURE_3D, texture[2]);
 136         ctx.expectError(GL_NO_ERROR);
 137         ctx.glBindTexture(GL_TEXTURE_2D, texture[2]);
 138         ctx.expectError(GL_INVALID_OPERATION);
 139         ctx.glBindTexture(GL_TEXTURE_CUBE_MAP, texture[2]);
 140         ctx.expectError(GL_INVALID_OPERATION);
 141         ctx.glBindTexture(GL_TEXTURE_2D_ARRAY, texture[2]);
 142         ctx.expectError(GL_INVALID_OPERATION);
 143
 144         ctx.glBindTexture(GL_TEXTURE_2D_ARRAY, texture[3]);
 145         ctx.expectError(GL_NO_ERROR);
 146         ctx.glBindTexture(GL_TEXTURE_2D, texture[3]);
 147         ctx.expectError(GL_INVALID_OPERATION);
 148         ctx.glBindTexture(GL_TEXTURE_CUBE_MAP, texture[3]);
 149         ctx.expectError(GL_INVALID_OPERATION);
 150         ctx.glBindTexture(GL_TEXTURE_3D, texture[3]);
 151         ctx.expectError(GL_INVALID_OPERATION);
 152
 153         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
 154         {
 155                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, texture[0]);
 156                 ctx.expectError(GL_INVALID_OPERATION);
 157                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, texture[1]);
 158                 ctx.expectError(GL_INVALID_OPERATION);
 159                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, texture[2]);
 160                 ctx.expectError(GL_INVALID_OPERATION);
 161                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, texture[3]);
 162                 ctx.expectError(GL_INVALID_OPERATION);
 163                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, texture[4]);
 164                 ctx.expectError(GL_NO_ERROR);
 165                 ctx.glBindTexture(GL_TEXTURE_2D, texture[4]);
 166                 ctx.expectError(GL_INVALID_OPERATION);
 167                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP, texture[4]);
 168                 ctx.expectError(GL_INVALID_OPERATION);
 169                 ctx.glBindTexture(GL_TEXTURE_3D, texture[4]);
 170                 ctx.expectError(GL_INVALID_OPERATION);
 171                 ctx.glBindTexture(GL_TEXTURE_2D_ARRAY, texture[4]);
 172                 ctx.expectError(GL_INVALID_OPERATION);
 173         }
 174         ctx.endSection();
 175
 176         ctx.glDeleteTextures(5, texture);
 177 }
 178
 179 // glCompressedTexImage2D
 180
 181 void compressedteximage2d_invalid_target (NegativeTestContext& ctx)
 182 {
 183         ctx.beginSection("GL_INVALID_ENUM is generated if target is invalid.");
 184         ctx.glCompressedTexImage2D(0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 185         ctx.expectError(GL_INVALID_ENUM);
 186         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 187         ctx.expectError(GL_INVALID_ENUM);
 188         ctx.endSection();
 189 }
 190
 191 void compressedteximage2d_invalid_format (NegativeTestContext& ctx)
 192 {
 193         ctx.beginSection("GL_INVALID_ENUM is generated if internalformat is not a supported format returned in GL_COMPRESSED_TEXTURE_FORMATS.");
 194         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 0);
 195         ctx.expectError(GL_INVALID_ENUM);
 196         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 0, 0, 0);
 197         ctx.expectError(GL_INVALID_ENUM);
 198         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 0, 0, 0, 0, 0);
 199         ctx.expectError(GL_INVALID_ENUM);
 200         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, 0, 0, 0, 0, 0, 0);
 201         ctx.expectError(GL_INVALID_ENUM);
 202         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, 0, 0, 0, 0, 0, 0);
 203         ctx.expectError(GL_INVALID_ENUM);
 204         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, 0, 0, 0, 0, 0, 0);
 205         ctx.expectError(GL_INVALID_ENUM);
 206         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, 0, 0, 0, 0, 0, 0);
 207         ctx.expectError(GL_INVALID_ENUM);
 208         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, 0, 0, 0, 0, 0, 0);
 209         ctx.expectError(GL_INVALID_ENUM);
 210         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, 0, 0, 0, 0, 0, 0);
 211         ctx.expectError(GL_INVALID_ENUM);
 212         ctx.endSection();
 213 }
 214
 215 void compressedteximage2d_neg_level (NegativeTestContext& ctx)
 216 {
 217         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
 218         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, -1, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 219         ctx.expectError(GL_INVALID_VALUE);
 220         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, -1, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 221         ctx.expectError(GL_INVALID_VALUE);
 222         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, -1, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 223         ctx.expectError(GL_INVALID_VALUE);
 224         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, -1, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 225         ctx.expectError(GL_INVALID_VALUE);
 226         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, -1, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 227         ctx.expectError(GL_INVALID_VALUE);
 228         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, -1, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 229         ctx.expectError(GL_INVALID_VALUE);
 230         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, -1, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 231         ctx.expectError(GL_INVALID_VALUE);
 232         ctx.endSection();
 233 }
 234
 235 void compressedteximage2d_max_level (NegativeTestContext& ctx)
 236 {
 237         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE) for a 2d texture target.");
 238         deUint32 log2MaxTextureSize = deLog2Floor32(ctx.getInteger(GL_MAX_TEXTURE_SIZE)) + 1;
 239         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, log2MaxTextureSize, GL_COMPRESSED_RGB8_ETC2, 16, 16, 0, etc2DataSize(16, 16), 0);
 240         ctx.expectError(GL_INVALID_VALUE);
 241         ctx.endSection();
 242
 243         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_TEXTURE_SIZE) for a cubemap target.");
 244         deUint32 log2MaxCubemapSize = deLog2Floor32(ctx.getInteger(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
 245         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, log2MaxCubemapSize, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
 246         ctx.expectError(GL_INVALID_VALUE);
 247         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, log2MaxCubemapSize, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
 248         ctx.expectError(GL_INVALID_VALUE);
 249         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, log2MaxCubemapSize, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
 250         ctx.expectError(GL_INVALID_VALUE);
 251         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, log2MaxCubemapSize, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
 252         ctx.expectError(GL_INVALID_VALUE);
 253         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, log2MaxCubemapSize, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
 254         ctx.expectError(GL_INVALID_VALUE);
 255         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, log2MaxCubemapSize, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
 256         ctx.expectError(GL_INVALID_VALUE);
 257         ctx.endSection();
 258 }
 259
 260 void compressedteximage2d_neg_width_height (NegativeTestContext& ctx)
 261 {
 262         ctx.beginSection("GL_INVALID_VALUE is generated if width or height is less than 0.");
 263
 264         ctx.beginSection("GL_TEXTURE_2D target");
 265         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0, 0, 0, 0);
 266         ctx.expectError(GL_INVALID_VALUE);
 267         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, -1, 0, 0, 0);
 268         ctx.expectError(GL_INVALID_VALUE);
 269         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, -1, 0, 0, 0);
 270         ctx.expectError(GL_INVALID_VALUE);
 271         ctx.endSection();
 272
 273         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_X target");
 274         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0, 0, 0, 0);
 275         ctx.expectError(GL_INVALID_VALUE);
 276         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, -1, 0, 0, 0);
 277         ctx.expectError(GL_INVALID_VALUE);
 278         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, -1, 0, 0, 0);
 279         ctx.expectError(GL_INVALID_VALUE);
 280         ctx.endSection();
 281
 282         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_Y target");
 283         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0, 0, 0, 0);
 284         ctx.expectError(GL_INVALID_VALUE);
 285         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, -1, 0, 0, 0);
 286         ctx.expectError(GL_INVALID_VALUE);
 287         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, -1, 0, 0, 0);
 288         ctx.expectError(GL_INVALID_VALUE);
 289         ctx.endSection();
 290
 291         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_Z target");
 292         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0, 0, 0, 0);
 293         ctx.expectError(GL_INVALID_VALUE);
 294         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, -1, 0, 0, 0);
 295         ctx.expectError(GL_INVALID_VALUE);
 296         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, -1, 0, 0, 0);
 297         ctx.expectError(GL_INVALID_VALUE);
 298         ctx.endSection();
 299
 300         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_X target");
 301         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0, 0, 0, 0);
 302         ctx.expectError(GL_INVALID_VALUE);
 303         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, -1, 0, 0, 0);
 304         ctx.expectError(GL_INVALID_VALUE);
 305         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, -1, 0, 0, 0);
 306         ctx.expectError(GL_INVALID_VALUE);
 307         ctx.endSection();
 308
 309         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Y target");
 310         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0, 0, 0, 0);
 311         ctx.expectError(GL_INVALID_VALUE);
 312         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, -1, 0, 0, 0);
 313         ctx.expectError(GL_INVALID_VALUE);
 314         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, -1, 0, 0, 0);
 315         ctx.expectError(GL_INVALID_VALUE);
 316         ctx.endSection();
 317
 318         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Z target");
 319         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0, 0, 0, 0);
 320         ctx.expectError(GL_INVALID_VALUE);
 321         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, -1, 0, 0, 0);
 322         ctx.expectError(GL_INVALID_VALUE);
 323         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, -1, 0, 0, 0);
 324         ctx.expectError(GL_INVALID_VALUE);
 325         ctx.endSection();
 326
 327         ctx.endSection();
 328 }
 329
 330 void compressedteximage2d_max_width_height (NegativeTestContext& ctx)
 331 {
 332         int maxTextureSize = ctx.getInteger(GL_MAX_TEXTURE_SIZE) + 1;
 333         int maxCubemapSize = ctx.getInteger(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
 334         ctx.beginSection("GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_TEXTURE_SIZE.");
 335
 336         ctx.beginSection("GL_TEXTURE_2D target");
 337         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxTextureSize, 1, 0, etc2EacDataSize(maxTextureSize, 1), 0);
 338         ctx.expectError(GL_INVALID_VALUE);
 339         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 1, maxTextureSize, 0, etc2EacDataSize(1, maxTextureSize), 0);
 340         ctx.expectError(GL_INVALID_VALUE);
 341         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxTextureSize, maxTextureSize, 0, etc2EacDataSize(maxTextureSize, maxTextureSize), 0);
 342         ctx.expectError(GL_INVALID_VALUE);
 343         ctx.endSection();
 344
 345         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_X target");
 346         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, 1, 0, etc2EacDataSize(maxCubemapSize, 1), 0);
 347         ctx.expectError(GL_INVALID_VALUE);
 348         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 1, maxCubemapSize, 0, etc2EacDataSize(1, maxCubemapSize), 0);
 349         ctx.expectError(GL_INVALID_VALUE);
 350         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, maxCubemapSize, 0, etc2EacDataSize(maxCubemapSize, maxCubemapSize), 0);
 351         ctx.expectError(GL_INVALID_VALUE);
 352         ctx.endSection();
 353
 354         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_Y target");
 355         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, 1, 0, etc2EacDataSize(maxCubemapSize, 1), 0);
 356         ctx.expectError(GL_INVALID_VALUE);
 357         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 1, maxCubemapSize, 0, etc2EacDataSize(1, maxCubemapSize), 0);
 358         ctx.expectError(GL_INVALID_VALUE);
 359         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, maxCubemapSize, 0, etc2EacDataSize(maxCubemapSize, maxCubemapSize), 0);
 360         ctx.expectError(GL_INVALID_VALUE);
 361         ctx.endSection();
 362
 363         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_Z target");
 364         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, 1, 0, etc2EacDataSize(maxCubemapSize, 1), 0);
 365         ctx.expectError(GL_INVALID_VALUE);
 366         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 1, maxCubemapSize, 0, etc2EacDataSize(1, maxCubemapSize), 0);
 367         ctx.expectError(GL_INVALID_VALUE);
 368         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, maxCubemapSize, 0, etc2EacDataSize(maxCubemapSize, maxCubemapSize), 0);
 369         ctx.expectError(GL_INVALID_VALUE);
 370         ctx.endSection();
 371
 372         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_X target");
 373         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, 1, 0, etc2EacDataSize(maxCubemapSize, 1), 0);
 374         ctx.expectError(GL_INVALID_VALUE);
 375         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 1, maxCubemapSize, 0, etc2EacDataSize(1, maxCubemapSize), 0);
 376         ctx.expectError(GL_INVALID_VALUE);
 377         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, maxCubemapSize, 0, etc2EacDataSize(maxCubemapSize, maxCubemapSize), 0);
 378         ctx.expectError(GL_INVALID_VALUE);
 379         ctx.endSection();
 380
 381         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Y target");
 382         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, 1, 0, etc2EacDataSize(maxCubemapSize, 1), 0);
 383         ctx.expectError(GL_INVALID_VALUE);
 384         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 1, maxCubemapSize, 0, etc2EacDataSize(1, maxCubemapSize), 0);
 385         ctx.expectError(GL_INVALID_VALUE);
 386         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, maxCubemapSize, 0, etc2EacDataSize(maxCubemapSize, maxCubemapSize), 0);
 387         ctx.expectError(GL_INVALID_VALUE);
 388         ctx.endSection();
 389
 390         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Z target");
 391         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, 1, 0, etc2EacDataSize(maxCubemapSize, 1), 0);
 392         ctx.expectError(GL_INVALID_VALUE);
 393         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 1, maxCubemapSize, 0, etc2EacDataSize(1, maxCubemapSize), 0);
 394         ctx.expectError(GL_INVALID_VALUE);
 395         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, maxCubemapSize, 0, etc2EacDataSize(maxCubemapSize, maxCubemapSize), 0);
 396         ctx.expectError(GL_INVALID_VALUE);
 397         ctx.endSection();
 398
 399         ctx.endSection();
 400 }
 401
 402 void compressedteximage2d_invalid_border (NegativeTestContext& ctx)
 403 {
 404         ctx.beginSection("GL_INVALID_VALUE is generated if border is not 0.");
 405
 406         ctx.beginSection("GL_TEXTURE_2D target");
 407         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 1, 0, 0);
 408         ctx.expectError(GL_INVALID_VALUE);
 409         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, -1, 0, 0);
 410         ctx.expectError(GL_INVALID_VALUE);
 411         ctx.endSection();
 412
 413         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_X target");
 414         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 1, 0, 0);
 415         ctx.expectError(GL_INVALID_VALUE);
 416         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, -1, 0, 0);
 417         ctx.expectError(GL_INVALID_VALUE);
 418         ctx.endSection();
 419
 420         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_Y target");
 421         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 1, 0, 0);
 422         ctx.expectError(GL_INVALID_VALUE);
 423         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, -1, 0, 0);
 424         ctx.expectError(GL_INVALID_VALUE);
 425         ctx.endSection();
 426
 427         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_Z target");
 428         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 1, 0, 0);
 429         ctx.expectError(GL_INVALID_VALUE);
 430         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, -1, 0, 0);
 431         ctx.expectError(GL_INVALID_VALUE);
 432         ctx.endSection();
 433
 434         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_X target");
 435         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 1, 0, 0);
 436         ctx.expectError(GL_INVALID_VALUE);
 437         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, -1, 0, 0);
 438         ctx.expectError(GL_INVALID_VALUE);
 439         ctx.endSection();
 440
 441         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Y target");
 442         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 1, 0, 0);
 443         ctx.expectError(GL_INVALID_VALUE);
 444         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, -1, 0, 0);
 445         ctx.expectError(GL_INVALID_VALUE);
 446         ctx.endSection();
 447
 448         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Z target");
 449         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 1, 0, 0);
 450         ctx.expectError(GL_INVALID_VALUE);
 451         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, -1, 0, 0);
 452         ctx.expectError(GL_INVALID_VALUE);
 453         ctx.endSection();
 454
 455         ctx.endSection();
 456 }
 457
 458 void compressedteximage2d_invalid_size (NegativeTestContext& ctx)
 459 {
 460         ctx.beginSection("GL_INVALID_VALUE is generated if imageSize is not consistent with the format, dimensions, and contents of the specified compressed image data.");
 461         // Subtracting 1 to the imageSize field to deviate from the expected size. Removing the -1 would cause the imageSize to be correct.
 462         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_R11_EAC, 1, 1, 0, divRoundUp(1, 4) * divRoundUp(1, 4) * 8 - 1, 0);
 463         ctx.expectError(GL_INVALID_VALUE);
 464         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SIGNED_R11_EAC, 1, 1, 0, divRoundUp(1, 4) * divRoundUp(1, 4) * 8 - 1, 0);
 465         ctx.expectError(GL_INVALID_VALUE);
 466         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RG11_EAC, 1, 1, 0, divRoundUp(1, 4) * divRoundUp(1, 4) * 16 - 1, 0);
 467         ctx.expectError(GL_INVALID_VALUE);
 468         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SIGNED_RG11_EAC, 1, 1, 0, divRoundUp(1, 4) * divRoundUp(1, 4) * 16 - 1, 0);
 469         ctx.expectError(GL_INVALID_VALUE);
 470         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB8_ETC2, 1, 1, 0, divRoundUp(1, 4) * divRoundUp(1, 4) * 8 - 1, 0);
 471         ctx.expectError(GL_INVALID_VALUE);
 472         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_ETC2, 1, 1, 0, divRoundUp(1, 4) * divRoundUp(1, 4) * 8 - 1, 0);
 473         ctx.expectError(GL_INVALID_VALUE);
 474         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, 1, 1, 0, divRoundUp(1, 4) * divRoundUp(1, 4) * 8 - 1, 0);
 475         ctx.expectError(GL_INVALID_VALUE);
 476         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, 1, 1, 0, divRoundUp(1, 4) * divRoundUp(1, 4) * 8 - 1, 0);
 477         ctx.expectError(GL_INVALID_VALUE);
 478         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 1, 1, 0, divRoundUp(1, 4) * divRoundUp(1, 4) * 16 - 1, 0);
 479         ctx.expectError(GL_INVALID_VALUE);
 480         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, 1, 1, 0, divRoundUp(1, 4) * divRoundUp(1, 4) * 16 - 1, 0);
 481         ctx.expectError(GL_INVALID_VALUE);
 482
 483         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
 484         {
 485             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_ASTC_4x4, 1, 1, 0, divRoundUp(1, 4) * divRoundUp(1, 4) * 16 - 1, 0);
 486             ctx.expectError(GL_INVALID_VALUE);
 487             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_ASTC_5x4, 1, 1, 0, divRoundUp(1, 5) * divRoundUp(1, 4) * 16 - 1, 0);
 488             ctx.expectError(GL_INVALID_VALUE);
 489             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_ASTC_5x5, 1, 1, 0, divRoundUp(1, 5) * divRoundUp(1, 5) * 16 - 1, 0);
 490             ctx.expectError(GL_INVALID_VALUE);
 491             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_ASTC_6x5, 1, 1, 0, divRoundUp(1, 6) * divRoundUp(1, 5) * 16 - 1, 0);
 492             ctx.expectError(GL_INVALID_VALUE);
 493             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_ASTC_6x6, 1, 1, 0, divRoundUp(1, 6) * divRoundUp(1, 6) * 16 - 1, 0);
 494             ctx.expectError(GL_INVALID_VALUE);
 495             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_ASTC_8x5, 1, 1, 0, divRoundUp(1, 8) * divRoundUp(1, 5) * 16 - 1, 0);
 496             ctx.expectError(GL_INVALID_VALUE);
 497             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_ASTC_8x6, 1, 1, 0, divRoundUp(1, 8) * divRoundUp(1, 6) * 16 - 1, 0);
 498             ctx.expectError(GL_INVALID_VALUE);
 499             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_ASTC_8x8, 1, 1, 0, divRoundUp(1, 8) * divRoundUp(1, 8) * 16 - 1, 0);
 500             ctx.expectError(GL_INVALID_VALUE);
 501             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_ASTC_10x5, 1, 1, 0, divRoundUp(1, 10) * divRoundUp(1, 5) * 16 - 1, 0);
 502             ctx.expectError(GL_INVALID_VALUE);
 503             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_ASTC_10x6, 1, 1, 0, divRoundUp(1, 10) * divRoundUp(1, 6) * 16 - 1, 0);
 504             ctx.expectError(GL_INVALID_VALUE);
 505             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_ASTC_10x8, 1, 1, 0, divRoundUp(1, 10) * divRoundUp(1, 8) * 16 - 1, 0);
 506             ctx.expectError(GL_INVALID_VALUE);
 507             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_ASTC_10x10, 1, 1, 0, divRoundUp(1, 10) * divRoundUp(1, 10) * 16 - 1, 0);
 508             ctx.expectError(GL_INVALID_VALUE);
 509             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_ASTC_12x10, 1, 1, 0, divRoundUp(1, 12) * divRoundUp(1, 10) * 16 - 1, 0);
 510             ctx.expectError(GL_INVALID_VALUE);
 511             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_ASTC_12x12, 1, 1, 0, divRoundUp(1, 12) * divRoundUp(1, 12) * 16 - 1, 0);
 512             ctx.expectError(GL_INVALID_VALUE);
 513             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4, 1, 1, 0, divRoundUp(1, 4) * divRoundUp(1, 4) * 16 - 1, 0);
 514             ctx.expectError(GL_INVALID_VALUE);
 515             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4, 1, 1, 0, divRoundUp(1, 5) * divRoundUp(1, 4) * 16 - 1, 0);
 516             ctx.expectError(GL_INVALID_VALUE);
 517             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5, 1, 1, 0, divRoundUp(1, 5) * divRoundUp(1, 5) * 16 - 1, 0);
 518             ctx.expectError(GL_INVALID_VALUE);
 519             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5, 1, 1, 0, divRoundUp(1, 6) * divRoundUp(1, 5) * 16 - 1, 0);
 520             ctx.expectError(GL_INVALID_VALUE);
 521             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6, 1, 1, 0, divRoundUp(1, 6) * divRoundUp(1, 6) * 16 - 1, 0);
 522             ctx.expectError(GL_INVALID_VALUE);
 523             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5, 1, 1, 0, divRoundUp(1, 8) * divRoundUp(1, 5) * 16 - 1, 0);
 524             ctx.expectError(GL_INVALID_VALUE);
 525             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6, 1, 1, 0, divRoundUp(1, 8) * divRoundUp(1, 6) * 16 - 1, 0);
 526             ctx.expectError(GL_INVALID_VALUE);
 527             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8, 1, 1, 0, divRoundUp(1, 8) * divRoundUp(1, 8) * 16 - 1, 0);
 528             ctx.expectError(GL_INVALID_VALUE);
 529             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5, 1, 1, 0, divRoundUp(1, 10) * divRoundUp(1, 5) * 16 - 1, 0);
 530             ctx.expectError(GL_INVALID_VALUE);
 531             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6, 1, 1, 0, divRoundUp(1, 10) * divRoundUp(1, 6) * 16 - 1, 0);
 532             ctx.expectError(GL_INVALID_VALUE);
 533             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8, 1, 1, 0, divRoundUp(1, 10) * divRoundUp(1, 8) * 16 - 1, 0);
 534             ctx.expectError(GL_INVALID_VALUE);
 535             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10, 1, 1, 0, divRoundUp(1, 10) * divRoundUp(1, 10) * 16 - 1, 0);
 536             ctx.expectError(GL_INVALID_VALUE);
 537             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10, 1, 1, 0, divRoundUp(1, 12) * divRoundUp(1, 10) * 16 - 1, 0);
 538             ctx.expectError(GL_INVALID_VALUE);
 539             ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12, 1, 1, 0, divRoundUp(1, 12) * divRoundUp(1, 12) * 16 - 1, 0);
 540             ctx.expectError(GL_INVALID_VALUE);
 541         }
 542         ctx.endSection();
 543 }
 544
 545 void compressedteximage2d_neg_size (NegativeTestContext& ctx)
 546 {
 547         ctx.beginSection("GL_INVALID_VALUE is generated if imageSize is negative.");
 548         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_R11_EAC, 0, 0, 0, -1, 0);
 549         ctx.expectError(GL_INVALID_VALUE);
 550         ctx.endSection();
 551 }
 552
 553 void compressedteximage2d_invalid_width_height (NegativeTestContext& ctx)
 554 {
 555         ctx.beginSection("GL_INVALID_VALUE is generated if target is a cube map face and width and height are not equal.");
 556
 557         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_X target");
 558         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_R11_EAC, 1, 2, 0, divRoundUp(1, 4) * divRoundUp(2, 4) * 8, 0);
 559         ctx.expectError(GL_INVALID_VALUE);
 560         ctx.endSection();
 561
 562         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_Y target");
 563         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_COMPRESSED_R11_EAC, 1, 2, 0, divRoundUp(1, 4) * divRoundUp(2, 4) * 8, 0);
 564         ctx.expectError(GL_INVALID_VALUE);
 565         ctx.endSection();
 566
 567         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_Z target");
 568         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_COMPRESSED_R11_EAC, 1, 2, 0, divRoundUp(1, 4) * divRoundUp(2, 4) * 8, 0);
 569         ctx.expectError(GL_INVALID_VALUE);
 570         ctx.endSection();
 571
 572         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_X target");
 573         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_COMPRESSED_R11_EAC, 1, 2, 0, divRoundUp(1, 4) * divRoundUp(2, 4) * 8, 0);
 574         ctx.expectError(GL_INVALID_VALUE);
 575         ctx.endSection();
 576
 577         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Y target");
 578         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_COMPRESSED_R11_EAC, 1, 2, 0, divRoundUp(1, 4) * divRoundUp(2, 4) * 8, 0);
 579         ctx.expectError(GL_INVALID_VALUE);
 580         ctx.endSection();
 581
 582         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Z target");
 583         ctx.glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_COMPRESSED_R11_EAC, 1, 2, 0, divRoundUp(1, 4) * divRoundUp(2, 4) * 8, 0);
 584         ctx.expectError(GL_INVALID_VALUE);
 585         ctx.endSection();
 586
 587         ctx.endSection();
 588 }
 589
 590 void compressedteximage2d_invalid_buffer_target (NegativeTestContext& ctx)
 591 {
 592         deUint32                                buf = 1234;
 593         std::vector<GLubyte>    data(64);
 594
 595         ctx.glGenBuffers                        (1, &buf);
 596         ctx.glBindBuffer                        (GL_PIXEL_UNPACK_BUFFER, buf);
 597         ctx.glBufferData                        (GL_PIXEL_UNPACK_BUFFER, 64, &data[0], GL_DYNAMIC_COPY);
 598         ctx.expectError                         (GL_NO_ERROR);
 599
 600         ctx.beginSection("GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and the buffer object's data store is currently mapped.");
 601         ctx.glMapBufferRange            (GL_PIXEL_UNPACK_BUFFER, 0, 32, GL_MAP_WRITE_BIT);
 602         ctx.glCompressedTexImage2D      (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB8_ETC2, 4, 4, 0, etc2DataSize(4, 4), 0);
 603         ctx.expectError                         (GL_INVALID_OPERATION);
 604         ctx.glUnmapBuffer                       (GL_PIXEL_UNPACK_BUFFER);
 605         ctx.endSection();
 606
 607         ctx.beginSection("GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
 608         ctx.glCompressedTexImage2D      (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB8_ETC2, 16, 16, 0, etc2DataSize(16, 16), 0);
 609         ctx.expectError                         (GL_INVALID_OPERATION);
 610         ctx.endSection();
 611
 612         ctx.glDeleteBuffers                     (1, &buf);
 613 }
 614
 615 // glCopyTexImage2D
 616
 617 void copyteximage2d_invalid_target (NegativeTestContext& ctx)
 618 {
 619         ctx.beginSection("GL_INVALID_ENUM is generated if target is invalid.");
 620         ctx.glCopyTexImage2D(0, 0, GL_RGB, 0, 0, 64, 64, 0);
 621         ctx.expectError(GL_INVALID_ENUM);
 622         ctx.endSection();
 623 }
 624
 625 void copyteximage2d_invalid_format (NegativeTestContext& ctx)
 626 {
 627         ctx.beginSection("GL_INVALID_ENUM or GL_INVALID_VALUE is generated if internalformat is not an accepted format.");
 628         ctx.glCopyTexImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 64, 64, 0);
 629         ctx.expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
 630         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, 0, 0, 0, 16, 16, 0);
 631         ctx.expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
 632         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, 0, 0, 0, 16, 16, 0);
 633         ctx.expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
 634         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, 0, 0, 0, 16, 16, 0);
 635         ctx.expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
 636         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, 0, 0, 0, 16, 16, 0);
 637         ctx.expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
 638         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, 0, 0, 0, 16, 16, 0);
 639         ctx.expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
 640         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, 0, 0, 0, 16, 16, 0);
 641         ctx.expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
 642         ctx.endSection();
 643 }
 644
 645 void copyteximage2d_inequal_width_height_cube (NegativeTestContext& ctx)
 646 {
 647         ctx.beginSection("GL_INVALID_VALUE is generated if target is one of the six cube map 2D image targets and the width and height parameters are not equal.");
 648         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 16, 17, 0);
 649         ctx.expectError(GL_INVALID_VALUE);
 650         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, 16, 17, 0);
 651         ctx.expectError(GL_INVALID_VALUE);
 652         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, 16, 17, 0);
 653         ctx.expectError(GL_INVALID_VALUE);
 654         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, 16, 17, 0);
 655         ctx.expectError(GL_INVALID_VALUE);
 656         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, 16, 17, 0);
 657         ctx.expectError(GL_INVALID_VALUE);
 658         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, 16, 17, 0);
 659         ctx.expectError(GL_INVALID_VALUE);
 660         ctx.endSection();
 661 }
 662
 663 void copyteximage2d_neg_level (NegativeTestContext& ctx)
 664 {
 665         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
 666         ctx.glCopyTexImage2D(GL_TEXTURE_2D, -1, GL_RGB, 0, 0, 64, 64, 0);
 667         ctx.expectError(GL_INVALID_VALUE);
 668         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, -1, GL_RGB, 0, 0, 16, 16, 0);
 669         ctx.expectError(GL_INVALID_VALUE);
 670         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, -1, GL_RGB, 0, 0, 16, 16, 0);
 671         ctx.expectError(GL_INVALID_VALUE);
 672         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, -1, GL_RGB, 0, 0, 16, 16, 0);
 673         ctx.expectError(GL_INVALID_VALUE);
 674         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, -1, GL_RGB, 0, 0, 16, 16, 0);
 675         ctx.expectError(GL_INVALID_VALUE);
 676         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, -1, GL_RGB, 0, 0, 16, 16, 0);
 677         ctx.expectError(GL_INVALID_VALUE);
 678         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, -1, GL_RGB, 0, 0, 16, 16, 0);
 679         ctx.expectError(GL_INVALID_VALUE);
 680         ctx.endSection();
 681 }
 682
 683 void copyteximage2d_max_level (NegativeTestContext& ctx)
 684 {
 685         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
 686         deUint32 log2MaxTextureSize = deLog2Floor32(ctx.getInteger(GL_MAX_TEXTURE_SIZE)) + 1;
 687         ctx.glCopyTexImage2D(GL_TEXTURE_2D, log2MaxTextureSize, GL_RGB, 0, 0, 64, 64, 0);
 688         ctx.expectError(GL_INVALID_VALUE);
 689         ctx.endSection();
 690
 691         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_TEXTURE_SIZE).");
 692         deUint32 log2MaxCubemapSize = deLog2Floor32(ctx.getInteger(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
 693         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, log2MaxCubemapSize, GL_RGB, 0, 0, 16, 16, 0);
 694         ctx.expectError(GL_INVALID_VALUE);
 695         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, log2MaxCubemapSize, GL_RGB, 0, 0, 16, 16, 0);
 696         ctx.expectError(GL_INVALID_VALUE);
 697         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, log2MaxCubemapSize, GL_RGB, 0, 0, 16, 16, 0);
 698         ctx.expectError(GL_INVALID_VALUE);
 699         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, log2MaxCubemapSize, GL_RGB, 0, 0, 16, 16, 0);
 700         ctx.expectError(GL_INVALID_VALUE);
 701         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, log2MaxCubemapSize, GL_RGB, 0, 0, 16, 16, 0);
 702         ctx.expectError(GL_INVALID_VALUE);
 703         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, log2MaxCubemapSize, GL_RGB, 0, 0, 16, 16, 0);
 704         ctx.expectError(GL_INVALID_VALUE);
 705         ctx.endSection();
 706 }
 707
 708 void copyteximage2d_neg_width_height (NegativeTestContext& ctx)
 709 {
 710         ctx.beginSection("GL_INVALID_VALUE is generated if width or height is less than 0.");
 711
 712         ctx.beginSection("GL_TEXTURE_2D target");
 713         ctx.glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, -1, 1, 0);
 714         ctx.expectError(GL_INVALID_VALUE);
 715         ctx.glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 1, -1, 0);
 716         ctx.expectError(GL_INVALID_VALUE);
 717         ctx.glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, -1, -1, 0);
 718         ctx.expectError(GL_INVALID_VALUE);
 719         ctx.endSection();
 720
 721         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_X target");
 722         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, -1, 1, 0);
 723         ctx.expectError(GL_INVALID_VALUE);
 724         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 1, -1, 0);
 725         ctx.expectError(GL_INVALID_VALUE);
 726         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, -1, -1, 0);
 727         ctx.expectError(GL_INVALID_VALUE);
 728         ctx.endSection();
 729
 730         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_Y target");
 731         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, -1, 1, 0);
 732         ctx.expectError(GL_INVALID_VALUE);
 733         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, 1, -1, 0);
 734         ctx.expectError(GL_INVALID_VALUE);
 735         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, -1, -1, 0);
 736         ctx.expectError(GL_INVALID_VALUE);
 737         ctx.endSection();
 738
 739         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_Z target");
 740         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, -1, 1, 0);
 741         ctx.expectError(GL_INVALID_VALUE);
 742         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, 1, -1, 0);
 743         ctx.expectError(GL_INVALID_VALUE);
 744         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, -1, -1, 0);
 745         ctx.expectError(GL_INVALID_VALUE);
 746         ctx.endSection();
 747
 748         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_X target");
 749         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, -1, 1, 0);
 750         ctx.expectError(GL_INVALID_VALUE);
 751         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, 1, -1, 0);
 752         ctx.expectError(GL_INVALID_VALUE);
 753         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, -1, -1, 0);
 754         ctx.expectError(GL_INVALID_VALUE);
 755         ctx.endSection();
 756
 757         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Y target");
 758         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, -1, 1, 0);
 759         ctx.expectError(GL_INVALID_VALUE);
 760         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, 1, -1, 0);
 761         ctx.expectError(GL_INVALID_VALUE);
 762         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, -1, -1, 0);
 763         ctx.expectError(GL_INVALID_VALUE);
 764         ctx.endSection();
 765
 766         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Z target");
 767         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, -1, 1, 0);
 768         ctx.expectError(GL_INVALID_VALUE);
 769         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, 1, -1, 0);
 770         ctx.expectError(GL_INVALID_VALUE);
 771         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, -1, -1, 0);
 772         ctx.expectError(GL_INVALID_VALUE);
 773         ctx.endSection();
 774
 775         ctx.endSection();
 776 }
 777
 778 void copyteximage2d_max_width_height (NegativeTestContext& ctx)
 779 {
 780         int maxTextureSize = ctx.getInteger(GL_MAX_TEXTURE_SIZE) + 1;
 781         int maxCubemapSize = ctx.getInteger(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
 782
 783         ctx.beginSection("GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_TEXTURE_SIZE.");
 784
 785         ctx.beginSection("GL_TEXTURE_2D target");
 786         ctx.glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, maxTextureSize, 1, 0);
 787         ctx.expectError(GL_INVALID_VALUE);
 788         ctx.glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 1, maxTextureSize, 0);
 789         ctx.expectError(GL_INVALID_VALUE);
 790         ctx.glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, maxTextureSize, maxTextureSize, 0);
 791         ctx.expectError(GL_INVALID_VALUE);
 792         ctx.endSection();
 793
 794         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_X target");
 795         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 1, maxCubemapSize, 0);
 796         ctx.expectError(GL_INVALID_VALUE);
 797         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, maxCubemapSize, 1, 0);
 798         ctx.expectError(GL_INVALID_VALUE);
 799         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, maxCubemapSize, maxCubemapSize, 0);
 800         ctx.expectError(GL_INVALID_VALUE);
 801         ctx.endSection();
 802
 803         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_Y target");
 804         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, 1, maxCubemapSize, 0);
 805         ctx.expectError(GL_INVALID_VALUE);
 806         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, maxCubemapSize, 1, 0);
 807         ctx.expectError(GL_INVALID_VALUE);
 808         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, maxCubemapSize, maxCubemapSize, 0);
 809         ctx.expectError(GL_INVALID_VALUE);
 810         ctx.endSection();
 811
 812         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_Z target");
 813         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, 1, maxCubemapSize, 0);
 814         ctx.expectError(GL_INVALID_VALUE);
 815         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, maxCubemapSize, 1, 0);
 816         ctx.expectError(GL_INVALID_VALUE);
 817         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, maxCubemapSize, maxCubemapSize, 0);
 818         ctx.expectError(GL_INVALID_VALUE);
 819         ctx.endSection();
 820
 821         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_X target");
 822         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, 1, maxCubemapSize, 0);
 823         ctx.expectError(GL_INVALID_VALUE);
 824         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, maxCubemapSize, 1, 0);
 825         ctx.expectError(GL_INVALID_VALUE);
 826         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, maxCubemapSize, maxCubemapSize, 0);
 827         ctx.expectError(GL_INVALID_VALUE);
 828         ctx.endSection();
 829
 830         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Y target");
 831         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, 1, maxCubemapSize, 0);
 832         ctx.expectError(GL_INVALID_VALUE);
 833         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, maxCubemapSize, 1, 0);
 834         ctx.expectError(GL_INVALID_VALUE);
 835         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, maxCubemapSize, maxCubemapSize, 0);
 836         ctx.expectError(GL_INVALID_VALUE);
 837         ctx.endSection();
 838
 839         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Z target");
 840         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, 1, maxCubemapSize, 0);
 841         ctx.expectError(GL_INVALID_VALUE);
 842         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, maxCubemapSize, 1, 0);
 843         ctx.expectError(GL_INVALID_VALUE);
 844         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, maxCubemapSize, maxCubemapSize, 0);
 845         ctx.expectError(GL_INVALID_VALUE);
 846         ctx.endSection();
 847
 848         ctx.endSection();
 849 }
 850
 851 void copyteximage2d_invalid_border (NegativeTestContext& ctx)
 852 {
 853         ctx.beginSection("GL_INVALID_VALUE is generated if border is not 0.");
 854
 855         ctx.beginSection("GL_TEXTURE_2D target");
 856         ctx.glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 0, 0, -1);
 857         ctx.expectError(GL_INVALID_VALUE);
 858         ctx.glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 0, 0, 1);
 859         ctx.expectError(GL_INVALID_VALUE);
 860         ctx.endSection();
 861
 862         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_X target");
 863         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 0, 0, -1);
 864         ctx.expectError(GL_INVALID_VALUE);
 865         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 0, 0, 1);
 866         ctx.expectError(GL_INVALID_VALUE);
 867         ctx.endSection();
 868
 869         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_Y target");
 870         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, 0, 0, -1);
 871         ctx.expectError(GL_INVALID_VALUE);
 872         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, 0, 0, 1);
 873         ctx.expectError(GL_INVALID_VALUE);
 874         ctx.endSection();
 875
 876         ctx.beginSection("GL_TEXTURE_2D target");
 877         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, 0, 0, -1);
 878         ctx.expectError(GL_INVALID_VALUE);
 879         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, 0, 0, 1);
 880         ctx.expectError(GL_INVALID_VALUE);
 881         ctx.endSection();
 882
 883         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_X target");
 884         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, 0, 0, -1);
 885         ctx.expectError(GL_INVALID_VALUE);
 886         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, 0, 0, 1);
 887         ctx.expectError(GL_INVALID_VALUE);
 888         ctx.endSection();
 889
 890         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Y target");
 891         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, 0, 0, -1);
 892         ctx.expectError(GL_INVALID_VALUE);
 893         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, 0, 0, 1);
 894         ctx.expectError(GL_INVALID_VALUE);
 895         ctx.endSection();
 896
 897         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Z target");
 898         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, 0, 0, -1);
 899         ctx.expectError(GL_INVALID_VALUE);
 900         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, 0, 0, 1);
 901         ctx.expectError(GL_INVALID_VALUE);
 902         ctx.endSection();
 903
 904         ctx.endSection();
 905 }
 906
 907 void copyteximage2d_incomplete_framebuffer (NegativeTestContext& ctx)
 908 {
 909         GLuint fbo = 0x1234;
 910         ctx.glGenFramebuffers           (1, &fbo);
 911         ctx.glBindFramebuffer           (GL_FRAMEBUFFER, fbo);
 912         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
 913
 914         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
 915         ctx.glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 0, 0, 0, 0, 0);
 916         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 917         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA8, 0, 0, 0, 0, 0);
 918         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 919         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGBA8, 0, 0, 0, 0, 0);
 920         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 921         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGBA8, 0, 0, 0, 0, 0);
 922         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 923         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGBA8, 0, 0, 0, 0, 0);
 924         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 925         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGBA8, 0, 0, 0, 0, 0);
 926         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 927         ctx.glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGBA8, 0, 0, 0, 0, 0);
 928         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 929         ctx.endSection();
 930
 931         ctx.glBindFramebuffer   (GL_FRAMEBUFFER, 0);
 932         ctx.glDeleteFramebuffers(1, &fbo);
 933 }
 934
 935 void copytexsubimage2d_invalid_target (NegativeTestContext& ctx)
 936 {
 937         GLuint texture = 0x1234;
 938         ctx.glGenTextures       (1, &texture);
 939         ctx.glBindTexture       (GL_TEXTURE_2D, texture);
 940         ctx.glTexImage2D        (GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 941
 942         ctx.beginSection("GL_INVALID_ENUM is generated if target is invalid.");
 943         ctx.glCopyTexSubImage2D(0, 0, 0, 0, 0, 0, 4, 4);
 944         ctx.expectError(GL_INVALID_ENUM);
 945         ctx.endSection();
 946
 947         ctx.glDeleteTextures(1, &texture);
 948 }
 949 void copytexsubimage2d_read_buffer_is_none (NegativeTestContext& ctx)
 950 {
 951         GLuint texture = 0x1234;
 952         ctx.glGenTextures       (1, &texture);
 953         ctx.glBindTexture       (GL_TEXTURE_2D, texture);
 954         ctx.glTexImage2D        (GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 955
 956         ctx.beginSection("GL_INVALID_OPERATION is generated if the read buffer is NONE");
 957         ctx.glReadBuffer(GL_NONE);
 958         ctx.glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 4, 4);
 959         ctx.expectError(GL_INVALID_OPERATION);
 960         ctx.endSection();
 961
 962         ctx.glDeleteTextures(1, &texture);
 963 }
 964
 965 void copytexsubimage2d_texture_internalformat (NegativeTestContext& ctx)
 966 {
 967         GLuint texture = 0x1234;
 968         ctx.glGenTextures       (1, &texture);
 969         ctx.glBindTexture       (GL_TEXTURE_2D, texture);
 970         ctx.glTexImage2D        (GL_TEXTURE_2D, 0, GL_RGB9_E5, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 971
 972         ctx.beginSection("GL_INVALID_OPERATION is generated if internal format of the texture is GL_RGB9_E5");
 973         ctx.glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 4, 4);
 974         ctx.expectError(GL_INVALID_OPERATION);
 975         ctx.endSection();
 976
 977         ctx.glDeleteTextures(1, &texture);
 978 }
 979
 980 void copytexsubimage2d_neg_level (NegativeTestContext& ctx)
 981 {
 982         GLuint textures[2];
 983         ctx.glGenTextures       (2, &textures[0]);
 984         ctx.glBindTexture       (GL_TEXTURE_2D, textures[0]);
 985         ctx.glTexImage2D        (GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 986         ctx.glBindTexture       (GL_TEXTURE_CUBE_MAP, textures[1]);
 987         FOR_CUBE_FACES(faceGL, ctx.glTexImage2D(faceGL, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0););
 988
 989         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
 990         ctx.glCopyTexSubImage2D(GL_TEXTURE_2D, -1, 0, 0, 0, 0, 4, 4);
 991         ctx.expectError(GL_INVALID_VALUE);
 992         FOR_CUBE_FACES(faceGL,
 993         {
 994                 ctx.glCopyTexSubImage2D(faceGL, -1, 0, 0, 0, 0, 4, 4);
 995                 ctx.expectError(GL_INVALID_VALUE);
 996         });
 997         ctx.endSection();
 998
 999         ctx.glDeleteTextures(2, &textures[0]);
1000 }
1001
1002 void copytexsubimage2d_max_level (NegativeTestContext& ctx)
1003 {
1004         GLuint textures[2];
1005         ctx.glGenTextures       (2, &textures[0]);
1006         ctx.glBindTexture       (GL_TEXTURE_2D, textures[0]);
1007         ctx.glTexImage2D        (GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1008         ctx.glBindTexture       (GL_TEXTURE_CUBE_MAP, textures[1]);
1009         FOR_CUBE_FACES(faceGL, ctx.glTexImage2D(faceGL, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0););
1010
1011         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE) for 2D texture targets.");
1012         deUint32 log2MaxTextureSize = deLog2Floor32(ctx.getInteger(GL_MAX_TEXTURE_SIZE)) + 1;
1013         ctx.glCopyTexSubImage2D(GL_TEXTURE_2D, log2MaxTextureSize, 0, 0, 0, 0, 4, 4);
1014         ctx.expectError(GL_INVALID_VALUE);
1015         ctx.endSection();
1016
1017         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_SIZE) for cubemap targets.");
1018         deUint32 log2MaxCubemapSize = deLog2Floor32(ctx.getInteger(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
1019         FOR_CUBE_FACES(faceGL,
1020         {
1021                 ctx.glCopyTexSubImage2D(faceGL, log2MaxCubemapSize, 0, 0, 0, 0, 4, 4);
1022                 ctx.expectError(GL_INVALID_VALUE);
1023         });
1024         ctx.endSection();
1025
1026         ctx.glDeleteTextures(2, &textures[0]);
1027 }
1028
1029 void copytexsubimage2d_neg_offset (NegativeTestContext& ctx)
1030 {
1031         GLuint texture = 0x1234;
1032         ctx.glGenTextures       (1, &texture);
1033         ctx.glBindTexture       (GL_TEXTURE_2D, texture);
1034         ctx.glTexImage2D        (GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1035
1036         ctx.beginSection("GL_INVALID_VALUE is generated if xoffset < 0 or yoffset < 0.");
1037         ctx.glCopyTexSubImage2D(GL_TEXTURE_2D, 0, -1, 0, 0, 0, 4, 4);
1038         ctx.expectError(GL_INVALID_VALUE);
1039         ctx.glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, -1, 0, 0, 4, 4);
1040         ctx.expectError(GL_INVALID_VALUE);
1041         ctx.glCopyTexSubImage2D(GL_TEXTURE_2D, 0, -1, -1, 0, 0, 4, 4);
1042         ctx.expectError(GL_INVALID_VALUE);
1043         ctx.endSection();
1044
1045         ctx.glDeleteTextures(1, &texture);
1046 }
1047
1048 void copytexsubimage2d_invalid_offset (NegativeTestContext& ctx)
1049 {
1050         GLuint texture = 0x1234;
1051         ctx.glGenTextures       (1, &texture);
1052         ctx.glBindTexture       (GL_TEXTURE_2D, texture);
1053         ctx.glTexImage2D        (GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1054
1055         ctx.beginSection("GL_INVALID_VALUE is generated if xoffset + width > texture_width or yoffset + height > texture_height.");
1056         ctx.glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 14, 0, 0, 0, 4, 4);
1057         ctx.expectError(GL_INVALID_VALUE);
1058         ctx.glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 14, 0, 0, 4, 4);
1059         ctx.expectError(GL_INVALID_VALUE);
1060         ctx.glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 14, 14, 0, 0, 4, 4);
1061         ctx.expectError(GL_INVALID_VALUE);
1062         ctx.endSection();
1063
1064         ctx.glDeleteTextures(1, &texture);
1065 }
1066
1067 void copytexsubimage2d_neg_width_height (NegativeTestContext& ctx)
1068 {
1069         GLuint texture = 0x1234;
1070         ctx.glGenTextures       (1, &texture);
1071         ctx.glBindTexture       (GL_TEXTURE_2D, texture);
1072         ctx.glTexImage2D        (GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1073
1074         ctx.beginSection("GL_INVALID_VALUE is generated if width or height is less than 0.");
1075         ctx.glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, -1, 0);
1076         ctx.expectError(GL_INVALID_VALUE);
1077         ctx.glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, -1);
1078         ctx.expectError(GL_INVALID_VALUE);
1079         ctx.glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, -1, -1);
1080         ctx.expectError(GL_INVALID_VALUE);
1081         ctx.endSection();
1082
1083         ctx.glDeleteTextures(1, &texture);
1084 }
1085
1086 void copytexsubimage2d_incomplete_framebuffer (NegativeTestContext& ctx)
1087 {
1088         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
1089
1090         GLuint texture[2];
1091         GLuint fbo = 0x1234;
1092
1093         ctx.glGenTextures                       (2, texture);
1094         ctx.glBindTexture                       (GL_TEXTURE_2D, texture[0]);
1095         ctx.glTexImage2D                        (GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1096         ctx.glBindTexture                       (GL_TEXTURE_CUBE_MAP, texture[1]);
1097         ctx.glTexImage2D                        (GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1098         ctx.glTexImage2D                        (GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1099         ctx.glTexImage2D                        (GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1100         ctx.glTexImage2D                        (GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1101         ctx.glTexImage2D                        (GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1102         ctx.glTexImage2D                        (GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1103         ctx.expectError(GL_NO_ERROR);
1104
1105         ctx.glGenFramebuffers(1, &fbo);
1106         ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1107         ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1108         ctx.expectError(GL_NO_ERROR);
1109
1110         ctx.glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 0);
1111         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1112         ctx.glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, 0, 0, 0, 0, 0, 0);
1113         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1114         ctx.glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, 0, 0, 0, 0, 0, 0);
1115         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1116         ctx.glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, 0, 0, 0, 0, 0, 0);
1117         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1118         ctx.glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, 0, 0, 0, 0, 0, 0);
1119         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1120         ctx.glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, 0, 0, 0, 0, 0, 0);
1121         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1122         ctx.glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, 0, 0, 0, 0, 0, 0);
1123         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1124
1125         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1126         ctx.glDeleteFramebuffers(1, &fbo);
1127         ctx.glDeleteTextures(2, texture);
1128
1129         ctx.endSection();
1130 }
1131
1132 // glDeleteTextures
1133
1134 void deletetextures (NegativeTestContext& ctx)
1135 {
1136         GLuint texture = 0x1234;
1137         ctx.glGenTextures(1, &texture);
1138
1139         ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
1140         ctx.glDeleteTextures(-1, 0);
1141         ctx.expectError(GL_INVALID_VALUE);
1142
1143         ctx.glBindTexture(GL_TEXTURE_2D, texture);
1144         ctx.glDeleteTextures(-1, 0);
1145         ctx.expectError(GL_INVALID_VALUE);
1146         ctx.endSection();
1147
1148         ctx.glDeleteTextures(1, &texture);
1149 }
1150
1151 // glGenerateMipmap
1152
1153 void generatemipmap (NegativeTestContext& ctx)
1154 {
1155         GLuint texture[2];
1156         ctx.glGenTextures(2, texture);
1157
1158         ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_TEXTURE_2D or GL_TEXTURE_CUBE_MAP.");
1159         ctx.glGenerateMipmap(0);
1160         ctx.expectError(GL_INVALID_ENUM);
1161         ctx.endSection();
1162
1163         ctx.beginSection("INVALID_OPERATION is generated if the texture bound to target is not cube complete.");
1164         ctx.glBindTexture(GL_TEXTURE_CUBE_MAP, texture[0]);
1165         ctx.glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_REPEAT);
1166         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1167         ctx.glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
1168         ctx.expectError(GL_INVALID_OPERATION);
1169
1170         ctx.glBindTexture(GL_TEXTURE_CUBE_MAP, texture[0]);
1171         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1172         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1173         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1174         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1175         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1176         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 32, 32, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1177         ctx.glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
1178         ctx.expectError(GL_INVALID_OPERATION);
1179         ctx.endSection();
1180
1181         ctx.beginSection("GL_INVALID_OPERATION is generated if the zero level array is stored in a compressed internal format.");
1182         ctx.glBindTexture(GL_TEXTURE_2D, texture[1]);
1183         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
1184         ctx.glGenerateMipmap(GL_TEXTURE_2D);
1185         ctx.expectError(GL_INVALID_OPERATION);
1186         ctx.endSection();
1187
1188         ctx.beginSection("GL_INVALID_OPERATION is generated if the level base array was not specified with an unsized internal format or a sized internal format that is both color-renderable and texture-filterable.");
1189         ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8_SNORM, 0, 0, 0, GL_RGB, GL_BYTE, 0);
1190         ctx.glGenerateMipmap(GL_TEXTURE_2D);
1191         ctx.expectError(GL_INVALID_OPERATION);
1192         ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_R8I, 0, 0, 0, GL_RED_INTEGER, GL_BYTE, 0);
1193         ctx.glGenerateMipmap(GL_TEXTURE_2D);
1194         ctx.expectError(GL_INVALID_OPERATION);
1195
1196         if (!(ctx.getContextInfo().isExtensionSupported("GL_EXT_color_buffer_float") && ctx.getContextInfo().isExtensionSupported("GL_OES_texture_float_linear")))
1197         {
1198                 ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 0, 0, 0, GL_RGBA, GL_FLOAT, 0);
1199                 ctx.glGenerateMipmap(GL_TEXTURE_2D);
1200                 ctx.expectError(GL_INVALID_OPERATION);
1201         }
1202
1203         ctx.endSection();
1204
1205         ctx.glDeleteTextures(2, texture);
1206 }
1207
1208 // glGenTextures
1209
1210 void gentextures (NegativeTestContext& ctx)
1211 {
1212         ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
1213         ctx.glGenTextures(-1, 0);
1214         ctx.expectError(GL_INVALID_VALUE);
1215         ctx.endSection();
1216 }
1217
1218 // glPixelStorei
1219
1220 void pixelstorei (NegativeTestContext& ctx)
1221 {
1222         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value.");
1223         ctx.glPixelStorei(0,1);
1224         ctx.expectError(GL_INVALID_ENUM);
1225         ctx.endSection();
1226
1227         ctx.beginSection("GL_INVALID_VALUE is generated if a negative row length, pixel skip, or row skip value is specified, or if alignment is specified as other than 1, 2, 4, or 8.");
1228         ctx.glPixelStorei(GL_PACK_ROW_LENGTH, -1);
1229         ctx.expectError(GL_INVALID_VALUE);
1230         ctx.glPixelStorei(GL_PACK_SKIP_ROWS, -1);
1231         ctx.expectError(GL_INVALID_VALUE);
1232         ctx.glPixelStorei(GL_PACK_SKIP_PIXELS, -1);
1233         ctx.expectError(GL_INVALID_VALUE);
1234         ctx.glPixelStorei(GL_UNPACK_ROW_LENGTH, -1);
1235         ctx.expectError(GL_INVALID_VALUE);
1236         ctx.glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, -1);
1237         ctx.expectError(GL_INVALID_VALUE);
1238         ctx.glPixelStorei(GL_UNPACK_SKIP_ROWS, -1);
1239         ctx.expectError(GL_INVALID_VALUE);
1240         ctx.glPixelStorei(GL_UNPACK_SKIP_PIXELS, -1);
1241         ctx.expectError(GL_INVALID_VALUE);
1242         ctx.glPixelStorei(GL_UNPACK_SKIP_IMAGES, -1);
1243         ctx.expectError(GL_INVALID_VALUE);
1244         ctx.glPixelStorei(GL_PACK_ALIGNMENT, 0);
1245         ctx.expectError(GL_INVALID_VALUE);
1246         ctx.glPixelStorei(GL_UNPACK_ALIGNMENT, 0);
1247         ctx.expectError(GL_INVALID_VALUE);
1248         ctx.glPixelStorei(GL_PACK_ALIGNMENT, 16);
1249         ctx.expectError(GL_INVALID_VALUE);
1250         ctx.glPixelStorei(GL_UNPACK_ALIGNMENT, 16);
1251         ctx.expectError(GL_INVALID_VALUE);
1252         ctx.endSection();
1253 }
1254
1255 // glTexImage2D
1256
1257 void teximage2d (NegativeTestContext& ctx)
1258 {
1259         ctx.beginSection("GL_INVALID_ENUM is generated if target is invalid.");
1260         ctx.glTexImage2D(0, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1261         ctx.expectError(GL_INVALID_ENUM);
1262         ctx.endSection();
1263
1264         ctx.beginSection("GL_INVALID_ENUM is generated if type is not a type constant.");
1265         ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, 0, 0);
1266         ctx.expectError(GL_INVALID_ENUM);
1267         ctx.endSection();
1268
1269         ctx.beginSection("GL_INVALID_OPERATION is generated if the combination of internalFormat, format and type is invalid.");
1270         ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1271         ctx.expectError(GL_INVALID_OPERATION);
1272         ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, 0);
1273         ctx.expectError(GL_INVALID_OPERATION);
1274         ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB5_A1, 1, 1, 0, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, 0);
1275         ctx.expectError(GL_INVALID_OPERATION);
1276         ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB10_A2, 1, 1, 0, GL_RGB, GL_UNSIGNED_INT_2_10_10_10_REV, 0);
1277         ctx.expectError(GL_INVALID_OPERATION);
1278         ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32UI, 1, 1, 0, GL_RGBA_INTEGER, GL_INT, 0);
1279         ctx.expectError(GL_INVALID_OPERATION);
1280         ctx.endSection();
1281 }
1282
1283 void teximage2d_inequal_width_height_cube (NegativeTestContext& ctx)
1284 {
1285         ctx.beginSection("GL_INVALID_VALUE is generated if target is one of the six cube map 2D image targets and the width and height parameters are not equal.");
1286         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1287         ctx.expectError(GL_INVALID_VALUE);
1288         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1289         ctx.expectError(GL_INVALID_VALUE);
1290         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1291         ctx.expectError(GL_INVALID_VALUE);
1292         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1293         ctx.expectError(GL_INVALID_VALUE);
1294         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1295         ctx.expectError(GL_INVALID_VALUE);
1296         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1297         ctx.expectError(GL_INVALID_VALUE);
1298         ctx.endSection();
1299 }
1300
1301 void teximage2d_neg_level (NegativeTestContext& ctx)
1302 {
1303         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
1304         ctx.glTexImage2D(GL_TEXTURE_2D, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1305         ctx.expectError(GL_INVALID_VALUE);
1306         ctx.endSection();
1307
1308         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
1309         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1310         ctx.expectError(GL_INVALID_VALUE);
1311         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1312         ctx.expectError(GL_INVALID_VALUE);
1313         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1314         ctx.expectError(GL_INVALID_VALUE);
1315         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1316         ctx.expectError(GL_INVALID_VALUE);
1317         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1318         ctx.expectError(GL_INVALID_VALUE);
1319         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1320         ctx.expectError(GL_INVALID_VALUE);
1321         ctx.endSection();
1322 }
1323
1324 void teximage2d_max_level (NegativeTestContext& ctx)
1325 {
1326         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
1327         deUint32 log2MaxTextureSize = deLog2Floor32(ctx.getInteger(GL_MAX_TEXTURE_SIZE)) + 1;
1328         ctx.glTexImage2D(GL_TEXTURE_2D, log2MaxTextureSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1329         ctx.expectError(GL_INVALID_VALUE);
1330         ctx.endSection();
1331
1332         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_TEXTURE_SIZE).");
1333         deUint32 log2MaxCubemapSize = deLog2Floor32(ctx.getInteger(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
1334         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, log2MaxCubemapSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1335         ctx.expectError(GL_INVALID_VALUE);
1336         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, log2MaxCubemapSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1337         ctx.expectError(GL_INVALID_VALUE);
1338         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, log2MaxCubemapSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1339         ctx.expectError(GL_INVALID_VALUE);
1340         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, log2MaxCubemapSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1341         ctx.expectError(GL_INVALID_VALUE);
1342         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, log2MaxCubemapSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1343         ctx.expectError(GL_INVALID_VALUE);
1344         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, log2MaxCubemapSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1345         ctx.expectError(GL_INVALID_VALUE);
1346         ctx.endSection();
1347 }
1348
1349 void teximage2d_neg_width_height (NegativeTestContext& ctx)
1350 {
1351         ctx.beginSection("GL_INVALID_VALUE is generated if width or height is less than 0.");
1352
1353         ctx.beginSection("GL_TEXTURE_2D target");
1354         ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1355         ctx.expectError(GL_INVALID_VALUE);
1356         ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1357         ctx.expectError(GL_INVALID_VALUE);
1358         ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1359         ctx.expectError(GL_INVALID_VALUE);
1360         ctx.endSection();
1361
1362         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_X target");
1363         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1364         ctx.expectError(GL_INVALID_VALUE);
1365         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1366         ctx.expectError(GL_INVALID_VALUE);
1367         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1368         ctx.expectError(GL_INVALID_VALUE);
1369         ctx.endSection();
1370
1371         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_Y target");
1372         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1373         ctx.expectError(GL_INVALID_VALUE);
1374         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1375         ctx.expectError(GL_INVALID_VALUE);
1376         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1377         ctx.expectError(GL_INVALID_VALUE);
1378         ctx.endSection();
1379
1380         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_Z target");
1381         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1382         ctx.expectError(GL_INVALID_VALUE);
1383         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1384         ctx.expectError(GL_INVALID_VALUE);
1385         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1386         ctx.expectError(GL_INVALID_VALUE);
1387         ctx.endSection();
1388
1389         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_X target");
1390         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1391         ctx.expectError(GL_INVALID_VALUE);
1392         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1393         ctx.expectError(GL_INVALID_VALUE);
1394         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1395         ctx.expectError(GL_INVALID_VALUE);
1396         ctx.endSection();
1397
1398         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Y target");
1399         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1400         ctx.expectError(GL_INVALID_VALUE);
1401         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1402         ctx.expectError(GL_INVALID_VALUE);
1403         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1404         ctx.expectError(GL_INVALID_VALUE);
1405         ctx.endSection();
1406
1407         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Z target");
1408         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1409         ctx.expectError(GL_INVALID_VALUE);
1410         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1411         ctx.expectError(GL_INVALID_VALUE);
1412         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1413         ctx.expectError(GL_INVALID_VALUE);
1414         ctx.endSection();
1415
1416         ctx.endSection();
1417 }
1418
1419 void teximage2d_max_width_height (NegativeTestContext& ctx)
1420 {
1421         int maxTextureSize = ctx.getInteger(GL_MAX_TEXTURE_SIZE) + 1;
1422         int maxCubemapSize = ctx.getInteger(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
1423
1424         ctx.beginSection("GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_TEXTURE_SIZE.");
1425         ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, maxTextureSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1426         ctx.expectError(GL_INVALID_VALUE);
1427         ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1428         ctx.expectError(GL_INVALID_VALUE);
1429         ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, maxTextureSize, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1430         ctx.expectError(GL_INVALID_VALUE);
1431         ctx.endSection();
1432
1433         ctx.beginSection("GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
1434
1435         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_X target");
1436         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, maxCubemapSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1437         ctx.expectError(GL_INVALID_VALUE);
1438         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 1, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1439         ctx.expectError(GL_INVALID_VALUE);
1440         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, maxCubemapSize, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1441         ctx.expectError(GL_INVALID_VALUE);
1442         ctx.endSection();
1443
1444         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_Y target");
1445         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, maxCubemapSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1446         ctx.expectError(GL_INVALID_VALUE);
1447         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 1, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1448         ctx.expectError(GL_INVALID_VALUE);
1449         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, maxCubemapSize, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1450         ctx.expectError(GL_INVALID_VALUE);
1451         ctx.endSection();
1452
1453         ctx.beginSection("GL_TEXTURE_CUBE_MAP_POSITIVE_Z target");
1454         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, maxCubemapSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1455         ctx.expectError(GL_INVALID_VALUE);
1456         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 1, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1457         ctx.expectError(GL_INVALID_VALUE);
1458         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, maxCubemapSize, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1459         ctx.expectError(GL_INVALID_VALUE);
1460         ctx.endSection();
1461
1462         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_X target");
1463         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, maxCubemapSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1464         ctx.expectError(GL_INVALID_VALUE);
1465         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 1, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1466         ctx.expectError(GL_INVALID_VALUE);
1467         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, maxCubemapSize, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1468         ctx.expectError(GL_INVALID_VALUE);
1469         ctx.endSection();
1470
1471         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Y target");
1472         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, maxCubemapSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1473         ctx.expectError(GL_INVALID_VALUE);
1474         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 1, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1475         ctx.expectError(GL_INVALID_VALUE);
1476         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, maxCubemapSize, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1477         ctx.expectError(GL_INVALID_VALUE);
1478         ctx.endSection();
1479
1480         ctx.beginSection("GL_TEXTURE_CUBE_MAP_NEGATIVE_Z target");
1481         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, maxCubemapSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1482         ctx.expectError(GL_INVALID_VALUE);
1483         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 1, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1484         ctx.expectError(GL_INVALID_VALUE);
1485         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, maxCubemapSize, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1486         ctx.expectError(GL_INVALID_VALUE);
1487         ctx.endSection();
1488
1489         ctx.endSection();
1490 }
1491
1492 void teximage2d_invalid_border (NegativeTestContext& ctx)
1493 {
1494         ctx.beginSection("GL_INVALID_VALUE is generated if border is not 0.");
1495         ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1496         ctx.expectError(GL_INVALID_VALUE);
1497         ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, -1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1498         ctx.expectError(GL_INVALID_VALUE);
1499         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 1, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1500         ctx.expectError(GL_INVALID_VALUE);
1501         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 1, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1502         ctx.expectError(GL_INVALID_VALUE);
1503         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 1, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1504         ctx.expectError(GL_INVALID_VALUE);
1505         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 1, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1506         ctx.expectError(GL_INVALID_VALUE);
1507         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 1, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1508         ctx.expectError(GL_INVALID_VALUE);
1509         ctx.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 1, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1510         ctx.expectError(GL_INVALID_VALUE);
1511         ctx.endSection();
1512 }
1513
1514 void teximage2d_invalid_buffer_target (NegativeTestContext& ctx)
1515 {
1516         deUint32                                buf = 0x1234;
1517         deUint32                                texture = 0x1234;
1518         std::vector<GLubyte>    data(64);
1519
1520         ctx.glGenBuffers                        (1, &buf);
1521         ctx.glBindBuffer                        (GL_PIXEL_UNPACK_BUFFER, buf);
1522         ctx.glBufferData                        (GL_PIXEL_UNPACK_BUFFER, 64, &data[0], GL_DYNAMIC_COPY);
1523         ctx.glGenTextures                       (1, &texture);
1524         ctx.glBindTexture                       (GL_TEXTURE_2D, texture);
1525         ctx.expectError                         (GL_NO_ERROR);
1526
1527         ctx.beginSection("GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and...");
1528         ctx.beginSection("...the buffer object's data store is currently mapped.");
1529         ctx.glMapBufferRange            (GL_PIXEL_UNPACK_BUFFER, 0, 32, GL_MAP_WRITE_BIT);
1530         ctx.glTexImage2D                        (GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1531         ctx.expectError                         (GL_INVALID_OPERATION);
1532         ctx.glUnmapBuffer                       (GL_PIXEL_UNPACK_BUFFER);
1533         ctx.endSection();
1534
1535         ctx.beginSection("...the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
1536         ctx.glTexImage2D                        (GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1537         ctx.expectError                         (GL_INVALID_OPERATION);
1538         ctx.endSection();
1539
1540         ctx.beginSection("...data is not evenly divisible into the number of bytes needed to store in memory a datum indicated by type.");
1541         ctx.getLog() << TestLog::Message << "// Set byte offset = 3" << TestLog::EndMessage;
1542         ctx.glTexImage2D                        (GL_TEXTURE_2D, 0, GL_RGB5_A1, 4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, (const GLvoid*)3);
1543         ctx.expectError                         (GL_INVALID_OPERATION);
1544         ctx.endSection();
1545         ctx.endSection();
1546
1547         ctx.glDeleteBuffers                     (1, &buf);
1548         ctx.glDeleteTextures            (1, &texture);
1549 }
1550
1551 // glTexSubImage2D
1552
1553 void texsubimage2d (NegativeTestContext& ctx)
1554 {
1555         deUint32                        texture = 0x1234;
1556         ctx.glGenTextures               (1, &texture);
1557         ctx.glBindTexture               (GL_TEXTURE_2D, texture);
1558         ctx.glTexImage2D                (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1559         ctx.expectError                 (GL_NO_ERROR);
1560
1561         ctx.beginSection("GL_INVALID_ENUM is generated if target is invalid.");
1562         ctx.glTexSubImage2D(0, 0, 0, 0, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1563         ctx.expectError(GL_INVALID_ENUM);
1564         ctx.endSection();
1565
1566         ctx.beginSection("GL_INVALID_ENUM is generated if format is not an accepted format constant.");
1567         ctx.glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 4, 4, GL_UNSIGNED_BYTE, 0);
1568         ctx.expectError(GL_INVALID_ENUM);
1569         ctx.endSection();
1570
1571         ctx.beginSection("GL_INVALID_ENUM is generated if type is not a type constant.");
1572         ctx.glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGB, 0, 0);
1573         ctx.expectError(GL_INVALID_ENUM);
1574         ctx.endSection();
1575
1576         ctx.beginSection("GL_INVALID_OPERATION is generated if the combination of internalFormat of the previously specified texture array, format and type is not valid.");
1577         ctx.glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGBA, GL_UNSIGNED_SHORT_5_6_5, 0);
1578         ctx.expectError(GL_INVALID_OPERATION);
1579         ctx.glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, 0);
1580         ctx.expectError(GL_INVALID_OPERATION);
1581         ctx.glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, 0);
1582         ctx.expectError(GL_INVALID_OPERATION);
1583         ctx.glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, 0);
1584         ctx.expectError(GL_INVALID_OPERATION);
1585         ctx.glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGBA_INTEGER, GL_UNSIGNED_INT, 0);
1586         ctx.expectError(GL_INVALID_OPERATION);
1587         ctx.glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGB, GL_FLOAT, 0);
1588         ctx.expectError(GL_INVALID_OPERATION);
1589         ctx.endSection();
1590
1591         ctx.glDeleteTextures    (1, &texture);
1592 }
1593
1594 void texsubimage2d_neg_level (NegativeTestContext& ctx)
1595 {
1596         deUint32                        textures[2];
1597         ctx.glGenTextures               (2, &textures[0]);
1598         ctx.glBindTexture               (GL_TEXTURE_2D, textures[0]);
1599         ctx.glTexImage2D                (GL_TEXTURE_2D, 0, GL_RGB, 32, 32, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1600         ctx.glBindTexture               (GL_TEXTURE_2D, textures[1]);
1601         FOR_CUBE_FACES(faceGL, ctx.glTexImage2D(faceGL, 0, GL_RGB, 32, 32, 0, GL_RGB, GL_UNSIGNED_BYTE, 0););
1602         ctx.expectError                 (GL_NO_ERROR);
1603
1604         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
1605         ctx.glTexSubImage2D(GL_TEXTURE_2D, -1, 0, 0, 0, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1606         ctx.expectError(GL_INVALID_VALUE);
1607         ctx.endSection();
1608
1609         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
1610         FOR_CUBE_FACES(faceGL,
1611         {
1612                 ctx.glTexSubImage2D(faceGL, -1, 0, 0, 0, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1613                 ctx.expectError(GL_INVALID_VALUE);
1614         });
1615         ctx.endSection();
1616
1617         ctx.glDeleteTextures(2, &textures[0]);
1618 }
1619
1620 void texsubimage2d_max_level (NegativeTestContext& ctx)
1621 {
1622         deUint32                        textures[2];
1623         ctx.glGenTextures               (2, &textures[0]);
1624         ctx.glBindTexture               (GL_TEXTURE_2D, textures[0]);
1625         ctx.glTexImage2D                (GL_TEXTURE_2D, 0, GL_RGB, 32, 32, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1626         ctx.glBindTexture               (GL_TEXTURE_CUBE_MAP, textures[1]);
1627         FOR_CUBE_FACES(faceGL, ctx.glTexImage2D(faceGL, 0, GL_RGB, 32, 32, 0, GL_RGB, GL_UNSIGNED_BYTE, 0););
1628         ctx.expectError                 (GL_NO_ERROR);
1629
1630         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
1631         deUint32 log2MaxTextureSize = deLog2Floor32(ctx.getInteger(GL_MAX_TEXTURE_SIZE)) + 1;
1632         ctx.glTexSubImage2D(GL_TEXTURE_2D, log2MaxTextureSize, 0, 0, 0, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1633         ctx.expectError(GL_INVALID_VALUE);
1634         ctx.endSection();
1635
1636         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_TEXTURE_SIZE).");
1637         deUint32 log2MaxCubemapSize = deLog2Floor32(ctx.getInteger(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
1638         FOR_CUBE_FACES(faceGL,
1639         {
1640                 ctx.glTexSubImage2D(faceGL, log2MaxCubemapSize, 0, 0, 0, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1641                 ctx.expectError(GL_INVALID_VALUE);
1642         });
1643         ctx.endSection();
1644
1645         ctx.glDeleteTextures(2, &textures[0]);
1646 }
1647
1648 void texsubimage2d_neg_offset (NegativeTestContext& ctx)
1649 {
1650         deUint32 texture = 0x1234;
1651         ctx.glGenTextures(1, &texture);
1652         ctx.glBindTexture(GL_TEXTURE_2D, texture);
1653         ctx.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 32, 32, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1654         ctx.expectError(GL_NO_ERROR);
1655
1656         ctx.beginSection("GL_INVALID_VALUE is generated if xoffset or yoffset are negative.");
1657         ctx.glTexSubImage2D(GL_TEXTURE_2D, 0, -1, 0, 0, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1658         ctx.expectError(GL_INVALID_VALUE);
1659         ctx.glTexSubImage2D(GL_TEXTURE_2D, 0, 0, -1, 0, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1660         ctx.expectError(GL_INVALID_VALUE);
1661         ctx.glTexSubImage2D(GL_TEXTURE_2D, 0, -1, -1, 0, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1662         ctx.expectError(GL_INVALID_VALUE);
1663         ctx.endSection();
1664
1665         ctx.glDeleteTextures(1, &texture);
1666 }
1667
1668 void texsubimage2d_invalid_offset (NegativeTestContext& ctx)
1669 {
1670         deUint32                        texture = 0x1234;
1671         ctx.glGenTextures               (1, &texture);
1672         ctx.glBindTexture               (GL_TEXTURE_2D, texture);
1673         ctx.glTexImage2D                (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1674         ctx.expectError                 (GL_NO_ERROR);
1675
1676         ctx.beginSection("GL_INVALID_VALUE is generated if xoffset + width > texture_width or yoffset + height > texture_height.");
1677         ctx.glTexSubImage2D(GL_TEXTURE_2D, 0, 30, 0, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1678         ctx.expectError(GL_INVALID_VALUE);
1679         ctx.glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 30, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1680         ctx.expectError(GL_INVALID_VALUE);
1681         ctx.glTexSubImage2D(GL_TEXTURE_2D, 0, 30, 30, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1682         ctx.expectError(GL_INVALID_VALUE);
1683         ctx.endSection();
1684
1685         ctx.glDeleteTextures    (1, &texture);
1686 }
1687
1688 void texsubimage2d_neg_width_height (NegativeTestContext& ctx)
1689 {
1690         deUint32                        texture = 0x1234;
1691         ctx.glGenTextures               (1, &texture);
1692         ctx.glBindTexture               (GL_TEXTURE_2D, texture);
1693         ctx.glTexImage2D                (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1694         ctx.expectError                 (GL_NO_ERROR);
1695
1696         ctx.beginSection("GL_INVALID_VALUE is generated if width or height is less than 0.");
1697         ctx.glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1698         ctx.expectError(GL_INVALID_VALUE);
1699         ctx.glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, -1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1700         ctx.expectError(GL_INVALID_VALUE);
1701         ctx.glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, -1, -1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1702         ctx.expectError(GL_INVALID_VALUE);
1703         ctx.endSection();
1704
1705         ctx.glDeleteTextures    (1, &texture);
1706 }
1707
1708 void texsubimage2d_invalid_buffer_target (NegativeTestContext& ctx)
1709 {
1710         deUint32                                buf = 0x1234;
1711         deUint32                                texture = 0x1234;
1712         std::vector<GLubyte>    data(64);
1713
1714         ctx.glGenTextures                       (1, &texture);
1715         ctx.glBindTexture                       (GL_TEXTURE_2D, texture);
1716         ctx.glTexImage2D                        (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1717         ctx.glGenBuffers                        (1, &buf);
1718         ctx.glBindBuffer                        (GL_PIXEL_UNPACK_BUFFER, buf);
1719         ctx.glBufferData                        (GL_PIXEL_UNPACK_BUFFER, 64, &data[0], GL_DYNAMIC_COPY);
1720         ctx.expectError                         (GL_NO_ERROR);
1721
1722         ctx.beginSection("GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and...");
1723         ctx.beginSection("...the buffer object's data store is currently mapped.");
1724         ctx.glMapBufferRange            (GL_PIXEL_UNPACK_BUFFER, 0, 32, GL_MAP_WRITE_BIT);
1725         ctx.glTexSubImage2D                     (GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1726         ctx.expectError                         (GL_INVALID_OPERATION);
1727         ctx.glUnmapBuffer                       (GL_PIXEL_UNPACK_BUFFER);
1728         ctx.endSection();
1729
1730         ctx.beginSection("...the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
1731         ctx.glTexSubImage2D                     (GL_TEXTURE_2D, 0, 0, 0, 32, 32, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1732         ctx.expectError                         (GL_INVALID_OPERATION);
1733         ctx.endSection();
1734
1735         ctx.beginSection("...data is not evenly divisible into the number of bytes needed to store in memory a datum indicated by type.");
1736         ctx.getLog() << TestLog::Message << "// Set byte offset = 3" << TestLog::EndMessage;
1737         ctx.glBindBuffer                        (GL_PIXEL_UNPACK_BUFFER, 0);
1738         ctx.glTexImage2D                        (GL_TEXTURE_2D, 0, GL_RGBA4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, 0);
1739         ctx.glBindBuffer                        (GL_PIXEL_UNPACK_BUFFER, buf);
1740         ctx.expectError                         (GL_NO_ERROR);
1741         ctx.glTexSubImage2D                     (GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, (const GLvoid*)3);
1742         ctx.expectError                         (GL_INVALID_OPERATION);
1743         ctx.endSection();
1744         ctx.endSection();
1745
1746         ctx.glDeleteBuffers                     (1, &buf);
1747         ctx.glDeleteTextures            (1, &texture);
1748 }
1749
1750 // glTexParameteri
1751
1752 void texparameteri (NegativeTestContext& ctx)
1753 {
1754         GLuint texture = 0x1234;
1755         GLint textureMode = -1;
1756
1757         ctx.glGenTextures(1, &texture);
1758         ctx.glBindTexture(GL_TEXTURE_2D, texture);
1759
1760         ctx.beginSection("GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1761         ctx.glTexParameteri(0, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1762         ctx.expectError(GL_INVALID_ENUM);
1763         ctx.glTexParameteri(GL_TEXTURE_2D, 0, GL_LINEAR);
1764         ctx.expectError(GL_INVALID_ENUM);
1765         ctx.glTexParameteri(0, 0, GL_LINEAR);
1766         ctx.expectError(GL_INVALID_ENUM);
1767         ctx.endSection();
1768
1769         ctx.beginSection("GL_INVALID_ENUM is generated if pname is enum and the value of param(s) is not a valid value.");
1770         ctx.glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, textureMode);
1771         ctx.expectError(GL_INVALID_ENUM);
1772         ctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, textureMode);
1773         ctx.expectError(GL_INVALID_ENUM);
1774         ctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, textureMode);
1775         ctx.expectError(GL_INVALID_ENUM);
1776         ctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, textureMode);
1777         ctx.expectError(GL_INVALID_ENUM);
1778         ctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, textureMode);
1779         ctx.expectError(GL_INVALID_ENUM);
1780         ctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, textureMode);
1781         ctx.expectError(GL_INVALID_ENUM);
1782         ctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, textureMode);
1783         ctx.expectError(GL_INVALID_ENUM);
1784         ctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, textureMode);
1785         ctx.expectError(GL_INVALID_ENUM);
1786         ctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, textureMode);
1787         ctx.expectError(GL_INVALID_ENUM);
1788         ctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, textureMode);
1789         ctx.expectError(GL_INVALID_ENUM);
1790         ctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, textureMode);
1791         ctx.expectError(GL_INVALID_ENUM);
1792         ctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, textureMode);
1793         ctx.expectError(GL_INVALID_ENUM);
1794         ctx.endSection();
1795
1796         ctx.beginSection("GL_INVALID_VALUE is generated if pname is GL_TEXTURE_BASE_LEVEL or GL_TEXTURE_MAX_LEVEL and param(s) is negative.");
1797         ctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, -1);
1798         ctx.expectError(GL_INVALID_VALUE);
1799         ctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, -1);
1800         ctx.expectError(GL_INVALID_VALUE);
1801         ctx.endSection();
1802
1803         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
1804         {
1805                 ctx.beginSection("GL_INVALID_ENUM is generated if pname is a non-scalar parameter.");
1806                 ctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, 0);
1807                 ctx.expectError(GL_INVALID_ENUM);
1808                 ctx.endSection();
1809         }
1810
1811         ctx.beginSection("GL_INVALID_ENUM error is generated if target is GL_TEXTURE_2D_MULTISAMPLE or GL_TEXTURE_2D_MULTISAMPLE_ARRAY and pname is not valid.");
1812         ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BORDER_COLOR, textureMode);
1813         ctx.expectError(GL_INVALID_ENUM);
1814         ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_FILTER, textureMode);
1815         ctx.expectError(GL_INVALID_ENUM);
1816         ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAG_FILTER, textureMode);
1817         ctx.expectError(GL_INVALID_ENUM);
1818         ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_S, textureMode);
1819         ctx.expectError(GL_INVALID_ENUM);
1820         ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_T, textureMode);
1821         ctx.expectError(GL_INVALID_ENUM);
1822         ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_R, textureMode);
1823         ctx.expectError(GL_INVALID_ENUM);
1824         ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_LOD, textureMode);
1825         ctx.expectError(GL_INVALID_ENUM);
1826         ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAX_LOD, textureMode);
1827         ctx.expectError(GL_INVALID_ENUM);
1828         ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_MODE, textureMode);
1829         ctx.expectError(GL_INVALID_ENUM);
1830         ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_FUNC, textureMode);
1831         ctx.expectError(GL_INVALID_ENUM);
1832
1833         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
1834         {
1835                 ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BORDER_COLOR, textureMode);
1836                 ctx.expectError(GL_INVALID_ENUM);
1837                 ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_FILTER, textureMode);
1838                 ctx.expectError(GL_INVALID_ENUM);
1839                 ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAG_FILTER, textureMode);
1840                 ctx.expectError(GL_INVALID_ENUM);
1841                 ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_S, textureMode);
1842                 ctx.expectError(GL_INVALID_ENUM);
1843                 ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_T, textureMode);
1844                 ctx.expectError(GL_INVALID_ENUM);
1845                 ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_R, textureMode);
1846                 ctx.expectError(GL_INVALID_ENUM);
1847                 ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_LOD, textureMode);
1848                 ctx.expectError(GL_INVALID_ENUM);
1849                 ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAX_LOD, textureMode);
1850                 ctx.expectError(GL_INVALID_ENUM);
1851                 ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_MODE, textureMode);
1852                 ctx.expectError(GL_INVALID_ENUM);
1853                 ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_FUNC, textureMode);
1854                 ctx.expectError(GL_INVALID_ENUM);
1855         }
1856         ctx.endSection();
1857
1858         ctx.beginSection("GL_INVALID_OPERATION is generated if target is GL_TEXTURE_2D_MULTISAMPLE or GL_TEXTURE_2D_MULTISAMPLE_ARRAY and pname GL_TEXTURE_BASE_LEVEL is not 0.");
1859         ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, 1);
1860         ctx.expectError(GL_INVALID_OPERATION);
1861
1862         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
1863         {
1864                 ctx.glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BASE_LEVEL, 1);
1865                 ctx.expectError(GL_INVALID_OPERATION);
1866         }
1867         ctx.endSection();
1868
1869         ctx.glDeleteTextures(1, &texture);
1870 }
1871
1872 // glTexParameterf
1873
1874 void texparameterf (NegativeTestContext& ctx)
1875 {
1876         GLuint texture = 0x1234;
1877         GLfloat textureMode = -1.0f;
1878         ctx.glGenTextures(1, &texture);
1879         ctx.glBindTexture(GL_TEXTURE_2D, texture);
1880
1881         ctx.beginSection("GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1882         ctx.glTexParameterf(0, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1883         ctx.expectError(GL_INVALID_ENUM);
1884         ctx.glTexParameterf(GL_TEXTURE_2D, 0, GL_LINEAR);
1885         ctx.expectError(GL_INVALID_ENUM);
1886         ctx.glTexParameterf(0, 0, GL_LINEAR);
1887         ctx.expectError(GL_INVALID_ENUM);
1888         ctx.endSection();
1889
1890         ctx.beginSection("GL_INVALID_ENUM is generated if pname is enum and the value of param(s) is not a valid value.");
1891         ctx.glTexParameterf(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, textureMode);
1892         ctx.expectError(GL_INVALID_ENUM);
1893         ctx.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, textureMode);
1894         ctx.expectError(GL_INVALID_ENUM);
1895         ctx.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, textureMode);
1896         ctx.expectError(GL_INVALID_ENUM);
1897         ctx.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, textureMode);
1898         ctx.expectError(GL_INVALID_ENUM);
1899         ctx.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, textureMode);
1900         ctx.expectError(GL_INVALID_ENUM);
1901         ctx.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, textureMode);
1902         ctx.expectError(GL_INVALID_ENUM);
1903         ctx.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, textureMode);
1904         ctx.expectError(GL_INVALID_ENUM);
1905         ctx.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, textureMode);
1906         ctx.expectError(GL_INVALID_ENUM);
1907         ctx.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, textureMode);
1908         ctx.expectError(GL_INVALID_ENUM);
1909         ctx.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, textureMode);
1910         ctx.expectError(GL_INVALID_ENUM);
1911         ctx.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, textureMode);
1912         ctx.expectError(GL_INVALID_ENUM);
1913         ctx.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, textureMode);
1914         ctx.expectError(GL_INVALID_ENUM);
1915         ctx.endSection();
1916
1917         ctx.beginSection("GL_INVALID_VALUE is generated if pname is GL_TEXTURE_BASE_LEVEL or GL_TEXTURE_MAX_LEVEL and param(s) is negative.");
1918         ctx.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, -1.0f);
1919         ctx.expectError(GL_INVALID_VALUE);
1920         ctx.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, -1.0f);
1921         ctx.expectError(GL_INVALID_VALUE);
1922         ctx.endSection();
1923
1924         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
1925         {
1926                 ctx.beginSection("GL_INVALID_ENUM is generated if pname is a non-scalar parameter.");
1927                 ctx.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, 0.0f);
1928                 ctx.expectError(GL_INVALID_ENUM);
1929                 ctx.endSection();
1930         }
1931
1932         ctx.beginSection("GL_INVALID_ENUM error is generated if target is GL_TEXTURE_2D_MULTISAMPLE or GL_TEXTURE_2D_MULTISAMPLE_ARRAY and pname is not valid.");
1933         ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BORDER_COLOR, textureMode);
1934         ctx.expectError(GL_INVALID_ENUM);
1935         ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_FILTER, textureMode);
1936         ctx.expectError(GL_INVALID_ENUM);
1937         ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAG_FILTER, textureMode);
1938         ctx.expectError(GL_INVALID_ENUM);
1939         ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_S, textureMode);
1940         ctx.expectError(GL_INVALID_ENUM);
1941         ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_T, textureMode);
1942         ctx.expectError(GL_INVALID_ENUM);
1943         ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_R, textureMode);
1944         ctx.expectError(GL_INVALID_ENUM);
1945         ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_LOD, textureMode);
1946         ctx.expectError(GL_INVALID_ENUM);
1947         ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAX_LOD, textureMode);
1948         ctx.expectError(GL_INVALID_ENUM);
1949         ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_MODE, textureMode);
1950         ctx.expectError(GL_INVALID_ENUM);
1951         ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_FUNC, textureMode);
1952         ctx.expectError(GL_INVALID_ENUM);
1953
1954         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
1955         {
1956                 ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BORDER_COLOR, textureMode);
1957                 ctx.expectError(GL_INVALID_ENUM);
1958                 ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_FILTER, textureMode);
1959                 ctx.expectError(GL_INVALID_ENUM);
1960                 ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAG_FILTER, textureMode);
1961                 ctx.expectError(GL_INVALID_ENUM);
1962                 ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_S, textureMode);
1963                 ctx.expectError(GL_INVALID_ENUM);
1964                 ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_T, textureMode);
1965                 ctx.expectError(GL_INVALID_ENUM);
1966                 ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_R, textureMode);
1967                 ctx.expectError(GL_INVALID_ENUM);
1968                 ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_LOD, textureMode);
1969                 ctx.expectError(GL_INVALID_ENUM);
1970                 ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAX_LOD, textureMode);
1971                 ctx.expectError(GL_INVALID_ENUM);
1972                 ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_MODE, textureMode);
1973                 ctx.expectError(GL_INVALID_ENUM);
1974                 ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_FUNC, textureMode);
1975                 ctx.expectError(GL_INVALID_ENUM);
1976         }
1977         ctx.endSection();
1978
1979         ctx.beginSection("GL_INVALID_OPERATION is generated if target is GL_TEXTURE_2D_MULTISAMPLE or GL_TEXTURE_2D_MULTISAMPLE_ARRAY and pname GL_TEXTURE_BASE_LEVEL is not 0.");
1980         ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, 1.0f);
1981         ctx.expectError(GL_INVALID_OPERATION);
1982
1983         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
1984         {
1985                 ctx.glTexParameterf(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BASE_LEVEL, 1.0f);
1986                 ctx.expectError(GL_INVALID_OPERATION);
1987         }
1988         ctx.endSection();
1989
1990         ctx.glDeleteTextures(1, &texture);
1991 }
1992
1993 // glTexParameteriv
1994
1995 void texparameteriv (NegativeTestContext& ctx)
1996 {
1997         GLint params[1] = {GL_LINEAR};
1998
1999         GLuint texture = 0x1234;
2000         ctx.glGenTextures(1, &texture);
2001         ctx.glBindTexture(GL_TEXTURE_2D, texture);
2002
2003         ctx.beginSection("GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
2004         ctx.glTexParameteriv(0, GL_TEXTURE_MIN_FILTER, &params[0]);
2005         ctx.expectError(GL_INVALID_ENUM);
2006         ctx.glTexParameteriv(GL_TEXTURE_2D, 0, &params[0]);
2007         ctx.expectError(GL_INVALID_ENUM);
2008         ctx.glTexParameteriv(0, 0, &params[0]);
2009         ctx.expectError(GL_INVALID_ENUM);
2010         ctx.endSection();
2011
2012         ctx.beginSection("GL_INVALID_ENUM is generated if pname is enum and the value of param(s) is not a valid value.");
2013         params[0] = -1;
2014         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, &params[0]);
2015         ctx.expectError(GL_INVALID_ENUM);
2016         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, &params[0]);
2017         ctx.expectError(GL_INVALID_ENUM);
2018         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, &params[0]);
2019         ctx.expectError(GL_INVALID_ENUM);
2020         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &params[0]);
2021         ctx.expectError(GL_INVALID_ENUM);
2022         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &params[0]);
2023         ctx.expectError(GL_INVALID_ENUM);
2024         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, &params[0]);
2025         ctx.expectError(GL_INVALID_ENUM);
2026         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, &params[0]);
2027         ctx.expectError(GL_INVALID_ENUM);
2028         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, &params[0]);
2029         ctx.expectError(GL_INVALID_ENUM);
2030         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, &params[0]);
2031         ctx.expectError(GL_INVALID_ENUM);
2032         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, &params[0]);
2033         ctx.expectError(GL_INVALID_ENUM);
2034         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, &params[0]);
2035         ctx.expectError(GL_INVALID_ENUM);
2036         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, &params[0]);
2037         ctx.expectError(GL_INVALID_ENUM);
2038         ctx.endSection();
2039
2040         ctx.beginSection("GL_INVALID_VALUE is generated if pname is GL_TEXTURE_BASE_LEVEL or GL_TEXTURE_MAX_LEVEL and param(s) is negative.");
2041         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, &params[0]);
2042         ctx.expectError(GL_INVALID_VALUE);
2043         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, &params[0]);
2044         ctx.expectError(GL_INVALID_VALUE);
2045         ctx.endSection();
2046
2047         ctx.beginSection("GL_INVALID_ENUM error is generated if target is GL_TEXTURE_2D_MULTISAMPLE or GL_TEXTURE_2D_MULTISAMPLE_ARRAY and pname is not valid.");
2048         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BORDER_COLOR, &params[0]);
2049         ctx.expectError(GL_INVALID_ENUM);
2050         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_FILTER, &params[0]);
2051         ctx.expectError(GL_INVALID_ENUM);
2052         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAG_FILTER, &params[0]);
2053         ctx.expectError(GL_INVALID_ENUM);
2054         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_S, &params[0]);
2055         ctx.expectError(GL_INVALID_ENUM);
2056         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_T, &params[0]);
2057         ctx.expectError(GL_INVALID_ENUM);
2058         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_R, &params[0]);
2059         ctx.expectError(GL_INVALID_ENUM);
2060         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_LOD, &params[0]);
2061         ctx.expectError(GL_INVALID_ENUM);
2062         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAX_LOD, &params[0]);
2063         ctx.expectError(GL_INVALID_ENUM);
2064         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_MODE, &params[0]);
2065         ctx.expectError(GL_INVALID_ENUM);
2066         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_FUNC, &params[0]);
2067         ctx.expectError(GL_INVALID_ENUM);
2068
2069         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
2070         {
2071                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BORDER_COLOR, &params[0]);
2072                 ctx.expectError(GL_INVALID_ENUM);
2073                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_FILTER, &params[0]);
2074                 ctx.expectError(GL_INVALID_ENUM);
2075                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAG_FILTER, &params[0]);
2076                 ctx.expectError(GL_INVALID_ENUM);
2077                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_S, &params[0]);
2078                 ctx.expectError(GL_INVALID_ENUM);
2079                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_T, &params[0]);
2080                 ctx.expectError(GL_INVALID_ENUM);
2081                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_R, &params[0]);
2082                 ctx.expectError(GL_INVALID_ENUM);
2083                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_LOD, &params[0]);
2084                 ctx.expectError(GL_INVALID_ENUM);
2085                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAX_LOD, &params[0]);
2086                 ctx.expectError(GL_INVALID_ENUM);
2087                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_MODE, &params[0]);
2088                 ctx.expectError(GL_INVALID_ENUM);
2089                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_FUNC, &params[0]);
2090                 ctx.expectError(GL_INVALID_ENUM);
2091         }
2092         ctx.endSection();
2093
2094         ctx.beginSection("GL_INVALID_OPERATION is generated if target is GL_TEXTURE_2D_MULTISAMPLE or GL_TEXTURE_2D_MULTISAMPLE_ARRAY and pname GL_TEXTURE_BASE_LEVEL is not 0.");
2095         params[0] = 1;
2096         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, &params[0]);
2097         ctx.expectError(GL_INVALID_OPERATION);
2098
2099         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
2100         {
2101                 params[0] = 1;
2102                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BASE_LEVEL, &params[0]);
2103                 ctx.expectError(GL_INVALID_OPERATION);
2104         }
2105         ctx.endSection();
2106
2107         ctx.glDeleteTextures(1, &texture);
2108 }
2109
2110 // glTexParameterfv
2111
2112 void texparameterfv (NegativeTestContext& ctx)
2113 {
2114         GLfloat params[1] = {GL_LINEAR};
2115         GLuint texture = 0x1234;
2116         ctx.glGenTextures(1, &texture);
2117         ctx.glBindTexture(GL_TEXTURE_2D, texture);
2118
2119         ctx.beginSection("GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
2120         params[0] = GL_LINEAR;
2121         ctx.glTexParameterfv(0, GL_TEXTURE_MIN_FILTER, &params[0]);
2122         ctx.expectError(GL_INVALID_ENUM);
2123         ctx.glTexParameterfv(GL_TEXTURE_2D, 0, &params[0]);
2124         ctx.expectError(GL_INVALID_ENUM);
2125         ctx.glTexParameterfv(0, 0, &params[0]);
2126         ctx.expectError(GL_INVALID_ENUM);
2127         ctx.endSection();
2128
2129         ctx.beginSection("GL_INVALID_ENUM is generated if pname is enum and the value of param(s) is not a valid value.");
2130         params[0] = -1.0f;
2131         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, &params[0]);
2132         ctx.expectError(GL_INVALID_ENUM);
2133         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, &params[0]);
2134         ctx.expectError(GL_INVALID_ENUM);
2135         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, &params[0]);
2136         ctx.expectError(GL_INVALID_ENUM);
2137         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &params[0]);
2138         ctx.expectError(GL_INVALID_ENUM);
2139         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &params[0]);
2140         ctx.expectError(GL_INVALID_ENUM);
2141         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, &params[0]);
2142         ctx.expectError(GL_INVALID_ENUM);
2143         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, &params[0]);
2144         ctx.expectError(GL_INVALID_ENUM);
2145         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, &params[0]);
2146         ctx.expectError(GL_INVALID_ENUM);
2147         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, &params[0]);
2148         ctx.expectError(GL_INVALID_ENUM);
2149         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, &params[0]);
2150         ctx.expectError(GL_INVALID_ENUM);
2151         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, &params[0]);
2152         ctx.expectError(GL_INVALID_ENUM);
2153         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, &params[0]);
2154         ctx.expectError(GL_INVALID_ENUM);
2155         ctx.endSection();
2156
2157         ctx.beginSection("GL_INVALID_VALUE is generated if pname is GL_TEXTURE_BASE_LEVEL or GL_TEXTURE_MAX_LEVEL and param(s) is negative.");
2158         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, &params[0]);
2159         ctx.expectError(GL_INVALID_VALUE);
2160         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, &params[0]);
2161         ctx.expectError(GL_INVALID_VALUE);
2162         ctx.endSection();
2163
2164         ctx.beginSection("GL_INVALID_ENUM error is generated if target is GL_TEXTURE_2D_MULTISAMPLE or GL_TEXTURE_2D_MULTISAMPLE_ARRAY and pname is not valid.");
2165         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BORDER_COLOR, &params[0]);
2166         ctx.expectError(GL_INVALID_ENUM);
2167         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_FILTER, &params[0]);
2168         ctx.expectError(GL_INVALID_ENUM);
2169         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAG_FILTER, &params[0]);
2170         ctx.expectError(GL_INVALID_ENUM);
2171         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_S, &params[0]);
2172         ctx.expectError(GL_INVALID_ENUM);
2173         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_T, &params[0]);
2174         ctx.expectError(GL_INVALID_ENUM);
2175         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_R, &params[0]);
2176         ctx.expectError(GL_INVALID_ENUM);
2177         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_LOD, &params[0]);
2178         ctx.expectError(GL_INVALID_ENUM);
2179         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAX_LOD, &params[0]);
2180         ctx.expectError(GL_INVALID_ENUM);
2181         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_MODE, &params[0]);
2182         ctx.expectError(GL_INVALID_ENUM);
2183         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_FUNC, &params[0]);
2184         ctx.expectError(GL_INVALID_ENUM);
2185
2186         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
2187         {
2188                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BORDER_COLOR, &params[0]);
2189                 ctx.expectError(GL_INVALID_ENUM);
2190                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_FILTER, &params[0]);
2191                 ctx.expectError(GL_INVALID_ENUM);
2192                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAG_FILTER, &params[0]);
2193                 ctx.expectError(GL_INVALID_ENUM);
2194                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_S, &params[0]);
2195                 ctx.expectError(GL_INVALID_ENUM);
2196                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_T, &params[0]);
2197                 ctx.expectError(GL_INVALID_ENUM);
2198                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_R, &params[0]);
2199                 ctx.expectError(GL_INVALID_ENUM);
2200                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_LOD, &params[0]);
2201                 ctx.expectError(GL_INVALID_ENUM);
2202                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAX_LOD, &params[0]);
2203                 ctx.expectError(GL_INVALID_ENUM);
2204                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_MODE, &params[0]);
2205                 ctx.expectError(GL_INVALID_ENUM);
2206                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_FUNC, &params[0]);
2207                 ctx.expectError(GL_INVALID_ENUM);
2208         }
2209         ctx.endSection();
2210
2211         ctx.beginSection("GL_INVALID_OPERATION is generated if target is GL_TEXTURE_2D_MULTISAMPLE or GL_TEXTURE_2D_MULTISAMPLE_ARRAY and pname GL_TEXTURE_BASE_LEVEL is not 0.");
2212         params[0] = 1.0f;
2213         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, &params[0]);
2214         ctx.expectError(GL_INVALID_OPERATION);
2215
2216         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
2217         {
2218                 params[0] = 1.0f;
2219                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BASE_LEVEL, &params[0]);
2220                 ctx.expectError(GL_INVALID_OPERATION);
2221         }
2222         ctx.endSection();
2223
2224         ctx.glDeleteTextures(1, &texture);
2225 }
2226
2227 // glTexParameterIiv
2228
2229 void texparameterIiv (NegativeTestContext& ctx)
2230 {
2231         if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
2232                 throw tcu::NotSupportedError("glTexParameterIiv is not supported.", DE_NULL, __FILE__, __LINE__);
2233
2234         GLint textureMode[] = { GL_DEPTH_COMPONENT, GL_STENCIL_INDEX };
2235         ctx.beginSection("GL_INVALID_ENUM is generated if target is not a valid target.");
2236         ctx.glTexParameterIiv(0, GL_DEPTH_STENCIL_TEXTURE_MODE, textureMode);
2237         ctx.expectError(GL_INVALID_ENUM);
2238         ctx.endSection();
2239
2240         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not a valid parameter.");
2241         ctx.glTexParameterIiv(GL_TEXTURE_2D, 0, textureMode);
2242         ctx.expectError(GL_INVALID_ENUM);
2243         ctx.endSection();
2244
2245         ctx.beginSection("GL_INVALID_ENUM is generated if pname is enum and the value of param(s) is not a valid value.");
2246         textureMode[0] = -1;
2247         textureMode[1] = -1;
2248         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, textureMode);
2249         ctx.expectError(GL_INVALID_ENUM);
2250         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, textureMode);
2251         ctx.expectError(GL_INVALID_ENUM);
2252         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, textureMode);
2253         ctx.expectError(GL_INVALID_ENUM);
2254         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, textureMode);
2255         ctx.expectError(GL_INVALID_ENUM);
2256         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, textureMode);
2257         ctx.expectError(GL_INVALID_ENUM);
2258         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, textureMode);
2259         ctx.expectError(GL_INVALID_ENUM);
2260         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, textureMode);
2261         ctx.expectError(GL_INVALID_ENUM);
2262         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, textureMode);
2263         ctx.expectError(GL_INVALID_ENUM);
2264         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, textureMode);
2265         ctx.expectError(GL_INVALID_ENUM);
2266         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, textureMode);
2267         ctx.expectError(GL_INVALID_ENUM);
2268         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, textureMode);
2269         ctx.expectError(GL_INVALID_ENUM);
2270         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, textureMode);
2271         ctx.expectError(GL_INVALID_ENUM);
2272         ctx.endSection();
2273
2274         ctx.beginSection("GL_INVALID_VALUE is generated if pname is GL_TEXTURE_BASE_LEVEL or GL_TEXTURE_MAX_LEVEL and param(s) is negative.");
2275         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, textureMode);
2276         ctx.expectError(GL_INVALID_VALUE);
2277         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, textureMode);
2278         ctx.expectError(GL_INVALID_VALUE);
2279         ctx.endSection();
2280
2281         ctx.beginSection("GL_INVALID_ENUM error is generated if target is GL_TEXTURE_2D_MULTISAMPLE or GL_TEXTURE_2D_MULTISAMPLE_ARRAY and pname is not valid.");
2282         textureMode[0] = 0;
2283         textureMode[1] = 0;
2284         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BORDER_COLOR, textureMode);
2285         ctx.expectError(GL_INVALID_ENUM);
2286         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_FILTER, textureMode);
2287         ctx.expectError(GL_INVALID_ENUM);
2288         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAG_FILTER, textureMode);
2289         ctx.expectError(GL_INVALID_ENUM);
2290         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_S, textureMode);
2291         ctx.expectError(GL_INVALID_ENUM);
2292         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_T, textureMode);
2293         ctx.expectError(GL_INVALID_ENUM);
2294         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_R, textureMode);
2295         ctx.expectError(GL_INVALID_ENUM);
2296         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_LOD, textureMode);
2297         ctx.expectError(GL_INVALID_ENUM);
2298         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAX_LOD, textureMode);
2299         ctx.expectError(GL_INVALID_ENUM);
2300         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_MODE, textureMode);
2301         ctx.expectError(GL_INVALID_ENUM);
2302         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_FUNC, textureMode);
2303         ctx.expectError(GL_INVALID_ENUM);
2304
2305         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BORDER_COLOR, textureMode);
2306         ctx.expectError(GL_INVALID_ENUM);
2307         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_FILTER, textureMode);
2308         ctx.expectError(GL_INVALID_ENUM);
2309         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAG_FILTER, textureMode);
2310         ctx.expectError(GL_INVALID_ENUM);
2311         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_S, textureMode);
2312         ctx.expectError(GL_INVALID_ENUM);
2313         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_T, textureMode);
2314         ctx.expectError(GL_INVALID_ENUM);
2315         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_R, textureMode);
2316         ctx.expectError(GL_INVALID_ENUM);
2317         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_LOD, textureMode);
2318         ctx.expectError(GL_INVALID_ENUM);
2319         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAX_LOD, textureMode);
2320         ctx.expectError(GL_INVALID_ENUM);
2321         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_MODE, textureMode);
2322         ctx.expectError(GL_INVALID_ENUM);
2323         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_FUNC, textureMode);
2324         ctx.expectError(GL_INVALID_ENUM);
2325         ctx.endSection();
2326
2327         ctx.beginSection("GL_INVALID_OPERATION is generated if target is GL_TEXTURE_2D_MULTISAMPLE or GL_TEXTURE_2D_MULTISAMPLE_ARRAY and pname GL_TEXTURE_BASE_LEVEL is not 0.");
2328         textureMode[0] = 1;
2329         textureMode[1] = 1;
2330         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, textureMode);
2331         ctx.expectError(GL_INVALID_OPERATION);
2332         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BASE_LEVEL, textureMode);
2333         ctx.expectError(GL_INVALID_OPERATION);
2334         ctx.endSection();
2335 }
2336
2337 // glTexParameterIuiv
2338
2339 void texparameterIuiv (NegativeTestContext& ctx)
2340 {
2341         if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
2342                 throw tcu::NotSupportedError("glTexParameterIuiv is not supported.", DE_NULL, __FILE__, __LINE__);
2343
2344         GLuint textureMode[] = { GL_DEPTH_COMPONENT, GL_STENCIL_INDEX };
2345         ctx.beginSection("GL_INVALID_ENUM is generated if target is not a valid target.");
2346         ctx.glTexParameterIuiv(0, GL_DEPTH_STENCIL_TEXTURE_MODE, textureMode);
2347         ctx.expectError(GL_INVALID_ENUM);
2348         ctx.endSection();
2349
2350         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not a valid parameter.");
2351         ctx.glTexParameterIuiv(GL_TEXTURE_2D, 0, textureMode);
2352         ctx.expectError(GL_INVALID_ENUM);
2353         ctx.endSection();
2354
2355         ctx.beginSection("GL_INVALID_ENUM is generated if pname is enum and the value of param(s) is not a valid value.");
2356         textureMode[0] = GL_DONT_CARE;
2357         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, textureMode);
2358         ctx.expectError(GL_INVALID_ENUM);
2359         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, textureMode);
2360         ctx.expectError(GL_INVALID_ENUM);
2361         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, textureMode);
2362         ctx.expectError(GL_INVALID_ENUM);
2363         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, textureMode);
2364         ctx.expectError(GL_INVALID_ENUM);
2365         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, textureMode);
2366         ctx.expectError(GL_INVALID_ENUM);
2367         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, textureMode);
2368         ctx.expectError(GL_INVALID_ENUM);
2369         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, textureMode);
2370         ctx.expectError(GL_INVALID_ENUM);
2371         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, textureMode);
2372         ctx.expectError(GL_INVALID_ENUM);
2373         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, textureMode);
2374         ctx.expectError(GL_INVALID_ENUM);
2375         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, textureMode);
2376         ctx.expectError(GL_INVALID_ENUM);
2377         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, textureMode);
2378         ctx.expectError(GL_INVALID_ENUM);
2379         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, textureMode);
2380         ctx.expectError(GL_INVALID_ENUM);
2381         ctx.endSection();
2382
2383         ctx.beginSection("GL_INVALID_ENUM error is generated if target is GL_TEXTURE_2D_MULTISAMPLE or GL_TEXTURE_2D_MULTISAMPLE_ARRAY and pname is not valid.");
2384         textureMode[0] = 0;
2385         textureMode[1] = 0;
2386         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BORDER_COLOR, textureMode);
2387         ctx.expectError(GL_INVALID_ENUM);
2388         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_FILTER, textureMode);
2389         ctx.expectError(GL_INVALID_ENUM);
2390         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAG_FILTER, textureMode);
2391         ctx.expectError(GL_INVALID_ENUM);
2392         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_S, textureMode);
2393         ctx.expectError(GL_INVALID_ENUM);
2394         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_T, textureMode);
2395         ctx.expectError(GL_INVALID_ENUM);
2396         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_R, textureMode);
2397         ctx.expectError(GL_INVALID_ENUM);
2398         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_LOD, textureMode);
2399         ctx.expectError(GL_INVALID_ENUM);
2400         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAX_LOD, textureMode);
2401         ctx.expectError(GL_INVALID_ENUM);
2402         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_MODE, textureMode);
2403         ctx.expectError(GL_INVALID_ENUM);
2404         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_FUNC, textureMode);
2405         ctx.expectError(GL_INVALID_ENUM);
2406
2407         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BORDER_COLOR, textureMode);
2408         ctx.expectError(GL_INVALID_ENUM);
2409         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_FILTER, textureMode);
2410         ctx.expectError(GL_INVALID_ENUM);
2411         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAG_FILTER, textureMode);
2412         ctx.expectError(GL_INVALID_ENUM);
2413         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_S, textureMode);
2414         ctx.expectError(GL_INVALID_ENUM);
2415         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_T, textureMode);
2416         ctx.expectError(GL_INVALID_ENUM);
2417         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_R, textureMode);
2418         ctx.expectError(GL_INVALID_ENUM);
2419         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_LOD, textureMode);
2420         ctx.expectError(GL_INVALID_ENUM);
2421         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAX_LOD, textureMode);
2422         ctx.expectError(GL_INVALID_ENUM);
2423         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_MODE, textureMode);
2424         ctx.expectError(GL_INVALID_ENUM);
2425         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_FUNC, textureMode);
2426         ctx.expectError(GL_INVALID_ENUM);
2427         ctx.endSection();
2428
2429         ctx.beginSection("GL_INVALID_OPERATION is generated if target is GL_TEXTURE_2D_MULTISAMPLE or GL_TEXTURE_2D_MULTISAMPLE_ARRAY and pname GL_TEXTURE_BASE_LEVEL is not 0.");
2430         textureMode[0] = 1;
2431         textureMode[1] = 1;
2432         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, textureMode);
2433         ctx.expectError(GL_INVALID_OPERATION);
2434         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BASE_LEVEL, textureMode);
2435         ctx.expectError(GL_INVALID_OPERATION);
2436         ctx.endSection();
2437 }
2438
2439 // glCompressedTexSubImage2D
2440
2441 void compressedtexsubimage2d (NegativeTestContext& ctx)
2442 {
2443         ctx.beginSection("GL_INVALID_ENUM is generated if target is invalid.");
2444         ctx.glCompressedTexSubImage2D(0, 0, 0, 0, 0, 0, GL_COMPRESSED_RGB8_ETC2, 0, 0);
2445         ctx.expectError(GL_INVALID_ENUM);
2446         ctx.endSection();
2447
2448         deUint32                                texture = 0x1234;
2449         ctx.glGenTextures                       (1, &texture);
2450         ctx.glBindTexture                       (GL_TEXTURE_2D, texture);
2451         ctx.glCompressedTexImage2D      (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 0, etc2EacDataSize(18, 18), 0);
2452         ctx.expectError                         (GL_NO_ERROR);
2453
2454         ctx.beginSection("GL_INVALID_OPERATION is generated if format does not match the internal format of the texture image being modified.");
2455         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, GL_COMPRESSED_RGB8_ETC2, 0, 0);
2456         ctx.expectError(GL_INVALID_OPERATION);
2457         ctx.endSection();
2458
2459         ctx.beginSection("For ETC2/EAC images GL_INVALID_OPERATION is generated if width is not a multiple of four, and width + xoffset is not equal to the width of the texture level.");
2460         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 4, 0, 10, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(10, 4), 0);
2461         ctx.expectError(GL_INVALID_OPERATION);
2462         ctx.endSection();
2463
2464         ctx.beginSection("For ETC2/EAC images GL_INVALID_OPERATION is generated if height is not a multiple of four, and height + yoffset is not equal to the height of the texture level.");
2465         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 4, 4, 10, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 10), 0);
2466         ctx.expectError(GL_INVALID_OPERATION);
2467         ctx.endSection();
2468
2469         ctx.beginSection("For ETC2/EAC images GL_INVALID_OPERATION is generated if xoffset or yoffset is not a multiple of four.");
2470         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 1, 4, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
2471         ctx.expectError(GL_INVALID_OPERATION);
2472         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 1, 0, 4, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
2473         ctx.expectError(GL_INVALID_OPERATION);
2474         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 1, 1, 4, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
2475         ctx.expectError(GL_INVALID_OPERATION);
2476         ctx.endSection();
2477
2478         ctx.glDeleteTextures            (1, &texture);
2479 }
2480
2481 void compressedtexsubimage2d_neg_level (NegativeTestContext& ctx)
2482 {
2483         deUint32                                textures[2];
2484         ctx.glGenTextures                       (2, &textures[0]);
2485         ctx.glBindTexture                       (GL_TEXTURE_2D, textures[0]);
2486         ctx.glCompressedTexImage2D      (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 0, etc2EacDataSize(18, 18), 0);
2487         ctx.glBindTexture                       (GL_TEXTURE_CUBE_MAP, textures[1]);
2488         FOR_CUBE_FACES(faceGL, ctx.glCompressedTexImage2D(faceGL, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 0, etc2EacDataSize(18, 18), 0););
2489         ctx.expectError                         (GL_NO_ERROR);
2490
2491         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
2492         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, -1, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2493         ctx.expectError(GL_INVALID_VALUE);
2494         ctx.endSection();
2495
2496         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
2497         FOR_CUBE_FACES(faceGL,
2498         {
2499                 ctx.glCompressedTexSubImage2D(faceGL, -1, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2500                 ctx.expectError(GL_INVALID_VALUE);
2501         });
2502         ctx.endSection();
2503
2504         ctx.glDeleteTextures(2, &textures[0]);
2505 }
2506
2507 void compressedtexsubimage2d_max_level (NegativeTestContext& ctx)
2508 {
2509         deUint32                                textures[2];
2510         ctx.glGenTextures                       (2, &textures[0]);
2511         ctx.glBindTexture                       (GL_TEXTURE_2D, textures[0]);
2512         ctx.glCompressedTexImage2D      (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 0, etc2EacDataSize(18, 18), 0);
2513         ctx.glBindTexture                       (GL_TEXTURE_CUBE_MAP, textures[1]);
2514         FOR_CUBE_FACES(faceGL, ctx.glCompressedTexImage2D(faceGL, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 0, etc2EacDataSize(18, 18), 0););
2515         ctx.expectError                         (GL_NO_ERROR);
2516
2517         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
2518         deUint32 log2MaxTextureSize = deLog2Floor32(ctx.getInteger(GL_MAX_TEXTURE_SIZE)) + 1;
2519         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, log2MaxTextureSize, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2520         ctx.expectError(GL_INVALID_VALUE);
2521         ctx.endSection();
2522
2523         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_TEXTURE_SIZE).");
2524         deUint32 log2MaxCubemapSize = deLog2Floor32(ctx.getInteger(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
2525         FOR_CUBE_FACES(faceGL,
2526         {
2527                 ctx.glCompressedTexSubImage2D(faceGL, log2MaxCubemapSize, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2528                 ctx.expectError(GL_INVALID_VALUE);
2529         });
2530         ctx.endSection();
2531
2532         ctx.glDeleteTextures(2, &textures[0]);
2533 }
2534
2535 void compressedtexsubimage2d_neg_offset (NegativeTestContext& ctx)
2536 {
2537         GLuint texture = 0x1234;
2538         ctx.glGenTextures(1, &texture);
2539         ctx.glBindTexture(GL_TEXTURE_2D, texture);
2540         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 8, 8, 0, etc2EacDataSize(8, 8), 0);
2541
2542         // \note Both GL_INVALID_VALUE and GL_INVALID_OPERATION are valid here since implementation may
2543         //               first check if offsets are valid for certain format and only after that check that they
2544         //               are not negative.
2545         ctx.beginSection("GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if xoffset or yoffset are negative.");
2546
2547         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, -4, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2548         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2549         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, -4, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2550         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2551         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, -4, -4, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2552         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2553
2554         ctx.endSection();
2555
2556         ctx.glDeleteTextures(1, &texture);
2557 }
2558
2559 void compressedtexsubimage2d_invalid_offset (NegativeTestContext& ctx)
2560 {
2561         deUint32                                texture = 0x1234;
2562         ctx.glGenTextures                       (1, &texture);
2563         ctx.glBindTexture                       (GL_TEXTURE_2D, texture);
2564         ctx.glCompressedTexImage2D      (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
2565         ctx.expectError                         (GL_NO_ERROR);
2566
2567         ctx.beginSection("GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if xoffset + width > texture_width or yoffset + height > texture_height.");
2568
2569         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 12, 0, 8, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(8, 4), 0);
2570         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2571         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 12, 4, 8, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 8), 0);
2572         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2573         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 12, 12, 8, 8, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(8, 8), 0);
2574         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2575         ctx.endSection();
2576
2577         ctx.glDeleteTextures            (1, &texture);
2578 }
2579
2580 void compressedtexsubimage2d_neg_width_height (NegativeTestContext& ctx)
2581 {
2582         deUint32                                texture = 0x1234;
2583         ctx.glGenTextures                       (1, &texture);
2584         ctx.glBindTexture                       (GL_TEXTURE_2D, texture);
2585         ctx.glCompressedTexImage2D      (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
2586         ctx.expectError                         (GL_NO_ERROR);
2587
2588         ctx.beginSection("GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if width or height is less than 0.");
2589         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, -4, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2590         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2591         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, -4, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2592         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2593         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, -4, -4, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2594         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2595         ctx.endSection();
2596
2597         ctx.glDeleteTextures(1,         &texture);
2598 }
2599
2600 void compressedtexsubimage2d_invalid_size (NegativeTestContext& ctx)
2601 {
2602         deUint32                                texture = 0x1234;
2603         ctx.glGenTextures                       (1, &texture);
2604         ctx.glBindTexture                       (GL_TEXTURE_2D, texture);
2605         ctx.glCompressedTexImage2D      (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
2606         ctx.expectError                         (GL_NO_ERROR);
2607
2608         ctx.beginSection("GL_INVALID_VALUE is generated if imageSize is not consistent with the format, dimensions, and contents of the specified compressed image data.");
2609         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0);
2610         ctx.expectError(GL_INVALID_VALUE);
2611
2612         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 16, 16, GL_COMPRESSED_RGBA8_ETC2_EAC, 4*4*16-1, 0);
2613         ctx.expectError(GL_INVALID_VALUE);
2614         ctx.endSection();
2615
2616         ctx.glDeleteTextures            (1, &texture);
2617 }
2618
2619 void compressedtexsubimage2d_invalid_buffer_target (NegativeTestContext& ctx)
2620 {
2621         deUint32                                        buf = 0x1234;
2622         deUint32                                        texture = 0x1234;
2623         std::vector<GLubyte>            data(128);
2624
2625         ctx.glGenTextures                               (1, &texture);
2626         ctx.glBindTexture                               (GL_TEXTURE_2D, texture);
2627         ctx.glCompressedTexImage2D              (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
2628         ctx.glGenBuffers                                (1, &buf);
2629         ctx.glBindBuffer                                (GL_PIXEL_UNPACK_BUFFER, buf);
2630         ctx.glBufferData                                (GL_PIXEL_UNPACK_BUFFER, 128, &data[0], GL_DYNAMIC_COPY);
2631         ctx.expectError                                 (GL_NO_ERROR);
2632
2633         ctx.beginSection("GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and...");
2634         ctx.beginSection("...the buffer object's data store is currently mapped.");
2635         ctx.glMapBufferRange                    (GL_PIXEL_UNPACK_BUFFER, 0, 128, GL_MAP_WRITE_BIT);
2636         ctx.glCompressedTexSubImage2D   (GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
2637         ctx.expectError                                 (GL_INVALID_OPERATION);
2638         ctx.glUnmapBuffer                               (GL_PIXEL_UNPACK_BUFFER);
2639         ctx.endSection();
2640
2641         ctx.beginSection("...the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
2642         ctx.glCompressedTexSubImage2D   (GL_TEXTURE_2D, 0, 0, 0, 16, 16, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(16, 16), 0);
2643         ctx.expectError                                 (GL_INVALID_OPERATION);
2644         ctx.endSection();
2645         ctx.endSection();
2646
2647         ctx.glDeleteBuffers                     (1, &buf);
2648         ctx.glDeleteTextures            (1, &texture);
2649 }
2650
2651 // glTexImage3D
2652
2653 void teximage3d (NegativeTestContext& ctx)
2654 {
2655         ctx.beginSection("GL_INVALID_ENUM is generated if target is invalid.");
2656         ctx.glTexImage3D(0, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2657         ctx.expectError(GL_INVALID_ENUM);
2658         ctx.glTexImage3D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2659         ctx.expectError(GL_INVALID_ENUM);
2660         ctx.endSection();
2661
2662         ctx.beginSection("GL_INVALID_ENUM is generated if type is not a type constant.");
2663         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, 0, 0);
2664         ctx.expectError(GL_INVALID_ENUM);
2665         ctx.endSection();
2666
2667         ctx.beginSection("GL_INVALID_ENUM is generated if format is not an accepted format constant.");
2668         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, 1, 0, 0, GL_UNSIGNED_BYTE, 0);
2669         ctx.expectError(GL_INVALID_ENUM);
2670         ctx.endSection();
2671
2672         ctx.beginSection("GL_INVALID_VALUE is generated if internalFormat is not one of the accepted resolution and format symbolic constants.");
2673         ctx.glTexImage3D(GL_TEXTURE_3D, 0, 0, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2674         ctx.expectError(GL_INVALID_VALUE);
2675         ctx.endSection();
2676
2677         ctx.beginSection("GL_INVALID_OPERATION is generated if target is GL_TEXTURE_3D and format is GL_DEPTH_COMPONENT, or GL_DEPTH_STENCIL.");
2678         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_DEPTH_STENCIL, 1, 1, 1, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 0);
2679         ctx.expectError(GL_INVALID_OPERATION);
2680         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_DEPTH_COMPONENT, 1, 1, 1, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0);
2681         ctx.expectError(GL_INVALID_OPERATION);
2682         ctx.endSection();
2683
2684         ctx.beginSection("GL_INVALID_OPERATION is generated if the combination of internalFormat, format and type is invalid.");
2685         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2686         ctx.expectError(GL_INVALID_OPERATION);
2687         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, 0);
2688         ctx.expectError(GL_INVALID_OPERATION);
2689         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB5_A1, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, 0);
2690         ctx.expectError(GL_INVALID_OPERATION);
2691         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB10_A2, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_INT_2_10_10_10_REV, 0);
2692         ctx.expectError(GL_INVALID_OPERATION);
2693         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA32UI, 1, 1, 1, 0, GL_RGBA_INTEGER, GL_INT, 0);
2694         ctx.expectError(GL_INVALID_OPERATION);
2695         ctx.endSection();
2696
2697         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
2698         {
2699                 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_TEXTURE_CUBE_MAP_ARRAY and width and height are not equal.");
2700                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, 2, 1, 6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2701                 ctx.expectError(GL_INVALID_VALUE);
2702                 ctx.endSection();
2703
2704                 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_TEXTURE_CUBE_MAP_ARRAY and depth is not a multiple of six.");
2705                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2706                 ctx.expectError(GL_INVALID_VALUE);
2707                 ctx.endSection();
2708         }
2709 }
2710
2711 void teximage3d_neg_level (NegativeTestContext& ctx)
2712 {
2713         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
2714         ctx.glTexImage3D(GL_TEXTURE_3D, -1, GL_RGB, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
2715         ctx.expectError(GL_INVALID_VALUE);
2716         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, -1, GL_RGB, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
2717         ctx.expectError(GL_INVALID_VALUE);
2718
2719         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
2720         {
2721                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, -1, GL_RGBA, 1, 1, 6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2722                 ctx.expectError(GL_INVALID_VALUE);
2723         }
2724
2725         ctx.endSection();
2726
2727 }
2728
2729 void teximage3d_max_level (NegativeTestContext& ctx)
2730 {
2731         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_3D_TEXTURE_SIZE).");
2732         deUint32 log2Max3DTextureSize = deLog2Floor32(ctx.getInteger(GL_MAX_3D_TEXTURE_SIZE)) + 1;
2733         ctx.glTexImage3D(GL_TEXTURE_3D, log2Max3DTextureSize, GL_RGB, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
2734         ctx.expectError(GL_INVALID_VALUE);
2735         ctx.endSection();
2736
2737         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
2738         deUint32 log2MaxTextureSize = deLog2Floor32(ctx.getInteger(GL_MAX_TEXTURE_SIZE)) + 1;
2739         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, log2MaxTextureSize, GL_RGB, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
2740         ctx.expectError(GL_INVALID_VALUE);
2741         ctx.endSection();
2742 }
2743
2744 void teximage3d_neg_width_height_depth (NegativeTestContext& ctx)
2745 {
2746         ctx.beginSection("GL_INVALID_VALUE is generated if width or height is less than 0.");
2747         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, -1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2748         ctx.expectError(GL_INVALID_VALUE);
2749         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, -1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2750         ctx.expectError(GL_INVALID_VALUE);
2751         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2752         ctx.expectError(GL_INVALID_VALUE);
2753         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, -1, -1, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2754         ctx.expectError(GL_INVALID_VALUE);
2755
2756         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, -1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2757         ctx.expectError(GL_INVALID_VALUE);
2758         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 1, -1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2759         ctx.expectError(GL_INVALID_VALUE);
2760         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 1, 1, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2761         ctx.expectError(GL_INVALID_VALUE);
2762         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, -1, -1, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2763         ctx.expectError(GL_INVALID_VALUE);
2764
2765         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
2766         {
2767                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, -1, 1, 6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2768                 ctx.expectError(GL_INVALID_VALUE);
2769                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, 1, -1, 6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2770                 ctx.expectError(GL_INVALID_VALUE);
2771                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, 1, 1, -6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2772                 ctx.expectError(GL_INVALID_VALUE);
2773                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, -1, -1, -6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2774                 ctx.expectError(GL_INVALID_VALUE);
2775         }
2776         ctx.endSection();
2777 }
2778
2779 void teximage3d_max_width_height_depth (NegativeTestContext& ctx)
2780 {
2781         int max3DTextureSize    = ctx.getInteger(GL_MAX_3D_TEXTURE_SIZE) + 1;
2782         int maxTextureSize              = ctx.getInteger(GL_MAX_TEXTURE_SIZE) + 1;
2783
2784         ctx.beginSection("GL_INVALID_VALUE is generated if width, height or depth is greater than GL_MAX_3D_TEXTURE_SIZE.");
2785         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, max3DTextureSize, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2786         ctx.expectError(GL_INVALID_VALUE);
2787         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, max3DTextureSize, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2788         ctx.expectError(GL_INVALID_VALUE);
2789         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, max3DTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2790         ctx.expectError(GL_INVALID_VALUE);
2791         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, max3DTextureSize, max3DTextureSize, max3DTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2792         ctx.expectError(GL_INVALID_VALUE);
2793         ctx.endSection();
2794
2795         ctx.beginSection("GL_INVALID_VALUE is generated if width, height or depth is greater than GL_MAX_TEXTURE_SIZE.");
2796         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, maxTextureSize, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2797         ctx.expectError(GL_INVALID_VALUE);
2798         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 1, maxTextureSize, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2799         ctx.expectError(GL_INVALID_VALUE);
2800         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 1, 1, maxTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2801         ctx.expectError(GL_INVALID_VALUE);
2802         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, maxTextureSize, maxTextureSize, maxTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2803         ctx.expectError(GL_INVALID_VALUE);
2804         ctx.endSection();
2805 }
2806
2807 void teximage3d_invalid_border (NegativeTestContext& ctx)
2808 {
2809         ctx.beginSection("GL_INVALID_VALUE is generated if border is not 0 or 1.");
2810         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, 1, 1, 1, -1, GL_RGB, GL_UNSIGNED_BYTE, 0);
2811         ctx.expectError(GL_INVALID_VALUE);
2812         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, 1, 1, 1, 2, GL_RGB, GL_UNSIGNED_BYTE, 0);
2813         ctx.expectError(GL_INVALID_VALUE);
2814         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGB, 1, 1, 1, -1, GL_RGB, GL_UNSIGNED_BYTE, 0);
2815         ctx.expectError(GL_INVALID_VALUE);
2816         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGB, 1, 1, 1, 2, GL_RGB, GL_UNSIGNED_BYTE, 0);
2817         ctx.expectError(GL_INVALID_VALUE);
2818
2819         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
2820         {
2821                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA, 1, 1, 6, -1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2822                 ctx.expectError(GL_INVALID_VALUE);
2823                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA, 1, 1, 6, 1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2824                 ctx.expectError(GL_INVALID_VALUE);
2825         }
2826
2827         ctx.endSection();
2828 }
2829
2830 void teximage3d_invalid_buffer_target (NegativeTestContext& ctx)
2831 {
2832         deUint32                                buf = 0x1234;
2833         deUint32                                texture = 0x1234;
2834         std::vector<GLubyte>    data(512);
2835
2836         ctx.glGenBuffers                        (1, &buf);
2837         ctx.glBindBuffer                        (GL_PIXEL_UNPACK_BUFFER, buf);
2838         ctx.glBufferData                        (GL_PIXEL_UNPACK_BUFFER, 512, &data[0], GL_DYNAMIC_COPY);
2839         ctx.glGenTextures                       (1, &texture);
2840         ctx.glBindTexture                       (GL_TEXTURE_3D, texture);
2841         ctx.expectError                         (GL_NO_ERROR);
2842
2843         ctx.beginSection("GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and...");
2844
2845         ctx.beginSection("...the buffer object's data store is currently mapped.");
2846         ctx.glMapBufferRange            (GL_PIXEL_UNPACK_BUFFER, 0, 128, GL_MAP_WRITE_BIT);
2847         ctx.glTexImage3D                        (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2848         ctx.expectError                         (GL_INVALID_OPERATION);
2849         ctx.glUnmapBuffer                       (GL_PIXEL_UNPACK_BUFFER);
2850         ctx.endSection();
2851
2852         ctx.beginSection("...the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
2853         ctx.glTexImage3D                        (GL_TEXTURE_3D, 0, GL_RGBA, 64, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2854         ctx.expectError                         (GL_INVALID_OPERATION);
2855         ctx.endSection();
2856
2857         ctx.beginSection("...data is not evenly divisible into the number of bytes needed to store in memory a datum indicated by type.");
2858         ctx.getLog() << TestLog::Message << "// Set byte offset = 3" << TestLog::EndMessage;
2859         ctx.glTexImage3D                        (GL_TEXTURE_3D, 0, GL_RGB5_A1, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, (const GLvoid*)3);
2860         ctx.expectError                         (GL_INVALID_OPERATION);
2861         ctx.endSection();
2862
2863         ctx.endSection();
2864
2865         ctx.glDeleteBuffers                     (1, &buf);
2866         ctx.glDeleteTextures            (1, &texture);
2867 }
2868
2869 // glTexSubImage3D
2870
2871 void texsubimage3d (NegativeTestContext& ctx)
2872 {
2873         deUint32                        texture = 0x1234;
2874         ctx.glGenTextures               (1, &texture);
2875         ctx.glBindTexture               (GL_TEXTURE_3D, texture);
2876         ctx.glTexImage3D                (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2877         ctx.expectError                 (GL_NO_ERROR);
2878
2879         ctx.beginSection("GL_INVALID_ENUM is generated if target is invalid.");
2880         ctx.glTexSubImage3D(0, 0, 0, 0, 0, 4, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2881         ctx.expectError(GL_INVALID_ENUM);
2882         ctx.glTexSubImage3D(GL_TEXTURE_2D, 0, 0, 0, 0, 4, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2883         ctx.expectError(GL_INVALID_ENUM);
2884         ctx.endSection();
2885
2886         ctx.beginSection("GL_INVALID_ENUM is generated if format is not an accepted format constant.");
2887         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 4, 4, 4, GL_UNSIGNED_BYTE, 0);
2888         ctx.expectError(GL_INVALID_ENUM);
2889         ctx.endSection();
2890
2891         ctx.beginSection("GL_INVALID_ENUM is generated if type is not a type constant.");
2892         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGB, 0, 0);
2893         ctx.expectError(GL_INVALID_ENUM);
2894         ctx.endSection();
2895
2896         ctx.beginSection("GL_INVALID_OPERATION is generated if the combination of internalFormat of the previously specified texture array, format and type is not valid.");
2897         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, 0);
2898         ctx.expectError(GL_INVALID_OPERATION);
2899         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, 0);
2900         ctx.expectError(GL_INVALID_OPERATION);
2901         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, 0);
2902         ctx.expectError(GL_INVALID_OPERATION);
2903         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGBA_INTEGER, GL_UNSIGNED_INT, 0);
2904         ctx.expectError(GL_INVALID_OPERATION);
2905         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGB, GL_FLOAT, 0);
2906         ctx.expectError(GL_INVALID_OPERATION);
2907         ctx.endSection();
2908
2909         ctx.glDeleteTextures    (1, &texture);
2910 }
2911
2912 void texsubimage3d_neg_level (NegativeTestContext& ctx)
2913 {
2914         deUint32                        textures[3];
2915         ctx.glGenTextures               (3, &textures[0]);
2916         ctx.glBindTexture               (GL_TEXTURE_3D, textures[0]);
2917         ctx.glTexImage3D                (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2918         ctx.glBindTexture               (GL_TEXTURE_2D_ARRAY, textures[1]);
2919         ctx.glTexImage3D                (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2920         ctx.expectError                 (GL_NO_ERROR);
2921
2922         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
2923         ctx.glTexSubImage3D(GL_TEXTURE_3D, -1, 0, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2924         ctx.expectError(GL_INVALID_VALUE);
2925         ctx.glTexSubImage3D(GL_TEXTURE_2D_ARRAY, -1, 0, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2926         ctx.expectError(GL_INVALID_VALUE);
2927
2928         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
2929         {
2930                 ctx.glBindTexture               (GL_TEXTURE_CUBE_MAP_ARRAY, textures[2]);
2931                 ctx.glTexImage3D                (GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, 4, 4, 6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2932                 ctx.expectError                 (GL_NO_ERROR);
2933
2934                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, -1, 0, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2935                 ctx.expectError(GL_INVALID_VALUE);
2936         }
2937
2938         ctx.endSection();
2939
2940         ctx.glDeleteTextures    (3, &textures[0]);
2941 }
2942
2943 void texsubimage3d_max_level (NegativeTestContext& ctx)
2944 {
2945         deUint32                        textures[2];
2946         ctx.glGenTextures               (2, &textures[0]);
2947         ctx.glBindTexture               (GL_TEXTURE_3D, textures[0]);
2948         ctx.glTexImage3D                (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2949         ctx.glBindTexture               (GL_TEXTURE_2D_ARRAY, textures[1]);
2950         ctx.glTexImage3D                (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2951         ctx.expectError                 (GL_NO_ERROR);
2952
2953         deUint32 log2Max3DTextureSize   = deLog2Floor32(ctx.getInteger(GL_MAX_3D_TEXTURE_SIZE)) + 1;
2954         deUint32 log2MaxTextureSize             = deLog2Floor32(ctx.getInteger(GL_MAX_TEXTURE_SIZE)) + 1;
2955
2956         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_3D_TEXTURE_SIZE).");
2957         ctx.glTexSubImage3D(GL_TEXTURE_3D, log2Max3DTextureSize, 0, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2958         ctx.expectError(GL_INVALID_VALUE);
2959         ctx.endSection();
2960
2961         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
2962         ctx.glTexSubImage3D(GL_TEXTURE_2D_ARRAY, log2MaxTextureSize, 0, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2963         ctx.expectError(GL_INVALID_VALUE);
2964         ctx.endSection();
2965
2966         ctx.glDeleteTextures    (2, &textures[0]);
2967 }
2968
2969 void texsubimage3d_neg_offset (NegativeTestContext& ctx)
2970 {
2971         deUint32                        textures[3];
2972         ctx.glGenTextures               (3, &textures[0]);
2973         ctx.glBindTexture               (GL_TEXTURE_3D, textures[0]);
2974         ctx.glTexImage3D                (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2975         ctx.glBindTexture               (GL_TEXTURE_2D_ARRAY, textures[1]);
2976         ctx.glTexImage3D                (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2977         ctx.expectError                 (GL_NO_ERROR);
2978
2979         ctx.beginSection("GL_INVALID_VALUE is generated if xoffset, yoffset or zoffset are negative.");
2980         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, -1, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2981         ctx.expectError(GL_INVALID_VALUE);
2982         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, -1, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2983         ctx.expectError(GL_INVALID_VALUE);
2984         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, -1, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2985         ctx.expectError(GL_INVALID_VALUE);
2986         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, -1, -1, -1, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2987         ctx.expectError(GL_INVALID_VALUE);
2988         ctx.glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, -1, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2989         ctx.expectError(GL_INVALID_VALUE);
2990         ctx.glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, -1, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2991         ctx.expectError(GL_INVALID_VALUE);
2992         ctx.glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, -1, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2993         ctx.expectError(GL_INVALID_VALUE);
2994         ctx.glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, -1, -1, -1, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2995         ctx.expectError(GL_INVALID_VALUE);
2996
2997         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
2998         {
2999                 ctx.glBindTexture               (GL_TEXTURE_CUBE_MAP_ARRAY, textures[2]);
3000                 ctx.glTexImage3D                (GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, 4, 4, 6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3001                 ctx.expectError                 (GL_NO_ERROR);
3002
3003                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, -1, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3004                 ctx.expectError(GL_INVALID_VALUE);
3005                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, -1, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3006                 ctx.expectError(GL_INVALID_VALUE);
3007                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, 0, -1, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3008                 ctx.expectError(GL_INVALID_VALUE);
3009                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, -1, -1, -1, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3010                 ctx.expectError(GL_INVALID_VALUE);
3011         }
3012
3013         ctx.endSection();
3014
3015         ctx.glDeleteTextures    (3, &textures[0]);
3016 }
3017
3018 void texsubimage3d_invalid_offset (NegativeTestContext& ctx)
3019 {
3020         deUint32                        texture = 0x1234;
3021         ctx.glGenTextures               (1, &texture);
3022         ctx.glBindTexture               (GL_TEXTURE_3D, texture);
3023         ctx.glTexImage3D                (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3024         ctx.expectError                 (GL_NO_ERROR);
3025
3026         ctx.beginSection("GL_INVALID_VALUE is generated if xoffset + width > texture_width.");
3027         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 2, 0, 0, 4, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3028         ctx.expectError(GL_INVALID_VALUE);
3029         ctx.endSection();
3030
3031         ctx.beginSection("GL_INVALID_VALUE is generated if yoffset + height > texture_height.");
3032         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 2, 0, 4, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3033         ctx.expectError(GL_INVALID_VALUE);
3034         ctx.endSection();
3035
3036         ctx.beginSection("GL_INVALID_VALUE is generated if zoffset + depth > texture_depth.");
3037         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 2, 4, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3038         ctx.expectError(GL_INVALID_VALUE);
3039         ctx.endSection();
3040
3041         ctx.glDeleteTextures    (1, &texture);
3042 }
3043
3044 void texsubimage3d_neg_width_height (NegativeTestContext& ctx)
3045 {
3046         ctx.beginSection("GL_INVALID_VALUE is generated if width, height or depth is less than 0.");
3047         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, -1, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3048         ctx.expectError(GL_INVALID_VALUE);
3049         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3050         ctx.expectError(GL_INVALID_VALUE);
3051         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, -1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3052         ctx.expectError(GL_INVALID_VALUE);
3053         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, -1, -1, -1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3054         ctx.expectError(GL_INVALID_VALUE);
3055
3056         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3057         {
3058                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, 0, 0, -1, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3059                 ctx.expectError(GL_INVALID_VALUE);
3060                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, 0, 0, 0, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3061                 ctx.expectError(GL_INVALID_VALUE);
3062                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, 0, 0, 0, 0, -1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3063                 ctx.expectError(GL_INVALID_VALUE);
3064                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, 0, 0, -1, -1, -1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3065                 ctx.expectError(GL_INVALID_VALUE);
3066         }
3067
3068         ctx.endSection();
3069 }
3070
3071 void texsubimage3d_invalid_buffer_target (NegativeTestContext& ctx)
3072 {
3073         deUint32                                buf = 0x1234;
3074         deUint32                                texture = 0x1234;
3075         std::vector<GLubyte>    data(512);
3076
3077         ctx.glGenTextures                       (1, &texture);
3078         ctx.glBindTexture                       (GL_TEXTURE_3D, texture);
3079         ctx.glTexImage3D                        (GL_TEXTURE_3D, 0, GL_RGBA, 16, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3080         ctx.glGenBuffers                        (1, &buf);
3081         ctx.glBindBuffer                        (GL_PIXEL_UNPACK_BUFFER, buf);
3082         ctx.glBufferData                        (GL_PIXEL_UNPACK_BUFFER, 512, &data[0], GL_DYNAMIC_COPY);
3083         ctx.expectError                         (GL_NO_ERROR);
3084
3085         ctx.beginSection("GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and...");
3086
3087         ctx.beginSection("...the buffer object's data store is currently mapped.");
3088         ctx.glMapBufferRange            (GL_PIXEL_UNPACK_BUFFER, 0, 512, GL_MAP_WRITE_BIT);
3089         ctx.glTexSubImage3D                     (GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3090         ctx.expectError                         (GL_INVALID_OPERATION);
3091         ctx.glUnmapBuffer                       (GL_PIXEL_UNPACK_BUFFER);
3092         ctx.endSection();
3093
3094         ctx.beginSection("...the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
3095         ctx.glTexSubImage3D                     (GL_TEXTURE_3D, 0, 0, 0, 0, 16, 16, 16, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3096         ctx.expectError                         (GL_INVALID_OPERATION);
3097         ctx.endSection();
3098
3099         ctx.beginSection("...data is not evenly divisible into the number of bytes needed to store in memory a datum indicated by type.");
3100         ctx.getLog() << TestLog::Message << "// Set byte offset = 3" << TestLog::EndMessage;
3101         ctx.glBindBuffer                        (GL_PIXEL_UNPACK_BUFFER, 0);
3102         ctx.glTexImage3D                        (GL_TEXTURE_3D, 0, GL_RGBA4, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, 0);
3103         ctx.glBindBuffer                        (GL_PIXEL_UNPACK_BUFFER, buf);
3104         ctx.expectError                         (GL_NO_ERROR);
3105         ctx.glTexSubImage3D                     (GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, (const GLvoid*)3);
3106         ctx.expectError                         (GL_INVALID_OPERATION);
3107         ctx.endSection();
3108
3109         ctx.endSection();
3110
3111         ctx.glDeleteBuffers                     (1, &buf);
3112         ctx.glDeleteTextures            (1, &texture);
3113 }
3114
3115 // glCopyTexSubImage3D
3116
3117 void copytexsubimage3d (NegativeTestContext& ctx)
3118 {
3119         GLuint texture = 0x1234;
3120         ctx.glGenTextures       (1, &texture);
3121         ctx.glBindTexture       (GL_TEXTURE_3D, texture);
3122         ctx.glTexImage3D        (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3123
3124         ctx.beginSection("GL_INVALID_ENUM is generated if target is invalid.");
3125         ctx.glCopyTexSubImage3D(0, 0, 0, 0, 0, 0, 0, 4, 4);
3126         ctx.expectError(GL_INVALID_ENUM);
3127         ctx.endSection();
3128
3129         ctx.glDeleteTextures(1, &texture);
3130 }
3131
3132 void copytexsubimage3d_neg_level (NegativeTestContext& ctx)
3133 {
3134         deUint32        textures[3];
3135         ctx.glGenTextures(3, &textures[0]);
3136         ctx.glBindTexture(GL_TEXTURE_3D, textures[0]);
3137         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3138         ctx.glBindTexture(GL_TEXTURE_2D_ARRAY, textures[1]);
3139         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3140         ctx.expectError(GL_NO_ERROR);
3141
3142         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
3143         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, -1, 0, 0, 0, 0, 0, 4, 4);
3144         ctx.expectError(GL_INVALID_VALUE);
3145         ctx.glCopyTexSubImage3D(GL_TEXTURE_2D_ARRAY, -1, 0, 0, 0, 0, 0, 4, 4);
3146         ctx.expectError(GL_INVALID_VALUE);
3147
3148         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3149         {
3150                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, textures[2]);
3151                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, 4, 4, 6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3152                 ctx.expectError(GL_NO_ERROR);
3153                 ctx.glCopyTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, -1, 0, 0, 0, 0, 0, 4, 4);
3154                 ctx.expectError(GL_INVALID_VALUE);
3155         }
3156
3157         ctx.endSection();
3158
3159         ctx.glDeleteTextures(3, &textures[0]);
3160 }
3161
3162 void copytexsubimage3d_max_level (NegativeTestContext& ctx)
3163 {
3164         deUint32        log2Max3DTextureSize            = deLog2Floor32(ctx.getInteger(GL_MAX_3D_TEXTURE_SIZE)) + 1;
3165         deUint32        log2MaxTextureSize                      = deLog2Floor32(ctx.getInteger(GL_MAX_TEXTURE_SIZE)) + 1;
3166         deUint32        log2MaxCubeMapTextureSize       = deLog2Floor32(ctx.getInteger(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
3167
3168         deUint32        textures[3];
3169         ctx.glGenTextures(3, &textures[0]);
3170         ctx.glBindTexture(GL_TEXTURE_3D, textures[0]);
3171         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3172         ctx.glBindTexture(GL_TEXTURE_2D_ARRAY, textures[1]);
3173         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3174         ctx.expectError(GL_NO_ERROR);
3175
3176         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_3D_TEXTURE_SIZE).");
3177         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, log2Max3DTextureSize, 0, 0, 0, 0, 0, 4, 4);
3178         ctx.expectError(GL_INVALID_VALUE);
3179         ctx.endSection();
3180
3181         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
3182         ctx.glCopyTexSubImage3D(GL_TEXTURE_2D_ARRAY, log2MaxTextureSize, 0, 0, 0, 0, 0, 4, 4);
3183         ctx.expectError(GL_INVALID_VALUE);
3184         ctx.endSection();
3185
3186         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3187         {
3188                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, textures[2]);
3189                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, 4, 4, 6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3190                 ctx.expectError(GL_NO_ERROR);
3191                 ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_TEXTURE_SIZE).");
3192                 ctx.glCopyTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, log2MaxCubeMapTextureSize, 0, 0, 0, 0, 0, 4, 4);
3193                 ctx.expectError(GL_INVALID_VALUE);
3194                 ctx.endSection();
3195         }
3196
3197         ctx.glDeleteTextures(3, &textures[0]);
3198 }
3199
3200 void copytexsubimage3d_neg_offset (NegativeTestContext& ctx)
3201 {
3202         GLuint texture = 0x1234;
3203         ctx.glGenTextures       (1, &texture);
3204         ctx.glBindTexture       (GL_TEXTURE_3D, texture);
3205         ctx.glTexImage3D        (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3206
3207         ctx.beginSection("GL_INVALID_VALUE is generated if xoffset, yoffset or zoffset is negative.");
3208         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, -1, 0,  0, 0, 0, 4, 4);
3209         ctx.expectError(GL_INVALID_VALUE);
3210         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, -1, 0, 0, 0, 4, 4);
3211         ctx.expectError(GL_INVALID_VALUE);
3212         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, -1, 0, 0, 4, 4);
3213         ctx.expectError(GL_INVALID_VALUE);
3214         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, -1, -1, -1, 0, 0, 4, 4);
3215         ctx.expectError(GL_INVALID_VALUE);
3216         ctx.endSection();
3217
3218         ctx.glDeleteTextures(1, &texture);
3219 }
3220
3221 void copytexsubimage3d_invalid_offset (NegativeTestContext& ctx)
3222 {
3223         GLuint texture = 0x1234;
3224         ctx.glGenTextures       (1, &texture);
3225         ctx.glBindTexture       (GL_TEXTURE_3D, texture);
3226         ctx.glTexImage3D        (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3227
3228         ctx.beginSection("GL_INVALID_VALUE is generated if xoffset + width > texture_width.");
3229         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 1, 0, 0, 0, 0, 4, 4);
3230         ctx.expectError(GL_INVALID_VALUE);
3231         ctx.endSection();
3232
3233         ctx.beginSection("GL_INVALID_VALUE is generated if yoffset + height > texture_height.");
3234         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 1, 0, 0, 0, 4, 4);
3235         ctx.expectError(GL_INVALID_VALUE);
3236         ctx.endSection();
3237
3238         ctx.beginSection("GL_INVALID_VALUE is generated if zoffset + 1 > texture_depth.");
3239         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 4, 0, 0, 4, 4);
3240         ctx.expectError(GL_INVALID_VALUE);
3241         ctx.endSection();
3242
3243         ctx.glDeleteTextures(1, &texture);
3244 }
3245
3246 void copytexsubimage3d_neg_width_height (NegativeTestContext& ctx)
3247 {
3248         GLuint texture = 0x1234;
3249         ctx.glGenTextures       (1, &texture);
3250         ctx.glBindTexture       (GL_TEXTURE_3D, texture);
3251         ctx.glTexImage3D        (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3252
3253         ctx.beginSection("GL_INVALID_VALUE is generated if width < 0.");
3254         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, -4, 4);
3255         ctx.expectError(GL_INVALID_VALUE);
3256         ctx.endSection();
3257
3258         ctx.beginSection("GL_INVALID_VALUE is generated if height < 0.");
3259         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, 4, -4);
3260         ctx.expectError(GL_INVALID_VALUE);
3261         ctx.endSection();
3262
3263         ctx.glDeleteTextures(1, &texture);
3264 }
3265
3266 void copytexsubimage3d_incomplete_framebuffer (NegativeTestContext& ctx)
3267 {
3268         GLuint fbo = 0x1234;
3269         GLuint texture[2];
3270
3271         ctx.glGenTextures                       (2, texture);
3272         ctx.glBindTexture                       (GL_TEXTURE_3D, texture[0]);
3273         ctx.glTexImage3D                        (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3274         ctx.glBindTexture                       (GL_TEXTURE_2D_ARRAY, texture[1]);
3275         ctx.glTexImage3D                        (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3276         ctx.glGenFramebuffers           (1, &fbo);
3277         ctx.glBindFramebuffer           (GL_READ_FRAMEBUFFER, fbo);
3278         ctx.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER);
3279
3280         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
3281         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, 4, 4);
3282         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
3283         ctx.glCopyTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 0, 0, 4, 4);
3284         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
3285         ctx.endSection();
3286
3287         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
3288         ctx.glDeleteFramebuffers(1, &fbo);
3289         ctx.glDeleteTextures(2, texture);
3290 }
3291
3292 // glCompressedTexImage3D
3293
3294 void compressedteximage3d (NegativeTestContext& ctx)
3295 {
3296         ctx.beginSection("GL_INVALID_ENUM is generated if target is invalid.");
3297         ctx.glCompressedTexImage3D(0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0, 0);
3298         ctx.expectError(GL_INVALID_ENUM);
3299         ctx.glCompressedTexImage3D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0, 0);
3300         ctx.expectError(GL_INVALID_ENUM);
3301         ctx.endSection();
3302
3303         ctx.beginSection("GL_INVALID_ENUM is generated if internalformat is not one of the specific compressed internal formats.");
3304         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 0, 0, 0, 0);
3305         ctx.expectError(GL_INVALID_ENUM);
3306         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA8, 0, 0, 0, 0, 0, 0);
3307         ctx.expectError(GL_INVALID_ENUM);
3308         ctx.endSection();
3309 }
3310
3311 void compressedteximage3d_neg_level (NegativeTestContext& ctx)
3312 {
3313         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
3314         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, -1, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0, 0);
3315         ctx.expectError(GL_INVALID_VALUE);
3316         ctx.endSection();
3317 }
3318
3319 void compressedteximage3d_max_level (NegativeTestContext& ctx)
3320 {
3321         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
3322         deUint32 log2MaxTextureSize = deLog2Floor32(ctx.getInteger(GL_MAX_TEXTURE_SIZE)) + 1;
3323         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, log2MaxTextureSize, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0, 0);
3324         ctx.expectError(GL_INVALID_VALUE);
3325         ctx.endSection();
3326 }
3327
3328 void compressedteximage3d_neg_width_height_depth (NegativeTestContext& ctx)
3329 {
3330         ctx.beginSection("GL_INVALID_VALUE is generated if width, height or depth is less than 0.");
3331         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0, 0, 0, 0, 0);
3332         ctx.expectError(GL_INVALID_VALUE);
3333         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, -1, 0, 0, 0, 0);
3334         ctx.expectError(GL_INVALID_VALUE);
3335         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, -1, 0, 0, 0);
3336         ctx.expectError(GL_INVALID_VALUE);
3337         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, -1, -1, 0, 0, 0);
3338         ctx.expectError(GL_INVALID_VALUE);
3339         ctx.endSection();
3340 }
3341
3342 void compressedteximage3d_max_width_height_depth (NegativeTestContext& ctx)
3343 {
3344         int maxTextureSize = ctx.getInteger(GL_MAX_TEXTURE_SIZE) + 1;
3345
3346         ctx.beginSection("GL_INVALID_VALUE is generated if width, height or depth is greater than GL_MAX_TEXTURE_SIZE.");
3347         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxTextureSize, 0, 0, 0, 0, 0);
3348         ctx.expectError(GL_INVALID_VALUE);
3349         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, maxTextureSize, 0, 0, 0, 0);
3350         ctx.expectError(GL_INVALID_VALUE);
3351         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, maxTextureSize, 0, 0, 0);
3352         ctx.expectError(GL_INVALID_VALUE);
3353         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxTextureSize, maxTextureSize, maxTextureSize, 0, 0, 0);
3354         ctx.expectError(GL_INVALID_VALUE);
3355         ctx.endSection();
3356 }
3357
3358 void compressedteximage3d_invalid_border (NegativeTestContext& ctx)
3359 {
3360         ctx.beginSection("GL_INVALID_VALUE is generated if border is not 0.");
3361         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, -1, 0, 0);
3362         ctx.expectError(GL_INVALID_VALUE);
3363         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 1, 0, 0);
3364         ctx.expectError(GL_INVALID_VALUE);
3365         ctx.endSection();
3366 }
3367
3368 void compressedteximage3d_invalid_size (NegativeTestContext& ctx)
3369 {
3370         ctx.beginSection("GL_INVALID_VALUE is generated if imageSize is not consistent with the format, dimensions, and contents of the specified compressed image data.");
3371         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, -1, 0);
3372         ctx.expectError(GL_INVALID_VALUE);
3373         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, 4*4*8, 0);
3374         ctx.expectError(GL_INVALID_VALUE);
3375         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGB8_ETC2, 16, 16, 1, 0, 4*4*16, 0);
3376         ctx.expectError(GL_INVALID_VALUE);
3377         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_SIGNED_R11_EAC, 16, 16, 1, 0, 4*4*16, 0);
3378         ctx.expectError(GL_INVALID_VALUE);
3379         ctx.endSection();
3380 }
3381
3382 void compressedteximage3d_invalid_width_height (NegativeTestContext& ctx)
3383 {
3384         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3385         {
3386                 const int                               width           = 4;
3387                 const int                               height          = 6;
3388                 const int                               depth           = 6;
3389                 const int                               blockSize       = 16;
3390                 const int                               imageSize       = divRoundUp(width, 4) * divRoundUp(height, 4) * depth * blockSize;
3391                 std::vector<GLubyte>    data            (imageSize);
3392                 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_TEXTURE_CUBE_MAP_ARRAY and width and height are not equal.");
3393                 ctx.glCompressedTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_COMPRESSED_RGB8_ETC2, width, height, depth, 0, imageSize, &data[0]);
3394                 ctx.expectError(GL_INVALID_VALUE);
3395                 ctx.endSection();
3396         }
3397 }
3398
3399 void compressedteximage3d_invalid_buffer_target (NegativeTestContext& ctx)
3400 {
3401         deUint32                                buf = 0x1234;
3402         std::vector<GLubyte>    data(512);
3403
3404         ctx.glGenBuffers                        (1, &buf);
3405         ctx.glBindBuffer                        (GL_PIXEL_UNPACK_BUFFER, buf);
3406         ctx.glBufferData                        (GL_PIXEL_UNPACK_BUFFER, 64, &data[0], GL_DYNAMIC_COPY);
3407         ctx.expectError                         (GL_NO_ERROR);
3408
3409         ctx.beginSection("GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and the buffer object's data store is currently mapped.");
3410         ctx.glMapBufferRange            (GL_PIXEL_UNPACK_BUFFER, 0, 64, GL_MAP_WRITE_BIT);
3411         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGB8_ETC2, 4, 4, 1, 0, etc2DataSize(4, 4), 0);
3412         ctx.expectError                         (GL_INVALID_OPERATION);
3413         ctx.glUnmapBuffer                       (GL_PIXEL_UNPACK_BUFFER);
3414         ctx.endSection();
3415
3416         ctx.beginSection("GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
3417         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGB8_ETC2, 16, 16, 1, 0, etc2DataSize(16, 16), 0);
3418         ctx.expectError                         (GL_INVALID_OPERATION);
3419         ctx.endSection();
3420
3421         ctx.glDeleteBuffers                     (1, &buf);
3422 }
3423
3424 // glCompressedTexSubImage3D
3425
3426 void compressedtexsubimage3d (NegativeTestContext& ctx)
3427 {
3428         ctx.beginSection("GL_INVALID_ENUM is generated if target is invalid.");
3429         ctx.glCompressedTexSubImage3D(0, 0, 0, 0, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3430         ctx.expectError(GL_INVALID_ENUM);
3431         ctx.endSection();
3432
3433         deUint32                                texture = 0x1234;
3434         ctx.glGenTextures                       (1, &texture);
3435         ctx.glBindTexture                       (GL_TEXTURE_2D_ARRAY, texture);
3436         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 1, 0, etc2EacDataSize(18, 18), 0);
3437         ctx.expectError                         (GL_NO_ERROR);
3438
3439         ctx.beginSection("GL_INVALID_OPERATION is generated if format does not match the internal format of the texture image being modified.");
3440         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 0, 0, 0, GL_COMPRESSED_RGB8_ETC2, 0, 0);
3441         ctx.expectError(GL_INVALID_OPERATION);
3442         ctx.endSection();
3443
3444         ctx.beginSection("GL_INVALID_OPERATION is generated if internalformat is an ETC2/EAC format and target is not GL_TEXTURE_2D_ARRAY.");
3445         ctx.glCompressedTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 18, 18, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(18, 18), 0);
3446         ctx.expectError(GL_INVALID_OPERATION);
3447         ctx.endSection();
3448
3449         ctx.beginSection("For ETC2/EAC images GL_INVALID_OPERATION is generated if width is not a multiple of four, and width + xoffset is not equal to the width of the texture level.");
3450         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 4, 0, 0, 10, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(10, 4), 0);
3451         ctx.expectError(GL_INVALID_OPERATION);
3452         ctx.endSection();
3453
3454         ctx.beginSection("For ETC2/EAC images GL_INVALID_OPERATION is generated if height is not a multiple of four, and height + yoffset is not equal to the height of the texture level.");
3455         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 4, 0, 4, 10, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 10), 0);
3456         ctx.expectError(GL_INVALID_OPERATION);
3457         ctx.endSection();
3458
3459         ctx.beginSection("For ETC2/EAC images GL_INVALID_OPERATION is generated if xoffset or yoffset is not a multiple of four.");
3460         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 1, 0, 0, 4, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
3461         ctx.expectError(GL_INVALID_OPERATION);
3462         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 1, 0, 4, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
3463         ctx.expectError(GL_INVALID_OPERATION);
3464         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 1, 1, 0, 4, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
3465         ctx.expectError(GL_INVALID_OPERATION);
3466         ctx.endSection();
3467
3468         ctx.glDeleteTextures            (1, &texture);
3469 }
3470
3471 void compressedtexsubimage3d_neg_level (NegativeTestContext& ctx)
3472 {
3473         deUint32                                texture = 0x1234;
3474         ctx.glGenTextures                       (1, &texture);
3475         ctx.glBindTexture                       (GL_TEXTURE_2D_ARRAY, texture);
3476         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, etc2EacDataSize(16, 16), 0);
3477         ctx.expectError                         (GL_NO_ERROR);
3478
3479         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
3480         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, -1, 0, 0, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3481         ctx.expectError(GL_INVALID_VALUE);
3482         ctx.endSection();
3483
3484         ctx.glDeleteTextures            (1, &texture);
3485 }
3486
3487 void compressedtexsubimage3d_max_level (NegativeTestContext& ctx)
3488 {
3489         deUint32                                texture = 0x1234;
3490         ctx.glGenTextures                       (1, &texture);
3491         ctx.glBindTexture                       (GL_TEXTURE_2D_ARRAY, texture);
3492         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, etc2EacDataSize(16, 16), 0);
3493         ctx.expectError                         (GL_NO_ERROR);
3494
3495         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
3496         deUint32 log2MaxTextureSize = deLog2Floor32(ctx.getInteger(GL_MAX_TEXTURE_SIZE)) + 1;
3497         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, log2MaxTextureSize, 0, 0, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3498         ctx.expectError(GL_INVALID_VALUE);
3499         ctx.endSection();
3500
3501         ctx.glDeleteTextures            (1, &texture);
3502 }
3503
3504 void compressedtexsubimage3d_neg_offset (NegativeTestContext& ctx)
3505 {
3506         deUint32                                texture = 0x1234;
3507         ctx.glGenTextures                       (1, &texture);
3508         ctx.glBindTexture                       (GL_TEXTURE_2D_ARRAY, texture);
3509         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, etc2EacDataSize(16, 16), 0);
3510         ctx.expectError                         (GL_NO_ERROR);
3511
3512         ctx.beginSection("GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if xoffset, yoffset or zoffset are negative.");
3513         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, -4, 0, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3514         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3515         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, -4, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3516         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3517         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, -4, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3518         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3519         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, -4, -4, -4, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3520         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3521         ctx.endSection();
3522
3523         ctx.glDeleteTextures            (1, &texture);
3524 }
3525
3526 void compressedtexsubimage3d_invalid_offset (NegativeTestContext& ctx)
3527 {
3528         deUint32                                texture = 0x1234;
3529         ctx.glGenTextures                       (1, &texture);
3530         ctx.glBindTexture                       (GL_TEXTURE_2D_ARRAY, texture);
3531         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 4, 4, 1, 0, etc2EacDataSize(4, 4), 0);
3532         ctx.expectError                         (GL_NO_ERROR);
3533
3534         ctx.beginSection("GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if xoffset + width > texture_width or yoffset + height > texture_height.");
3535
3536         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 12, 0, 0, 8, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(8, 4), 0);
3537         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3538         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 12, 0, 4, 8, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 8), 0);
3539         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3540         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 12, 4, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
3541         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3542         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 12, 12, 12, 8, 8, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(8, 8), 0);
3543         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3544         ctx.endSection();
3545
3546         ctx.glDeleteTextures            (1, &texture);
3547 }
3548
3549 void compressedtexsubimage3d_neg_width_height_depth (NegativeTestContext& ctx)
3550 {
3551         deUint32                                texture = 0x1234;
3552         ctx.glGenTextures                       (1, &texture);
3553         ctx.glBindTexture                       (GL_TEXTURE_2D_ARRAY, texture);
3554         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, etc2EacDataSize(16, 16), 0);
3555         ctx.expectError                         (GL_NO_ERROR);
3556
3557         ctx.beginSection("GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if width, height or depth are negative.");
3558         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, -4, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3559         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3560         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 0, -4, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3561         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3562         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 0, 0, -4, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3563         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3564         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, -4, -4, -4, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3565         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3566         ctx.endSection();
3567
3568         ctx.glDeleteTextures            (1, &texture);
3569 }
3570
3571 void compressedtexsubimage3d_invalid_size (NegativeTestContext& ctx)
3572 {
3573         deUint32                                texture = 0x1234;
3574         ctx.glGenTextures                       (1, &texture);
3575         ctx.glBindTexture                       (GL_TEXTURE_2D_ARRAY, texture);
3576         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, 4*4*16, 0);
3577         ctx.expectError                         (GL_NO_ERROR);
3578
3579         ctx.beginSection("GL_INVALID_VALUE is generated if imageSize is not consistent with the format, dimensions, and contents of the specified compressed image data.");
3580         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 16, 16, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0);
3581         ctx.expectError(GL_INVALID_VALUE);
3582
3583         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 16, 16, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, 4*4*16-1, 0);
3584         ctx.expectError(GL_INVALID_VALUE);
3585         ctx.endSection();
3586
3587         ctx.glDeleteTextures            (1, &texture);
3588 }
3589
3590 void compressedtexsubimage3d_invalid_buffer_target (NegativeTestContext& ctx)
3591 {
3592         deUint32                                                buf = 0x1234;
3593         deUint32                                                texture = 0x1234;
3594         GLsizei                                                 bufferSize =  etc2EacDataSize(4, 4);
3595         std::vector<GLubyte>                    data(bufferSize);
3596
3597         ctx.glGenTextures                               (1, &texture);
3598         ctx.glBindTexture                               (GL_TEXTURE_2D_ARRAY, texture);
3599         ctx.glCompressedTexImage3D              (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, etc2EacDataSize(16, 16), 0);
3600         ctx.glGenBuffers                                (1, &buf);
3601         ctx.glBindBuffer                                (GL_PIXEL_UNPACK_BUFFER, buf);
3602         ctx.glBufferData                                (GL_PIXEL_UNPACK_BUFFER, bufferSize, &data[0], GL_DYNAMIC_COPY);
3603         ctx.expectError                                 (GL_NO_ERROR);
3604
3605         ctx.beginSection("GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and...");
3606         ctx.beginSection("...the buffer object's data store is currently mapped.");
3607         ctx.glMapBufferRange                    (GL_PIXEL_UNPACK_BUFFER, 0, bufferSize, GL_MAP_WRITE_BIT);
3608         ctx.glCompressedTexSubImage3D   (GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 4, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
3609         ctx.expectError                                 (GL_INVALID_OPERATION);
3610         ctx.glUnmapBuffer                               (GL_PIXEL_UNPACK_BUFFER);
3611         ctx.endSection();
3612
3613         ctx.beginSection("...the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
3614         ctx.glCompressedTexSubImage3D   (GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 16, 16, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(16, 16), 0);
3615         ctx.expectError                                 (GL_INVALID_OPERATION);
3616         ctx.endSection();
3617         ctx.endSection();
3618
3619         ctx.glDeleteBuffers                     (1, &buf);
3620         ctx.glDeleteTextures            (1, &texture);
3621 }
3622
3623 // glTexStorage2D
3624
3625 void texstorage2d (NegativeTestContext& ctx)
3626 {
3627         deUint32  textures[] = {0x1234, 0x1234};
3628
3629         ctx.glGenTextures(2, textures);
3630         ctx.glBindTexture(GL_TEXTURE_2D, textures[0]);
3631         ctx.expectError(GL_NO_ERROR);
3632
3633         ctx.beginSection("GL_INVALID_ENUM or GL_INVALID_VALUE is generated if internalformat is not a valid sized internal format.");
3634         ctx.glTexStorage2D(GL_TEXTURE_2D, 1, 0, 16, 16);
3635         ctx.expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
3636         ctx.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA_INTEGER, 16, 16);
3637         ctx.expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
3638         ctx.endSection();
3639
3640         ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the accepted target enumerants.");
3641         ctx.glTexStorage2D(0, 1, GL_RGBA8, 16, 16);
3642         ctx.expectError(GL_INVALID_ENUM);
3643         ctx.glTexStorage2D(GL_TEXTURE_3D, 1, GL_RGBA8, 16, 16);
3644         ctx.expectError(GL_INVALID_ENUM);
3645         ctx.glTexStorage2D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 16, 16);
3646         ctx.expectError(GL_INVALID_ENUM);
3647         ctx.endSection();
3648
3649         ctx.beginSection("GL_INVALID_VALUE is generated if width or height are less than 1.");
3650         ctx.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 0, 16);
3651         ctx.expectError(GL_INVALID_VALUE);
3652         ctx.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 16, 0);
3653         ctx.expectError(GL_INVALID_VALUE);
3654         ctx.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 0, 0);
3655         ctx.expectError(GL_INVALID_VALUE);
3656
3657         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
3658         {
3659                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP, textures[1]);
3660                 ctx.expectError(GL_NO_ERROR);
3661                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, 1, GL_RGBA8, 0, 16);
3662                 ctx.expectError(GL_INVALID_VALUE);
3663                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, 1, GL_RGBA8, 16, 0);
3664                 ctx.expectError(GL_INVALID_VALUE);
3665                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, 1, GL_RGBA8, 0, 0);
3666                 ctx.expectError(GL_INVALID_VALUE);
3667         }
3668         ctx.endSection();
3669
3670         ctx.glDeleteTextures(2, textures);
3671 }
3672
3673 void texstorage2d_invalid_binding (NegativeTestContext& ctx)
3674 {
3675         deUint32        textures[]              = {0x1234, 0x1234};
3676         deInt32         immutable               = 0x1234;
3677         const bool      supportsES32    = contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
3678
3679         ctx.beginSection("GL_INVALID_OPERATION is generated if the default texture object is curently bound to target.");
3680         ctx.glBindTexture(GL_TEXTURE_2D, 0);
3681         ctx.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 16, 16);
3682         ctx.expectError(GL_INVALID_OPERATION);
3683
3684         if (supportsES32)
3685         {
3686                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
3687                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, 1, GL_RGBA8, 16, 16);
3688                 ctx.expectError(GL_INVALID_OPERATION);
3689         }
3690         ctx.endSection();
3691
3692         ctx.glGenTextures(2, textures);
3693
3694         ctx.beginSection("GL_INVALID_OPERATION is generated if the texture object currently bound to target already has GL_TEXTURE_IMMUTABLE_FORMAT set to GL_TRUE.");
3695         ctx.glBindTexture(GL_TEXTURE_2D, textures[0]);
3696         ctx.glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3697         ctx.getLog() << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3698         ctx.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 16, 16);
3699         ctx.expectError(GL_NO_ERROR);
3700         ctx.glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3701         ctx.getLog() << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3702         ctx.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 16, 16);
3703         ctx.expectError(GL_INVALID_OPERATION);
3704
3705         if (supportsES32)
3706         {
3707                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP, textures[1]);
3708                 ctx.glGetTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3709                 ctx.getLog() << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3710                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, 1, GL_RGBA8, 16, 16);
3711                 ctx.expectError(GL_NO_ERROR);
3712                 ctx.glGetTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3713                 ctx.getLog() << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3714                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, 1, GL_RGBA8, 16, 16);
3715                 ctx.expectError(GL_INVALID_OPERATION);
3716         }
3717         ctx.endSection();
3718
3719         ctx.glDeleteTextures(2, textures);
3720 }
3721
3722 void texstorage2d_invalid_levels (NegativeTestContext& ctx)
3723 {
3724         deUint32        textures[]              = {0x1234, 0x1234};
3725         deUint32        log2MaxSize             = deLog2Floor32(deMax32(16, 16)) + 1 + 1;
3726         const bool      supportsES32    = contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
3727
3728         ctx.glGenTextures(2, textures);
3729         ctx.glBindTexture(GL_TEXTURE_2D, textures[0]);
3730
3731         if (supportsES32)
3732                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP, textures[1]);
3733
3734         ctx.expectError(GL_NO_ERROR);
3735
3736         ctx.beginSection("GL_INVALID_VALUE is generated if levels is less than 1.");
3737         ctx.glTexStorage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 16, 16);
3738         ctx.expectError(GL_INVALID_VALUE);
3739         ctx.glTexStorage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 0, 0);
3740         ctx.expectError(GL_INVALID_VALUE);
3741
3742         if (supportsES32)
3743         {
3744                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, 0, GL_RGBA8, 16, 16);
3745                 ctx.expectError(GL_INVALID_VALUE);
3746                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, 0, GL_RGBA8, 0, 0);
3747                 ctx.expectError(GL_INVALID_VALUE);
3748         }
3749         ctx.endSection();
3750
3751         ctx.beginSection("GL_INVALID_OPERATION is generated if levels is greater than floor(log_2(max(width, height))) + 1");
3752         ctx.glTexStorage2D(GL_TEXTURE_2D, log2MaxSize, GL_RGBA8, 16, 16);
3753         ctx.expectError(GL_INVALID_OPERATION);
3754
3755         if (supportsES32)
3756         {
3757                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, log2MaxSize, GL_RGBA8, 16, 16);
3758                 ctx.expectError(GL_INVALID_OPERATION);
3759         }
3760         ctx.endSection();
3761
3762         ctx.glDeleteTextures(2, textures);
3763 }
3764
3765 // glTexStorage3D
3766
3767 void texstorage3d (NegativeTestContext& ctx)
3768 {
3769         deUint32 textures[] = {0x1234, 0x1234};
3770
3771         ctx.glGenTextures(2, textures);
3772         ctx.glBindTexture(GL_TEXTURE_3D, textures[0]);
3773         ctx.expectError(GL_NO_ERROR);
3774
3775         ctx.beginSection("GL_INVALID_ENUM or GL_INVALID_VALUE is generated if internalformat is not a valid sized internal format.");
3776         ctx.glTexStorage3D(GL_TEXTURE_3D, 1, 0, 4, 4, 4);
3777         ctx.expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
3778         ctx.glTexStorage3D(GL_TEXTURE_3D, 1, GL_RGBA_INTEGER, 4, 4, 4);
3779         ctx.expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
3780         ctx.endSection();
3781
3782         ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the accepted target enumerants.");
3783         ctx.glTexStorage3D(0, 1, GL_RGBA8, 4, 4, 4);
3784         ctx.expectError(GL_INVALID_ENUM);
3785         ctx.glTexStorage3D(GL_TEXTURE_CUBE_MAP, 1, GL_RGBA8, 4, 4, 4);
3786         ctx.expectError(GL_INVALID_ENUM);
3787         ctx.glTexStorage3D(GL_TEXTURE_2D, 1, GL_RGBA8, 4, 4, 4);
3788         ctx.expectError(GL_INVALID_ENUM);
3789         ctx.endSection();
3790
3791         ctx.beginSection("GL_INVALID_VALUE is generated if width, height or depth are less than 1.");
3792         ctx.glTexStorage3D(GL_TEXTURE_3D, 1, GL_RGBA8, 0, 4, 4);
3793         ctx.expectError(GL_INVALID_VALUE);
3794         ctx.glTexStorage3D(GL_TEXTURE_3D, 1, GL_RGBA8, 4, 0, 4);
3795         ctx.expectError(GL_INVALID_VALUE);
3796         ctx.glTexStorage3D(GL_TEXTURE_3D, 1, GL_RGBA8, 4, 4, 0);
3797         ctx.expectError(GL_INVALID_VALUE);
3798         ctx.glTexStorage3D(GL_TEXTURE_3D, 1, GL_RGBA8, 0, 0, 0);
3799         ctx.expectError(GL_INVALID_VALUE);
3800
3801         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3802         {
3803                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, textures[1]);
3804                 ctx.expectError(GL_NO_ERROR);
3805                 ctx.glTexStorage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA8, 0, 4, 4);
3806                 ctx.expectError(GL_INVALID_VALUE);
3807                 ctx.glTexStorage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA8, 4, 0, 4);
3808                 ctx.expectError(GL_INVALID_VALUE);
3809                 ctx.glTexStorage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA8, 4, 4, 0);
3810                 ctx.expectError(GL_INVALID_VALUE);
3811                 ctx.glTexStorage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA8, 0, 0, 0);
3812                 ctx.expectError(GL_INVALID_VALUE);
3813         }
3814         ctx.endSection();
3815
3816         ctx.glDeleteTextures(2, textures);
3817 }
3818
3819 void texstorage3d_invalid_binding (NegativeTestContext& ctx)
3820 {
3821         deUint32        textures[]      = {0x1234, 0x1234};
3822         deInt32         immutable       = 0x1234;
3823
3824         ctx.beginSection("GL_INVALID_OPERATION is generated if the default texture object is curently bound to target.");
3825         ctx.glBindTexture       (GL_TEXTURE_3D, 0);
3826         ctx.glTexStorage3D      (GL_TEXTURE_3D, 1, GL_RGBA8, 4, 4, 4);
3827         ctx.expectError         (GL_INVALID_OPERATION);
3828
3829         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3830         {
3831                 ctx.glBindTexture       (GL_TEXTURE_CUBE_MAP_ARRAY, 0);
3832                 ctx.glTexStorage3D      (GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA8, 4, 4, 6);
3833                 ctx.expectError         (GL_INVALID_OPERATION);
3834         }
3835         ctx.endSection();
3836
3837         ctx.glGenTextures       (2, textures);
3838
3839         ctx.beginSection("GL_INVALID_OPERATION is generated if the texture object currently bound to target already has GL_TEXTURE_IMMUTABLE_FORMAT set to GL_TRUE.");
3840         ctx.glBindTexture       (GL_TEXTURE_3D, textures[0]);
3841         ctx.glGetTexParameteriv(GL_TEXTURE_3D, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3842         ctx.getLog() << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3843         ctx.glTexStorage3D      (GL_TEXTURE_3D, 1, GL_RGBA8, 4, 4, 4);
3844         ctx.expectError         (GL_NO_ERROR);
3845         ctx.glGetTexParameteriv(GL_TEXTURE_3D, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3846         ctx.getLog() << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3847         ctx.glTexStorage3D      (GL_TEXTURE_3D, 1, GL_RGBA8, 4, 4, 4);
3848         ctx.expectError         (GL_INVALID_OPERATION);
3849
3850         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3851         {
3852                 ctx.glBindTexture       (GL_TEXTURE_CUBE_MAP_ARRAY, textures[1]);
3853                 ctx.glGetTexParameteriv(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3854                 ctx.getLog() << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3855                 ctx.glTexStorage3D      (GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA8, 4, 4, 6);
3856                 ctx.expectError         (GL_NO_ERROR);
3857                 ctx.glGetTexParameteriv(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3858                 ctx.getLog() << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3859                 ctx.glTexStorage3D      (GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA8, 4, 4, 6);
3860                 ctx.expectError         (GL_INVALID_OPERATION);
3861         }
3862         ctx.endSection();
3863
3864         ctx.glDeleteTextures(2, textures);
3865 }
3866
3867 void texstorage3d_invalid_levels (NegativeTestContext& ctx)
3868 {
3869         deUint32        textures[]              = {0x1234, 0x1234};
3870         deUint32        log2MaxSize             = deLog2Floor32(8) + 1 + 1;
3871         const bool      supportsES32    = contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
3872         ctx.glGenTextures(2, textures);
3873         ctx.glBindTexture(GL_TEXTURE_3D, textures[0]);
3874
3875         ctx.beginSection("GL_INVALID_VALUE is generated if levels is less than 1.");
3876         ctx.glTexStorage3D(GL_TEXTURE_3D, 0, GL_RGBA8, 4, 4, 4);
3877         ctx.expectError(GL_INVALID_VALUE);
3878         ctx.glTexStorage3D(GL_TEXTURE_3D, 0, GL_RGBA8, 0, 0, 0);
3879         ctx.expectError(GL_INVALID_VALUE);
3880
3881         if (supportsES32 || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3882         {
3883                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, textures[1]);
3884                 ctx.glTexStorage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA8, 4, 4, 6);
3885                 ctx.expectError(GL_INVALID_VALUE);
3886                 ctx.glTexStorage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA8, 0, 0, 6);
3887                 ctx.expectError(GL_INVALID_VALUE);
3888         }
3889         ctx.endSection();
3890
3891         ctx.beginSection("GL_INVALID_OPERATION is generated if levels is greater than floor(log_2(max(width, height, depth))) + 1");
3892         ctx.glTexStorage3D      (GL_TEXTURE_3D, log2MaxSize, GL_RGBA8, 8, 2, 2);
3893         ctx.expectError         (GL_INVALID_OPERATION);
3894         ctx.glTexStorage3D      (GL_TEXTURE_3D, log2MaxSize, GL_RGBA8, 2, 8, 2);
3895         ctx.expectError         (GL_INVALID_OPERATION);
3896         ctx.glTexStorage3D      (GL_TEXTURE_3D, log2MaxSize, GL_RGBA8, 2, 2, 8);
3897         ctx.expectError         (GL_INVALID_OPERATION);
3898         ctx.glTexStorage3D      (GL_TEXTURE_3D, log2MaxSize, GL_RGBA8, 8, 8, 8);
3899         ctx.expectError         (GL_INVALID_OPERATION);
3900
3901         if (supportsES32 || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3902         {
3903                 ctx.glTexStorage3D      (GL_TEXTURE_CUBE_MAP_ARRAY, log2MaxSize, GL_RGBA8, 2, 2, 6);
3904                 ctx.expectError         (GL_INVALID_OPERATION);
3905                 ctx.glTexStorage3D      (GL_TEXTURE_CUBE_MAP_ARRAY, log2MaxSize, GL_RGBA8, 8, 8, 6);
3906                 ctx.expectError         (GL_INVALID_OPERATION);
3907         }
3908         ctx.endSection();
3909
3910         ctx.glDeleteTextures(2, textures);
3911 }
3912
3913 void srgb_decode_texparameteri (NegativeTestContext& ctx)
3914 {
3915         if (!ctx.isExtensionSupported("GL_EXT_texture_sRGB_decode"))
3916                 TCU_THROW(NotSupportedError, "GL_EXT_texture_sRGB_decode is not supported.");
3917
3918         GLuint  texture         = 0x1234;
3919         GLint   textureMode     = -1;
3920
3921         ctx.glGenTextures(1, &texture);
3922         ctx.glBindTexture(GL_TEXTURE_2D, texture);
3923
3924         ctx.beginSection("GL_INVALID_ENUM is generated if pname is GL_TEXTURE_SRGB_DECODE_EXT and the value of param(s) is not a valid value (one of DECODE_EXT, or SKIP_DECODE_EXT).");
3925         ctx.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SRGB_DECODE_EXT, textureMode);
3926         ctx.expectError(GL_INVALID_ENUM);
3927         ctx.endSection();
3928
3929         ctx.glDeleteTextures(1, &texture);
3930 }
3931
3932 void srgb_decode_texparameterf (NegativeTestContext& ctx)
3933 {
3934         if (!ctx.isExtensionSupported("GL_EXT_texture_sRGB_decode"))
3935                 TCU_THROW(NotSupportedError, "GL_EXT_texture_sRGB_decode is not supported.");
3936
3937         GLuint  texture         = 0x1234;
3938         GLfloat textureMode     = -1.0f;
3939
3940         ctx.glGenTextures(1, &texture);
3941         ctx.glBindTexture(GL_TEXTURE_2D, texture);
3942
3943         ctx.beginSection("GL_INVALID_ENUM is generated if pname is GL_TEXTURE_SRGB_DECODE_EXT and the value of param(s) is not a valid value (one of DECODE_EXT, or SKIP_DECODE_EXT).");
3944         ctx.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_SRGB_DECODE_EXT, textureMode);
3945         ctx.expectError(GL_INVALID_ENUM);
3946         ctx.endSection();
3947
3948         ctx.glDeleteTextures(1, &texture);
3949 }
3950
3951 void srgb_decode_texparameteriv (NegativeTestContext& ctx)
3952 {
3953         if (!ctx.isExtensionSupported("GL_EXT_texture_sRGB_decode"))
3954                 TCU_THROW(NotSupportedError, "GL_EXT_texture_sRGB_decode is not supported.");
3955
3956         GLint   params[1]       = {GL_LINEAR};
3957         GLuint  texture         = 0x1234;
3958
3959         ctx.glGenTextures(1, &texture);
3960         ctx.glBindTexture(GL_TEXTURE_2D, texture);
3961
3962         params[0] = -1;
3963         ctx.beginSection("GL_INVALID_ENUM is generated if pname is GL_TEXTURE_SRGB_DECODE_EXT and the value of param(s) is not a valid value (one of DECODE_EXT, or SKIP_DECODE_EXT).");
3964         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SRGB_DECODE_EXT, &params[0]);
3965         ctx.expectError(GL_INVALID_ENUM);
3966         ctx.endSection();
3967
3968         ctx.glDeleteTextures(1, &texture);
3969 }
3970
3971 void srgb_decode_texparameterfv (NegativeTestContext& ctx)
3972 {
3973         if (!ctx.isExtensionSupported("GL_EXT_texture_sRGB_decode"))
3974                 TCU_THROW(NotSupportedError, "GL_EXT_texture_sRGB_decode is not supported.");
3975
3976         GLfloat params[1]       = {GL_LINEAR};
3977         GLuint  texture         = 0x1234;
3978
3979         ctx.glGenTextures(1, &texture);
3980         ctx.glBindTexture(GL_TEXTURE_2D, texture);
3981
3982         params[0] = -1.0f;
3983         ctx.beginSection("GL_INVALID_ENUM is generated if pname is GL_TEXTURE_SRGB_DECODE_EXT and the value of param(s) is not a valid value (one of DECODE_EXT, or SKIP_DECODE_EXT).");
3984         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_SRGB_DECODE_EXT, &params[0]);
3985         ctx.expectError(GL_INVALID_ENUM);
3986         ctx.endSection();
3987
3988         ctx.glDeleteTextures(1, &texture);
3989 }
3990
3991 void srgb_decode_texparameterIiv (NegativeTestContext& ctx)
3992 {
3993         if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
3994                 TCU_THROW(NotSupportedError,"glTexParameterIiv is not supported.");
3995
3996         if (!ctx.isExtensionSupported("GL_EXT_texture_sRGB_decode"))
3997                 TCU_THROW(NotSupportedError, "GL_EXT_texture_sRGB_decode is not supported.");
3998
3999         GLint   textureMode[]   = {GL_DEPTH_COMPONENT, GL_STENCIL_INDEX};
4000         GLuint  texture                 = 0x1234;
4001
4002         ctx.glGenTextures(1, &texture);
4003         ctx.glBindTexture(GL_TEXTURE_2D, texture);
4004
4005         textureMode[0] = -1;
4006         textureMode[1] = -1;
4007         ctx.beginSection("GL_INVALID_ENUM is generated if pname is GL_TEXTURE_SRGB_DECODE_EXT and the value of param(s) is not a valid value (one of DECODE_EXT, or SKIP_DECODE_EXT).");
4008         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_SRGB_DECODE_EXT, textureMode);
4009         ctx.expectError(GL_INVALID_ENUM);
4010         ctx.endSection();
4011
4012         ctx.glDeleteTextures(1, &texture);
4013 }
4014
4015 void srgb_decode_texparameterIuiv (NegativeTestContext& ctx)
4016 {
4017         if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
4018                 TCU_THROW(NotSupportedError,"glTexParameterIuiv is not supported.");
4019
4020         if (!ctx.isExtensionSupported("GL_EXT_texture_sRGB_decode"))
4021                 TCU_THROW(NotSupportedError, "GL_EXT_texture_sRGB_decode is not supported.");
4022
4023         GLuint  textureMode[]   = {GL_DEPTH_COMPONENT, GL_STENCIL_INDEX};
4024         GLuint  texture                 = 0x1234;
4025
4026         ctx.glGenTextures(1, &texture);
4027         ctx.glBindTexture(GL_TEXTURE_2D, texture);
4028
4029         textureMode[0] = GL_DONT_CARE;
4030         textureMode[1] = GL_DONT_CARE;
4031         ctx.beginSection("GL_INVALID_ENUM is generated if pname is GL_TEXTURE_SRGB_DECODE_EXT and the value of param(s) is not a valid value (one of DECODE_EXT, or SKIP_DECODE_EXT).");
4032         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_SRGB_DECODE_EXT, textureMode);
4033         ctx.expectError(GL_INVALID_ENUM);
4034         ctx.endSection();
4035
4036         ctx.glDeleteTextures(1, &texture);
4037 }
4038
4039 std::vector<FunctionContainer> getNegativeTextureApiTestFunctions()
4040 {
4041         FunctionContainer funcs[] =
4042         {
4043                 {activetexture,                                                                 "activetexture",                                                                        "Invalid glActiveTexture() usage"                  },
4044                 {bindtexture,                                                                   "bindtexture",                                                                          "Invalid glBindTexture() usage"                    },
4045                 {compressedteximage2d_invalid_target,                   "compressedteximage2d_invalid_target",                          "Invalid glCompressedTexImage2D() usage"   },
4046                 {compressedteximage2d_invalid_format,                   "compressedteximage2d_invalid_format",                          "Invalid glCompressedTexImage2D() usage"   },
4047                 {compressedteximage2d_neg_level,                                "compressedteximage2d_neg_level",                                       "Invalid glCompressedTexImage2D() usage"   },
4048                 {compressedteximage2d_max_level,                                "compressedteximage2d_max_level",                                       "Invalid glCompressedTexImage2D() usage"   },
4049                 {compressedteximage2d_neg_width_height,                 "compressedteximage2d_neg_width_height",                        "Invalid glCompressedTexImage2D() usage"   },
4050                 {compressedteximage2d_max_width_height,                 "compressedteximage2d_max_width_height",                        "Invalid glCompressedTexImage2D() usage"   },
4051                 {compressedteximage2d_invalid_border,                   "compressedteximage2d_invalid_border",                          "Invalid glCompressedTexImage2D() usage"   },
4052                 {compressedteximage2d_invalid_size,                             "compressedteximage2d_invalid_size",                            "Invalid glCompressedTexImage2D() usage"   },
4053                 {compressedteximage2d_neg_size,                                 "compressedteximage2d_neg_size",                                        "Invalid glCompressedTexImage2D() usage"   },
4054                 {compressedteximage2d_invalid_width_height,             "compressedteximage2d_invalid_width_height",            "Invalid glCompressedTexImage2D() usage"   },
4055                 {compressedteximage2d_invalid_buffer_target,    "compressedteximage2d_invalid_buffer_target",           "Invalid glCompressedTexImage2D() usage"   },
4056                 {copyteximage2d_invalid_target,                                 "copyteximage2d_invalid_target",                                        "Invalid glCopyTexImage2D() usage"                 },
4057                 {copyteximage2d_invalid_format,                                 "copyteximage2d_invalid_format",                                        "Invalid glCopyTexImage2D() usage"                 },
4058                 {copyteximage2d_inequal_width_height_cube,              "copyteximage2d_inequal_width_height_cube",                     "Invalid glCopyTexImage2D() usage"                 },
4059                 {copyteximage2d_neg_level,                                              "copyteximage2d_neg_level",                                                     "Invalid glCopyTexImage2D() usage"                 },
4060                 {copyteximage2d_max_level,                                              "copyteximage2d_max_level",                                                     "Invalid glCopyTexImage2D() usage"                 },
4061                 {copyteximage2d_neg_width_height,                               "copyteximage2d_neg_width_height",                                      "Invalid glCopyTexImage2D() usage"                 },
4062                 {copyteximage2d_max_width_height,                               "copyteximage2d_max_width_height",                                      "Invalid glCopyTexImage2D() usage"                 },
4063                 {copyteximage2d_invalid_border,                                 "copyteximage2d_invalid_border",                                        "Invalid glCopyTexImage2D() usage"                 },
4064                 {copyteximage2d_incomplete_framebuffer,                 "copyteximage2d_incomplete_framebuffer",                        "Invalid glCopyTexImage2D() usage"                 },
4065                 {copytexsubimage2d_invalid_target,                              "copytexsubimage2d_invalid_target",                                     "Invalid glCopyTexSubImage2D() usage"      },
4066                 {copytexsubimage2d_read_buffer_is_none,                 "copytexsubimage2d_read_buffer_is_none",                        "Invalid glCopyTexSubImage2D() usage"      },
4067                 {copytexsubimage2d_texture_internalformat,              "copytexsubimage2d_texture_internalformat",                     "Invalid glCopyTexSubImage2D() usage"      },
4068                 {copytexsubimage2d_neg_level,                                   "copytexsubimage2d_neg_level",                                          "Invalid glCopyTexSubImage2D() usage"      },
4069                 {copytexsubimage2d_max_level,                                   "copytexsubimage2d_max_level",                                          "Invalid glCopyTexSubImage2D() usage"      },
4070                 {copytexsubimage2d_neg_offset,                                  "copytexsubimage2d_neg_offset",                                         "Invalid glCopyTexSubImage2D() usage"      },
4071                 {copytexsubimage2d_invalid_offset,                              "copytexsubimage2d_invalid_offset",                                     "Invalid glCopyTexSubImage2D() usage"      },
4072                 {copytexsubimage2d_neg_width_height,                    "copytexsubimage2d_neg_width_height",                           "Invalid glCopyTexSubImage2D() usage"      },
4073                 {copytexsubimage2d_incomplete_framebuffer,              "copytexsubimage2d_incomplete_framebuffer",                     "Invalid glCopyTexSubImage2D() usage"      },
4074                 {deletetextures,                                                                "deletetextures",                                                                       "Invalid glDeleteTextures() usage"                 },
4075                 {generatemipmap,                                                                "generatemipmap",                                                                       "Invalid glGenerateMipmap() usage"                 },
4076                 {gentextures,                                                                   "gentextures",                                                                          "Invalid glGenTextures() usage"                    },
4077                 {pixelstorei,                                                                   "pixelstorei",                                                                          "Invalid glPixelStorei() usage"                    },
4078                 {teximage2d,                                                                    "teximage2d",                                                                           "Invalid glTexImage2D() usage"                     },
4079                 {teximage2d_inequal_width_height_cube,                  "teximage2d_inequal_width_height_cube",                         "Invalid glTexImage2D() usage"                     },
4080                 {teximage2d_neg_level,                                                  "teximage2d_neg_level",                                                         "Invalid glTexImage2D() usage"                     },
4081                 {teximage2d_max_level,                                                  "teximage2d_max_level",                                                         "Invalid glTexImage2D() usage"                     },
4082                 {teximage2d_neg_width_height,                                   "teximage2d_neg_width_height",                                          "Invalid glTexImage2D() usage"                     },
4083                 {teximage2d_max_width_height,                                   "teximage2d_max_width_height",                                          "Invalid glTexImage2D() usage"                     },
4084                 {teximage2d_invalid_border,                                             "teximage2d_invalid_border",                                            "Invalid glTexImage2D() usage"                     },
4085                 {teximage2d_invalid_buffer_target,                              "teximage2d_invalid_buffer_target",                                     "Invalid glTexImage2D() usage"                     },
4086                 {texsubimage2d,                                                                 "texsubimage2d",                                                                        "Invalid glTexSubImage2D() usage"                  },
4087                 {texsubimage2d_neg_level,                                               "texsubimage2d_neg_level",                                                      "Invalid glTexSubImage2D() usage"                  },
4088                 {texsubimage2d_max_level,                                               "texsubimage2d_max_level",                                                      "Invalid glTexSubImage2D() usage"                  },
4089                 {texsubimage2d_neg_offset,                                              "texsubimage2d_neg_offset",                                                     "Invalid glTexSubImage2D() usage"                  },
4090                 {texsubimage2d_invalid_offset,                                  "texsubimage2d_invalid_offset",                                         "Invalid glTexSubImage2D() usage"                  },
4091                 {texsubimage2d_neg_width_height,                                "texsubimage2d_neg_width_height",                                       "Invalid glTexSubImage2D() usage"                  },
4092                 {texsubimage2d_invalid_buffer_target,                   "texsubimage2d_invalid_buffer_target",                          "Invalid glTexSubImage2D() usage"                  },
4093                 {texparameteri,                                                                 "texparameteri",                                                                        "Invalid glTexParameteri() usage"                  },
4094                 {texparameterf,                                                                 "texparameterf",                                                                        "Invalid glTexParameterf() usage"                  },
4095                 {texparameteriv,                                                                "texparameteriv",                                                                       "Invalid glTexParameteriv() usage"                 },
4096                 {texparameterfv,                                                                "texparameterfv",                                                                       "Invalid glTexParameterfv() usage"                 },
4097                 {texparameterIiv,                                                               "texparameterIiv",                                                                      "Invalid glTexParameterIiv() usage"                },
4098                 {texparameterIuiv,                                                              "texparameterIuiv",                                                                     "Invalid glTexParameterIuiv() usage"       },
4099                 {compressedtexsubimage2d,                                               "compressedtexsubimage2d",                                                      "Invalid glCompressedTexSubImage2D() usage"},
4100                 {compressedtexsubimage2d_neg_level,                             "compressedtexsubimage2d_neg_level",                            "Invalid glCompressedTexSubImage2D() usage"},
4101                 {compressedtexsubimage2d_max_level,                             "compressedtexsubimage2d_max_level",                            "Invalid glCompressedTexSubImage2D() usage"},
4102                 {compressedtexsubimage2d_neg_offset,                    "compressedtexsubimage2d_neg_offset",                           "Invalid glCompressedTexSubImage2D() usage"},
4103                 {compressedtexsubimage2d_invalid_offset,                "compressedtexsubimage2d_invalid_offset",                       "Invalid glCompressedTexSubImage2D() usage"},
4104                 {compressedtexsubimage2d_neg_width_height,              "compressedtexsubimage2d_neg_width_height",                     "Invalid glCompressedTexSubImage2D() usage"},
4105                 {compressedtexsubimage2d_invalid_size,                  "compressedtexsubimage2d_invalid_size",                         "Invalid glCompressedTexImage2D() usage"   },
4106                 {compressedtexsubimage2d_invalid_buffer_target, "compressedtexsubimage2d_invalid_buffer_target",        "Invalid glCompressedTexSubImage2D() usage"},
4107                 {teximage3d,                                                                    "teximage3d",                                                                           "Invalid glTexImage3D() usage"                     },
4108                 {teximage3d_neg_level,                                                  "teximage3d_neg_level",                                                         "Invalid glTexImage3D() usage"                     },
4109                 {teximage3d_max_level,                                                  "teximage3d_max_level",                                                         "Invalid glTexImage3D() usage"                     },
4110                 {teximage3d_neg_width_height_depth,                             "teximage3d_neg_width_height_depth",                            "Invalid glTexImage3D() usage"                     },
4111                 {teximage3d_max_width_height_depth,                             "teximage3d_max_width_height_depth",                            "Invalid glTexImage3D() usage"                     },
4112                 {teximage3d_invalid_border,                                             "teximage3d_invalid_border",                                            "Invalid glTexImage3D() usage"                     },
4113                 {teximage3d_invalid_buffer_target,                              "teximage3d_invalid_buffer_target",                                     "Invalid glTexImage3D() usage"                     },
4114                 {texsubimage3d,                                                                 "texsubimage3d",                                                                        "Invalid glTexSubImage3D() usage"                  },
4115                 {texsubimage3d_neg_level,                                               "texsubimage3d_neg_level",                                                      "Invalid glTexSubImage3D() usage"                  },
4116                 {texsubimage3d_max_level,                                               "texsubimage3d_max_level",                                                      "Invalid glTexSubImage3D() usage"                  },
4117                 {texsubimage3d_neg_offset,                                              "texsubimage3d_neg_offset",                                                     "Invalid glTexSubImage3D() usage"                  },
4118                 {texsubimage3d_invalid_offset,                                  "texsubimage3d_invalid_offset",                                         "Invalid glTexSubImage3D() usage"                  },
4119                 {texsubimage3d_neg_width_height,                                "texsubimage3d_neg_width_height",                                       "Invalid glTexSubImage3D() usage"                  },
4120                 {texsubimage3d_invalid_buffer_target,                   "texsubimage3d_invalid_buffer_target",                          "Invalid glTexSubImage3D() usage"                  },
4121                 {copytexsubimage3d,                                                             "copytexsubimage3d",                                                            "Invalid glCopyTexSubImage3D() usage"      },
4122                 {copytexsubimage3d_neg_level,                                   "copytexsubimage3d_neg_level",                                          "Invalid glCopyTexSubImage3D() usage"      },
4123                 {copytexsubimage3d_max_level,                                   "copytexsubimage3d_max_level",                                          "Invalid glCopyTexSubImage3D() usage"      },
4124                 {copytexsubimage3d_neg_offset,                                  "copytexsubimage3d_neg_offset",                                         "Invalid glCopyTexSubImage3D() usage"      },
4125                 {copytexsubimage3d_invalid_offset,                              "copytexsubimage3d_invalid_offset",                                     "Invalid glCopyTexSubImage3D() usage"      },
4126                 {copytexsubimage3d_neg_width_height,                    "copytexsubimage3d_neg_width_height",                           "Invalid glCopyTexSubImage3D() usage"      },
4127                 {copytexsubimage3d_incomplete_framebuffer,              "copytexsubimage3d_incomplete_framebuffer",                     "Invalid glCopyTexSubImage3D() usage"      },
4128                 {compressedteximage3d,                                                  "compressedteximage3d",                                                         "Invalid glCompressedTexImage3D() usage"   },
4129                 {compressedteximage3d_neg_level,                                "compressedteximage3d_neg_level",                                       "Invalid glCompressedTexImage3D() usage"   },
4130                 {compressedteximage3d_max_level,                                "compressedteximage3d_max_level",                                       "Invalid glCompressedTexImage3D() usage"   },
4131                 {compressedteximage3d_neg_width_height_depth,   "compressedteximage3d_neg_width_height_depth",          "Invalid glCompressedTexImage3D() usage"   },
4132                 {compressedteximage3d_max_width_height_depth,   "compressedteximage3d_max_width_height_depth",          "Invalid glCompressedTexImage3D() usage"   },
4133                 {compressedteximage3d_invalid_border,                   "compressedteximage3d_invalid_border",                          "Invalid glCompressedTexImage3D() usage"   },
4134                 {compressedteximage3d_invalid_size,                             "compressedteximage3d_invalid_size",                            "Invalid glCompressedTexImage3D() usage"   },
4135                 {compressedteximage3d_invalid_width_height,             "compressedteximage3d_invalid_width_height",            "Invalid glCompressedTexImage3D() usage"   },
4136                 {compressedteximage3d_invalid_buffer_target,    "compressedteximage3d_invalid_buffer_target",           "Invalid glCompressedTexImage3D() usage"   },
4137                 {compressedtexsubimage3d,                                               "compressedtexsubimage3d",                                                      "Invalid glCompressedTexSubImage3D() usage"},
4138                 {compressedtexsubimage3d_neg_level,                             "compressedtexsubimage3d_neg_level",                            "Invalid glCompressedTexSubImage3D() usage"},
4139                 {compressedtexsubimage3d_max_level,                             "compressedtexsubimage3d_max_level",                            "Invalid glCompressedTexSubImage3D() usage"},
4140                 {compressedtexsubimage3d_neg_offset,                    "compressedtexsubimage3d_neg_offset",                           "Invalid glCompressedTexSubImage3D() usage"},
4141                 {compressedtexsubimage3d_invalid_offset,                "compressedtexsubimage3d_invalid_offset",                       "Invalid glCompressedTexSubImage3D() usage"},
4142                 {compressedtexsubimage3d_neg_width_height_depth,"compressedtexsubimage3d_neg_width_height_depth",       "Invalid glCompressedTexSubImage3D() usage"},
4143                 {compressedtexsubimage3d_invalid_size,                  "compressedtexsubimage3d_invalid_size",                         "Invalid glCompressedTexSubImage3D() usage"},
4144                 {compressedtexsubimage3d_invalid_buffer_target, "compressedtexsubimage3d_invalid_buffer_target",        "Invalid glCompressedTexSubImage3D() usage"},
4145                 {texstorage2d,                                                                  "texstorage2d",                                                                         "Invalid glTexStorage2D() usage"                   },
4146                 {texstorage2d_invalid_binding,                                  "texstorage2d_invalid_binding",                                         "Invalid glTexStorage2D() usage"                   },
4147                 {texstorage2d_invalid_levels,                                   "texstorage2d_invalid_levels",                                          "Invalid glTexStorage2D() usage"                   },
4148                 {texstorage3d,                                                                  "texstorage3d",                                                                         "Invalid glTexStorage3D() usage"                   },
4149                 {texstorage3d_invalid_binding,                                  "texstorage3d_invalid_binding",                                         "Invalid glTexStorage3D() usage"                   },
4150                 {texstorage3d_invalid_levels,                                   "texstorage3d_invalid_levels",                                          "Invalid glTexStorage3D() usage"                   },
4151                 {srgb_decode_texparameteri,                                             "srgb_decode_texparameteri",                                            "Invalid texparameteri() usage srgb"       },
4152                 {srgb_decode_texparameterf,                                             "srgb_decode_texparameterf",                                            "Invalid texparameterf() usage srgb"       },
4153                 {srgb_decode_texparameteriv,                                    "srgb_decode_texparameteriv",                                           "Invalid texparameteriv() usage srgb"      },
4154                 {srgb_decode_texparameterfv,                                    "srgb_decode_texparameterfv",                                           "Invalid texparameterfv() usage srgb"      },
4155                 {srgb_decode_texparameterIiv,                                   "srgb_decode_texparameterIiv",                                          "Invalid texparameterIiv() usage srgb"     },
4156                 {srgb_decode_texparameterIuiv,                                  "srgb_decode_texparameterIuiv",                                         "Invalid texparameterIuiv() usage srgb"    },
4157         };
4158
4159         return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
4160 }
4161
4162 } // NegativeTestShared
4163 } // Functional
4164 } // gles31
4165 } // deqp