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         GLuint texture = 0x1234;
1999         ctx.glGenTextures(1, &texture);
2000         ctx.glBindTexture(GL_TEXTURE_2D, texture);
2001
2002         ctx.beginSection("GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
2003         ctx.glTexParameteriv(0, GL_TEXTURE_MIN_FILTER, &params[0]);
2004         ctx.expectError(GL_INVALID_ENUM);
2005         ctx.glTexParameteriv(GL_TEXTURE_2D, 0, &params[0]);
2006         ctx.expectError(GL_INVALID_ENUM);
2007         ctx.glTexParameteriv(0, 0, &params[0]);
2008         ctx.expectError(GL_INVALID_ENUM);
2009         ctx.endSection();
2010
2011         ctx.beginSection("GL_INVALID_ENUM is generated if pname is enum and the value of param(s) is not a valid value.");
2012         params[0] = -1;
2013         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, &params[0]);
2014         ctx.expectError(GL_INVALID_ENUM);
2015         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, &params[0]);
2016         ctx.expectError(GL_INVALID_ENUM);
2017         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, &params[0]);
2018         ctx.expectError(GL_INVALID_ENUM);
2019         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &params[0]);
2020         ctx.expectError(GL_INVALID_ENUM);
2021         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &params[0]);
2022         ctx.expectError(GL_INVALID_ENUM);
2023         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, &params[0]);
2024         ctx.expectError(GL_INVALID_ENUM);
2025         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, &params[0]);
2026         ctx.expectError(GL_INVALID_ENUM);
2027         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, &params[0]);
2028         ctx.expectError(GL_INVALID_ENUM);
2029         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, &params[0]);
2030         ctx.expectError(GL_INVALID_ENUM);
2031         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, &params[0]);
2032         ctx.expectError(GL_INVALID_ENUM);
2033         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, &params[0]);
2034         ctx.expectError(GL_INVALID_ENUM);
2035         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, &params[0]);
2036         ctx.expectError(GL_INVALID_ENUM);
2037         ctx.endSection();
2038
2039         ctx.beginSection("GL_INVALID_VALUE is generated if pname is GL_TEXTURE_BASE_LEVEL or GL_TEXTURE_MAX_LEVEL and param(s) is negative.");
2040         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, &params[0]);
2041         ctx.expectError(GL_INVALID_VALUE);
2042         ctx.glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, &params[0]);
2043         ctx.expectError(GL_INVALID_VALUE);
2044         ctx.endSection();
2045
2046         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.");
2047         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BORDER_COLOR, &params[0]);
2048         ctx.expectError(GL_INVALID_ENUM);
2049         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_FILTER, &params[0]);
2050         ctx.expectError(GL_INVALID_ENUM);
2051         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAG_FILTER, &params[0]);
2052         ctx.expectError(GL_INVALID_ENUM);
2053         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_S, &params[0]);
2054         ctx.expectError(GL_INVALID_ENUM);
2055         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_T, &params[0]);
2056         ctx.expectError(GL_INVALID_ENUM);
2057         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_R, &params[0]);
2058         ctx.expectError(GL_INVALID_ENUM);
2059         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_LOD, &params[0]);
2060         ctx.expectError(GL_INVALID_ENUM);
2061         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAX_LOD, &params[0]);
2062         ctx.expectError(GL_INVALID_ENUM);
2063         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_MODE, &params[0]);
2064         ctx.expectError(GL_INVALID_ENUM);
2065         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_FUNC, &params[0]);
2066         ctx.expectError(GL_INVALID_ENUM);
2067
2068         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
2069         {
2070                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BORDER_COLOR, &params[0]);
2071                 ctx.expectError(GL_INVALID_ENUM);
2072                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_FILTER, &params[0]);
2073                 ctx.expectError(GL_INVALID_ENUM);
2074                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAG_FILTER, &params[0]);
2075                 ctx.expectError(GL_INVALID_ENUM);
2076                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_S, &params[0]);
2077                 ctx.expectError(GL_INVALID_ENUM);
2078                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_T, &params[0]);
2079                 ctx.expectError(GL_INVALID_ENUM);
2080                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_R, &params[0]);
2081                 ctx.expectError(GL_INVALID_ENUM);
2082                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_LOD, &params[0]);
2083                 ctx.expectError(GL_INVALID_ENUM);
2084                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAX_LOD, &params[0]);
2085                 ctx.expectError(GL_INVALID_ENUM);
2086                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_MODE, &params[0]);
2087                 ctx.expectError(GL_INVALID_ENUM);
2088                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_FUNC, &params[0]);
2089                 ctx.expectError(GL_INVALID_ENUM);
2090         }
2091         ctx.endSection();
2092
2093         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.");
2094         params[0] = 1;
2095         ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, &params[0]);
2096         ctx.expectError(GL_INVALID_OPERATION);
2097
2098         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
2099         {
2100                 params[0] = 1;
2101                 ctx.glTexParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BASE_LEVEL, &params[0]);
2102                 ctx.expectError(GL_INVALID_OPERATION);
2103         }
2104         ctx.endSection();
2105
2106         ctx.glDeleteTextures(1, &texture);
2107 }
2108
2109 // glTexParameterfv
2110
2111 void texparameterfv (NegativeTestContext& ctx)
2112 {
2113         GLfloat params[1] = {GL_LINEAR};
2114         GLuint texture = 0x1234;
2115         ctx.glGenTextures(1, &texture);
2116         ctx.glBindTexture(GL_TEXTURE_2D, texture);
2117
2118         ctx.beginSection("GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
2119         params[0] = GL_LINEAR;
2120         ctx.glTexParameterfv(0, GL_TEXTURE_MIN_FILTER, &params[0]);
2121         ctx.expectError(GL_INVALID_ENUM);
2122         ctx.glTexParameterfv(GL_TEXTURE_2D, 0, &params[0]);
2123         ctx.expectError(GL_INVALID_ENUM);
2124         ctx.glTexParameterfv(0, 0, &params[0]);
2125         ctx.expectError(GL_INVALID_ENUM);
2126         ctx.endSection();
2127
2128         ctx.beginSection("GL_INVALID_ENUM is generated if pname is enum and the value of param(s) is not a valid value.");
2129         params[0] = -1.0f;
2130         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, &params[0]);
2131         ctx.expectError(GL_INVALID_ENUM);
2132         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, &params[0]);
2133         ctx.expectError(GL_INVALID_ENUM);
2134         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, &params[0]);
2135         ctx.expectError(GL_INVALID_ENUM);
2136         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &params[0]);
2137         ctx.expectError(GL_INVALID_ENUM);
2138         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &params[0]);
2139         ctx.expectError(GL_INVALID_ENUM);
2140         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, &params[0]);
2141         ctx.expectError(GL_INVALID_ENUM);
2142         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, &params[0]);
2143         ctx.expectError(GL_INVALID_ENUM);
2144         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, &params[0]);
2145         ctx.expectError(GL_INVALID_ENUM);
2146         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, &params[0]);
2147         ctx.expectError(GL_INVALID_ENUM);
2148         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, &params[0]);
2149         ctx.expectError(GL_INVALID_ENUM);
2150         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, &params[0]);
2151         ctx.expectError(GL_INVALID_ENUM);
2152         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, &params[0]);
2153         ctx.expectError(GL_INVALID_ENUM);
2154         ctx.endSection();
2155
2156         ctx.beginSection("GL_INVALID_VALUE is generated if pname is GL_TEXTURE_BASE_LEVEL or GL_TEXTURE_MAX_LEVEL and param(s) is negative.");
2157         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, &params[0]);
2158         ctx.expectError(GL_INVALID_VALUE);
2159         ctx.glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, &params[0]);
2160         ctx.expectError(GL_INVALID_VALUE);
2161         ctx.endSection();
2162
2163         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.");
2164         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BORDER_COLOR, &params[0]);
2165         ctx.expectError(GL_INVALID_ENUM);
2166         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_FILTER, &params[0]);
2167         ctx.expectError(GL_INVALID_ENUM);
2168         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAG_FILTER, &params[0]);
2169         ctx.expectError(GL_INVALID_ENUM);
2170         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_S, &params[0]);
2171         ctx.expectError(GL_INVALID_ENUM);
2172         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_T, &params[0]);
2173         ctx.expectError(GL_INVALID_ENUM);
2174         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_R, &params[0]);
2175         ctx.expectError(GL_INVALID_ENUM);
2176         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_LOD, &params[0]);
2177         ctx.expectError(GL_INVALID_ENUM);
2178         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAX_LOD, &params[0]);
2179         ctx.expectError(GL_INVALID_ENUM);
2180         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_MODE, &params[0]);
2181         ctx.expectError(GL_INVALID_ENUM);
2182         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_FUNC, &params[0]);
2183         ctx.expectError(GL_INVALID_ENUM);
2184
2185         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
2186         {
2187                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BORDER_COLOR, &params[0]);
2188                 ctx.expectError(GL_INVALID_ENUM);
2189                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_FILTER, &params[0]);
2190                 ctx.expectError(GL_INVALID_ENUM);
2191                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAG_FILTER, &params[0]);
2192                 ctx.expectError(GL_INVALID_ENUM);
2193                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_S, &params[0]);
2194                 ctx.expectError(GL_INVALID_ENUM);
2195                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_T, &params[0]);
2196                 ctx.expectError(GL_INVALID_ENUM);
2197                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_R, &params[0]);
2198                 ctx.expectError(GL_INVALID_ENUM);
2199                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_LOD, &params[0]);
2200                 ctx.expectError(GL_INVALID_ENUM);
2201                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAX_LOD, &params[0]);
2202                 ctx.expectError(GL_INVALID_ENUM);
2203                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_MODE, &params[0]);
2204                 ctx.expectError(GL_INVALID_ENUM);
2205                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_FUNC, &params[0]);
2206                 ctx.expectError(GL_INVALID_ENUM);
2207         }
2208         ctx.endSection();
2209
2210         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.");
2211         params[0] = 1.0f;
2212         ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, &params[0]);
2213         ctx.expectError(GL_INVALID_OPERATION);
2214
2215         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
2216         {
2217                 params[0] = 1.0f;
2218                 ctx.glTexParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BASE_LEVEL, &params[0]);
2219                 ctx.expectError(GL_INVALID_OPERATION);
2220         }
2221         ctx.endSection();
2222
2223         ctx.glDeleteTextures(1, &texture);
2224 }
2225
2226 // glTexParameterIiv
2227
2228 void texparameterIiv (NegativeTestContext& ctx)
2229 {
2230         if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
2231                 throw tcu::NotSupportedError("glTexParameterIiv is not supported.", DE_NULL, __FILE__, __LINE__);
2232
2233         GLint textureMode[] = { GL_DEPTH_COMPONENT, GL_STENCIL_INDEX };
2234         ctx.beginSection("GL_INVALID_ENUM is generated if target is not a valid target.");
2235         ctx.glTexParameterIiv(0, GL_DEPTH_STENCIL_TEXTURE_MODE, textureMode);
2236         ctx.expectError(GL_INVALID_ENUM);
2237         ctx.endSection();
2238
2239         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not a valid parameter.");
2240         ctx.glTexParameterIiv(GL_TEXTURE_2D, 0, textureMode);
2241         ctx.expectError(GL_INVALID_ENUM);
2242         ctx.endSection();
2243
2244         ctx.beginSection("GL_INVALID_ENUM is generated if pname is enum and the value of param(s) is not a valid value.");
2245         textureMode[0] = -1;
2246         textureMode[1] = -1;
2247         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, textureMode);
2248         ctx.expectError(GL_INVALID_ENUM);
2249         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, textureMode);
2250         ctx.expectError(GL_INVALID_ENUM);
2251         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, textureMode);
2252         ctx.expectError(GL_INVALID_ENUM);
2253         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, textureMode);
2254         ctx.expectError(GL_INVALID_ENUM);
2255         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, textureMode);
2256         ctx.expectError(GL_INVALID_ENUM);
2257         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, textureMode);
2258         ctx.expectError(GL_INVALID_ENUM);
2259         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, textureMode);
2260         ctx.expectError(GL_INVALID_ENUM);
2261         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, textureMode);
2262         ctx.expectError(GL_INVALID_ENUM);
2263         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, textureMode);
2264         ctx.expectError(GL_INVALID_ENUM);
2265         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, textureMode);
2266         ctx.expectError(GL_INVALID_ENUM);
2267         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, textureMode);
2268         ctx.expectError(GL_INVALID_ENUM);
2269         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, textureMode);
2270         ctx.expectError(GL_INVALID_ENUM);
2271         ctx.endSection();
2272
2273         ctx.beginSection("GL_INVALID_VALUE is generated if pname is GL_TEXTURE_BASE_LEVEL or GL_TEXTURE_MAX_LEVEL and param(s) is negative.");
2274         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, textureMode);
2275         ctx.expectError(GL_INVALID_VALUE);
2276         ctx.glTexParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, textureMode);
2277         ctx.expectError(GL_INVALID_VALUE);
2278         ctx.endSection();
2279
2280         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.");
2281         textureMode[0] = 0;
2282         textureMode[1] = 0;
2283         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BORDER_COLOR, textureMode);
2284         ctx.expectError(GL_INVALID_ENUM);
2285         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_FILTER, textureMode);
2286         ctx.expectError(GL_INVALID_ENUM);
2287         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAG_FILTER, textureMode);
2288         ctx.expectError(GL_INVALID_ENUM);
2289         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_S, textureMode);
2290         ctx.expectError(GL_INVALID_ENUM);
2291         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_T, textureMode);
2292         ctx.expectError(GL_INVALID_ENUM);
2293         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_R, textureMode);
2294         ctx.expectError(GL_INVALID_ENUM);
2295         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_LOD, textureMode);
2296         ctx.expectError(GL_INVALID_ENUM);
2297         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAX_LOD, textureMode);
2298         ctx.expectError(GL_INVALID_ENUM);
2299         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_MODE, textureMode);
2300         ctx.expectError(GL_INVALID_ENUM);
2301         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_FUNC, textureMode);
2302         ctx.expectError(GL_INVALID_ENUM);
2303
2304         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BORDER_COLOR, textureMode);
2305         ctx.expectError(GL_INVALID_ENUM);
2306         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_FILTER, textureMode);
2307         ctx.expectError(GL_INVALID_ENUM);
2308         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAG_FILTER, textureMode);
2309         ctx.expectError(GL_INVALID_ENUM);
2310         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_S, textureMode);
2311         ctx.expectError(GL_INVALID_ENUM);
2312         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_T, textureMode);
2313         ctx.expectError(GL_INVALID_ENUM);
2314         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_R, textureMode);
2315         ctx.expectError(GL_INVALID_ENUM);
2316         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_LOD, textureMode);
2317         ctx.expectError(GL_INVALID_ENUM);
2318         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAX_LOD, textureMode);
2319         ctx.expectError(GL_INVALID_ENUM);
2320         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_MODE, textureMode);
2321         ctx.expectError(GL_INVALID_ENUM);
2322         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_FUNC, textureMode);
2323         ctx.expectError(GL_INVALID_ENUM);
2324         ctx.endSection();
2325
2326         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.");
2327         textureMode[0] = 1;
2328         textureMode[1] = 1;
2329         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, textureMode);
2330         ctx.expectError(GL_INVALID_OPERATION);
2331         ctx.glTexParameterIiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BASE_LEVEL, textureMode);
2332         ctx.expectError(GL_INVALID_OPERATION);
2333         ctx.endSection();
2334 }
2335
2336 // glTexParameterIuiv
2337
2338 void texparameterIuiv (NegativeTestContext& ctx)
2339 {
2340         if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
2341                 throw tcu::NotSupportedError("glTexParameterIuiv is not supported.", DE_NULL, __FILE__, __LINE__);
2342
2343         GLuint textureMode[] = { GL_DEPTH_COMPONENT, GL_STENCIL_INDEX };
2344         ctx.beginSection("GL_INVALID_ENUM is generated if target is not a valid target.");
2345         ctx.glTexParameterIuiv(0, GL_DEPTH_STENCIL_TEXTURE_MODE, textureMode);
2346         ctx.expectError(GL_INVALID_ENUM);
2347         ctx.endSection();
2348
2349         ctx.beginSection("GL_INVALID_ENUM is generated if pname is not a valid parameter.");
2350         ctx.glTexParameterIuiv(GL_TEXTURE_2D, 0, textureMode);
2351         ctx.expectError(GL_INVALID_ENUM);
2352         ctx.endSection();
2353
2354         ctx.beginSection("GL_INVALID_ENUM is generated if pname is enum and the value of param(s) is not a valid value.");
2355         textureMode[0] = GL_DONT_CARE;
2356         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, textureMode);
2357         ctx.expectError(GL_INVALID_ENUM);
2358         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, textureMode);
2359         ctx.expectError(GL_INVALID_ENUM);
2360         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, textureMode);
2361         ctx.expectError(GL_INVALID_ENUM);
2362         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, textureMode);
2363         ctx.expectError(GL_INVALID_ENUM);
2364         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, textureMode);
2365         ctx.expectError(GL_INVALID_ENUM);
2366         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, textureMode);
2367         ctx.expectError(GL_INVALID_ENUM);
2368         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, textureMode);
2369         ctx.expectError(GL_INVALID_ENUM);
2370         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, textureMode);
2371         ctx.expectError(GL_INVALID_ENUM);
2372         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, textureMode);
2373         ctx.expectError(GL_INVALID_ENUM);
2374         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, textureMode);
2375         ctx.expectError(GL_INVALID_ENUM);
2376         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, textureMode);
2377         ctx.expectError(GL_INVALID_ENUM);
2378         ctx.glTexParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, textureMode);
2379         ctx.expectError(GL_INVALID_ENUM);
2380         ctx.endSection();
2381
2382         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.");
2383         textureMode[0] = 0;
2384         textureMode[1] = 0;
2385         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BORDER_COLOR, textureMode);
2386         ctx.expectError(GL_INVALID_ENUM);
2387         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_FILTER, textureMode);
2388         ctx.expectError(GL_INVALID_ENUM);
2389         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAG_FILTER, textureMode);
2390         ctx.expectError(GL_INVALID_ENUM);
2391         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_S, textureMode);
2392         ctx.expectError(GL_INVALID_ENUM);
2393         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_T, textureMode);
2394         ctx.expectError(GL_INVALID_ENUM);
2395         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_WRAP_R, textureMode);
2396         ctx.expectError(GL_INVALID_ENUM);
2397         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MIN_LOD, textureMode);
2398         ctx.expectError(GL_INVALID_ENUM);
2399         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAX_LOD, textureMode);
2400         ctx.expectError(GL_INVALID_ENUM);
2401         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_MODE, textureMode);
2402         ctx.expectError(GL_INVALID_ENUM);
2403         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_COMPARE_FUNC, textureMode);
2404         ctx.expectError(GL_INVALID_ENUM);
2405
2406         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BORDER_COLOR, textureMode);
2407         ctx.expectError(GL_INVALID_ENUM);
2408         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_FILTER, textureMode);
2409         ctx.expectError(GL_INVALID_ENUM);
2410         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAG_FILTER, textureMode);
2411         ctx.expectError(GL_INVALID_ENUM);
2412         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_S, textureMode);
2413         ctx.expectError(GL_INVALID_ENUM);
2414         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_T, textureMode);
2415         ctx.expectError(GL_INVALID_ENUM);
2416         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_WRAP_R, textureMode);
2417         ctx.expectError(GL_INVALID_ENUM);
2418         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MIN_LOD, textureMode);
2419         ctx.expectError(GL_INVALID_ENUM);
2420         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_MAX_LOD, textureMode);
2421         ctx.expectError(GL_INVALID_ENUM);
2422         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_MODE, textureMode);
2423         ctx.expectError(GL_INVALID_ENUM);
2424         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_COMPARE_FUNC, textureMode);
2425         ctx.expectError(GL_INVALID_ENUM);
2426         ctx.endSection();
2427
2428         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.");
2429         textureMode[0] = 1;
2430         textureMode[1] = 1;
2431         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, textureMode);
2432         ctx.expectError(GL_INVALID_OPERATION);
2433         ctx.glTexParameterIuiv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BASE_LEVEL, textureMode);
2434         ctx.expectError(GL_INVALID_OPERATION);
2435         ctx.endSection();
2436 }
2437
2438 // glCompressedTexSubImage2D
2439
2440 void compressedtexsubimage2d (NegativeTestContext& ctx)
2441 {
2442         ctx.beginSection("GL_INVALID_ENUM is generated if target is invalid.");
2443         ctx.glCompressedTexSubImage2D(0, 0, 0, 0, 0, 0, GL_COMPRESSED_RGB8_ETC2, 0, 0);
2444         ctx.expectError(GL_INVALID_ENUM);
2445         ctx.endSection();
2446
2447         deUint32                                texture = 0x1234;
2448         ctx.glGenTextures                       (1, &texture);
2449         ctx.glBindTexture                       (GL_TEXTURE_2D, texture);
2450         ctx.glCompressedTexImage2D      (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 0, etc2EacDataSize(18, 18), 0);
2451         ctx.expectError                         (GL_NO_ERROR);
2452
2453         ctx.beginSection("GL_INVALID_OPERATION is generated if format does not match the internal format of the texture image being modified.");
2454         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, GL_COMPRESSED_RGB8_ETC2, 0, 0);
2455         ctx.expectError(GL_INVALID_OPERATION);
2456         ctx.endSection();
2457
2458         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.");
2459         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 4, 0, 10, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(10, 4), 0);
2460         ctx.expectError(GL_INVALID_OPERATION);
2461         ctx.endSection();
2462
2463         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.");
2464         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 4, 4, 10, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 10), 0);
2465         ctx.expectError(GL_INVALID_OPERATION);
2466         ctx.endSection();
2467
2468         ctx.beginSection("For ETC2/EAC images GL_INVALID_OPERATION is generated if xoffset or yoffset is not a multiple of four.");
2469         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 1, 4, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
2470         ctx.expectError(GL_INVALID_OPERATION);
2471         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 1, 0, 4, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
2472         ctx.expectError(GL_INVALID_OPERATION);
2473         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 1, 1, 4, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
2474         ctx.expectError(GL_INVALID_OPERATION);
2475         ctx.endSection();
2476
2477         ctx.glDeleteTextures            (1, &texture);
2478 }
2479
2480 void compressedtexsubimage2d_neg_level (NegativeTestContext& ctx)
2481 {
2482         deUint32                                textures[2];
2483         ctx.glGenTextures                       (2, &textures[0]);
2484         ctx.glBindTexture                       (GL_TEXTURE_2D, textures[0]);
2485         ctx.glCompressedTexImage2D      (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 0, etc2EacDataSize(18, 18), 0);
2486         ctx.glBindTexture                       (GL_TEXTURE_CUBE_MAP, textures[1]);
2487         FOR_CUBE_FACES(faceGL, ctx.glCompressedTexImage2D(faceGL, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 0, etc2EacDataSize(18, 18), 0););
2488         ctx.expectError                         (GL_NO_ERROR);
2489
2490         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
2491         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, -1, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2492         ctx.expectError(GL_INVALID_VALUE);
2493         ctx.endSection();
2494
2495         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
2496         FOR_CUBE_FACES(faceGL,
2497         {
2498                 ctx.glCompressedTexSubImage2D(faceGL, -1, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2499                 ctx.expectError(GL_INVALID_VALUE);
2500         });
2501         ctx.endSection();
2502
2503         ctx.glDeleteTextures(2, &textures[0]);
2504 }
2505
2506 void compressedtexsubimage2d_max_level (NegativeTestContext& ctx)
2507 {
2508         deUint32                                textures[2];
2509         ctx.glGenTextures                       (2, &textures[0]);
2510         ctx.glBindTexture                       (GL_TEXTURE_2D, textures[0]);
2511         ctx.glCompressedTexImage2D      (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 0, etc2EacDataSize(18, 18), 0);
2512         ctx.glBindTexture                       (GL_TEXTURE_CUBE_MAP, textures[1]);
2513         FOR_CUBE_FACES(faceGL, ctx.glCompressedTexImage2D(faceGL, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 0, etc2EacDataSize(18, 18), 0););
2514         ctx.expectError                         (GL_NO_ERROR);
2515
2516         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
2517         deUint32 log2MaxTextureSize = deLog2Floor32(ctx.getInteger(GL_MAX_TEXTURE_SIZE)) + 1;
2518         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, log2MaxTextureSize, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2519         ctx.expectError(GL_INVALID_VALUE);
2520         ctx.endSection();
2521
2522         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_TEXTURE_SIZE).");
2523         deUint32 log2MaxCubemapSize = deLog2Floor32(ctx.getInteger(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
2524         FOR_CUBE_FACES(faceGL,
2525         {
2526                 ctx.glCompressedTexSubImage2D(faceGL, log2MaxCubemapSize, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2527                 ctx.expectError(GL_INVALID_VALUE);
2528         });
2529         ctx.endSection();
2530
2531         ctx.glDeleteTextures(2, &textures[0]);
2532 }
2533
2534 void compressedtexsubimage2d_neg_offset (NegativeTestContext& ctx)
2535 {
2536         GLuint texture = 0x1234;
2537         ctx.glGenTextures(1, &texture);
2538         ctx.glBindTexture(GL_TEXTURE_2D, texture);
2539         ctx.glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 8, 8, 0, etc2EacDataSize(8, 8), 0);
2540
2541         // \note Both GL_INVALID_VALUE and GL_INVALID_OPERATION are valid here since implementation may
2542         //               first check if offsets are valid for certain format and only after that check that they
2543         //               are not negative.
2544         ctx.beginSection("GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if xoffset or yoffset are negative.");
2545
2546         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, -4, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2547         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2548         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, -4, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2549         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2550         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, -4, -4, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2551         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2552
2553         ctx.endSection();
2554
2555         ctx.glDeleteTextures(1, &texture);
2556 }
2557
2558 void compressedtexsubimage2d_invalid_offset (NegativeTestContext& ctx)
2559 {
2560         deUint32                                texture = 0x1234;
2561         ctx.glGenTextures                       (1, &texture);
2562         ctx.glBindTexture                       (GL_TEXTURE_2D, texture);
2563         ctx.glCompressedTexImage2D      (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
2564         ctx.expectError                         (GL_NO_ERROR);
2565
2566         ctx.beginSection("GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if xoffset + width > texture_width or yoffset + height > texture_height.");
2567
2568         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 12, 0, 8, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(8, 4), 0);
2569         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2570         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 12, 4, 8, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 8), 0);
2571         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2572         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 12, 12, 8, 8, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(8, 8), 0);
2573         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2574         ctx.endSection();
2575
2576         ctx.glDeleteTextures            (1, &texture);
2577 }
2578
2579 void compressedtexsubimage2d_neg_width_height (NegativeTestContext& ctx)
2580 {
2581         deUint32                                texture = 0x1234;
2582         ctx.glGenTextures                       (1, &texture);
2583         ctx.glBindTexture                       (GL_TEXTURE_2D, texture);
2584         ctx.glCompressedTexImage2D      (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
2585         ctx.expectError                         (GL_NO_ERROR);
2586
2587         ctx.beginSection("GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if width or height is less than 0.");
2588         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, -4, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2589         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2590         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, -4, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2591         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2592         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, -4, -4, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2593         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2594         ctx.endSection();
2595
2596         ctx.glDeleteTextures(1,         &texture);
2597 }
2598
2599 void compressedtexsubimage2d_invalid_size (NegativeTestContext& ctx)
2600 {
2601         deUint32                                texture = 0x1234;
2602         ctx.glGenTextures                       (1, &texture);
2603         ctx.glBindTexture                       (GL_TEXTURE_2D, texture);
2604         ctx.glCompressedTexImage2D      (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
2605         ctx.expectError                         (GL_NO_ERROR);
2606
2607         ctx.beginSection("GL_INVALID_VALUE is generated if imageSize is not consistent with the format, dimensions, and contents of the specified compressed image data.");
2608         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0);
2609         ctx.expectError(GL_INVALID_VALUE);
2610
2611         ctx.glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 16, 16, GL_COMPRESSED_RGBA8_ETC2_EAC, 4*4*16-1, 0);
2612         ctx.expectError(GL_INVALID_VALUE);
2613         ctx.endSection();
2614
2615         ctx.glDeleteTextures            (1, &texture);
2616 }
2617
2618 void compressedtexsubimage2d_invalid_buffer_target (NegativeTestContext& ctx)
2619 {
2620         deUint32                                        buf = 0x1234;
2621         deUint32                                        texture = 0x1234;
2622         std::vector<GLubyte>            data(128);
2623
2624         ctx.glGenTextures                               (1, &texture);
2625         ctx.glBindTexture                               (GL_TEXTURE_2D, texture);
2626         ctx.glCompressedTexImage2D              (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
2627         ctx.glGenBuffers                                (1, &buf);
2628         ctx.glBindBuffer                                (GL_PIXEL_UNPACK_BUFFER, buf);
2629         ctx.glBufferData                                (GL_PIXEL_UNPACK_BUFFER, 128, &data[0], GL_DYNAMIC_COPY);
2630         ctx.expectError                                 (GL_NO_ERROR);
2631
2632         ctx.beginSection("GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and...");
2633         ctx.beginSection("...the buffer object's data store is currently mapped.");
2634         ctx.glMapBufferRange                    (GL_PIXEL_UNPACK_BUFFER, 0, 128, GL_MAP_WRITE_BIT);
2635         ctx.glCompressedTexSubImage2D   (GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
2636         ctx.expectError                                 (GL_INVALID_OPERATION);
2637         ctx.glUnmapBuffer                               (GL_PIXEL_UNPACK_BUFFER);
2638         ctx.endSection();
2639
2640         ctx.beginSection("...the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
2641         ctx.glCompressedTexSubImage2D   (GL_TEXTURE_2D, 0, 0, 0, 16, 16, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(16, 16), 0);
2642         ctx.expectError                                 (GL_INVALID_OPERATION);
2643         ctx.endSection();
2644         ctx.endSection();
2645
2646         ctx.glDeleteBuffers                     (1, &buf);
2647         ctx.glDeleteTextures            (1, &texture);
2648 }
2649
2650 // glTexImage3D
2651
2652 void teximage3d (NegativeTestContext& ctx)
2653 {
2654         ctx.beginSection("GL_INVALID_ENUM is generated if target is invalid.");
2655         ctx.glTexImage3D(0, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2656         ctx.expectError(GL_INVALID_ENUM);
2657         ctx.glTexImage3D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2658         ctx.expectError(GL_INVALID_ENUM);
2659         ctx.endSection();
2660
2661         ctx.beginSection("GL_INVALID_ENUM is generated if type is not a type constant.");
2662         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, 0, 0);
2663         ctx.expectError(GL_INVALID_ENUM);
2664         ctx.endSection();
2665
2666         ctx.beginSection("GL_INVALID_ENUM is generated if format is not an accepted format constant.");
2667         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, 1, 0, 0, GL_UNSIGNED_BYTE, 0);
2668         ctx.expectError(GL_INVALID_ENUM);
2669         ctx.endSection();
2670
2671         ctx.beginSection("GL_INVALID_VALUE is generated if internalFormat is not one of the accepted resolution and format symbolic constants.");
2672         ctx.glTexImage3D(GL_TEXTURE_3D, 0, 0, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2673         ctx.expectError(GL_INVALID_VALUE);
2674         ctx.endSection();
2675
2676         ctx.beginSection("GL_INVALID_OPERATION is generated if target is GL_TEXTURE_3D and format is GL_DEPTH_COMPONENT, or GL_DEPTH_STENCIL.");
2677         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, 1, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_BYTE, 0);
2678         ctx.expectError(GL_INVALID_OPERATION);
2679         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, 1, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0);
2680         ctx.expectError(GL_INVALID_OPERATION);
2681         ctx.endSection();
2682
2683         ctx.beginSection("GL_INVALID_OPERATION is generated if the combination of internalFormat, format and type is invalid.");
2684         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2685         ctx.expectError(GL_INVALID_OPERATION);
2686         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, 0);
2687         ctx.expectError(GL_INVALID_OPERATION);
2688         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB5_A1, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, 0);
2689         ctx.expectError(GL_INVALID_OPERATION);
2690         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB10_A2, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_INT_2_10_10_10_REV, 0);
2691         ctx.expectError(GL_INVALID_OPERATION);
2692         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA32UI, 1, 1, 1, 0, GL_RGBA_INTEGER, GL_INT, 0);
2693         ctx.expectError(GL_INVALID_OPERATION);
2694         ctx.endSection();
2695
2696         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
2697         {
2698                 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_TEXTURE_CUBE_MAP_ARRAY and width and height are not equal.");
2699                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, 2, 1, 6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2700                 ctx.expectError(GL_INVALID_VALUE);
2701                 ctx.endSection();
2702
2703                 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_TEXTURE_CUBE_MAP_ARRAY and depth is not a multiple of six.");
2704                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2705                 ctx.expectError(GL_INVALID_VALUE);
2706                 ctx.endSection();
2707         }
2708 }
2709
2710 void teximage3d_neg_level (NegativeTestContext& ctx)
2711 {
2712         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
2713         ctx.glTexImage3D(GL_TEXTURE_3D, -1, GL_RGB, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
2714         ctx.expectError(GL_INVALID_VALUE);
2715         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, -1, GL_RGB, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
2716         ctx.expectError(GL_INVALID_VALUE);
2717
2718         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
2719         {
2720                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, -1, GL_RGBA, 1, 1, 6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2721                 ctx.expectError(GL_INVALID_VALUE);
2722         }
2723
2724         ctx.endSection();
2725
2726 }
2727
2728 void teximage3d_max_level (NegativeTestContext& ctx)
2729 {
2730         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_3D_TEXTURE_SIZE).");
2731         deUint32 log2Max3DTextureSize = deLog2Floor32(ctx.getInteger(GL_MAX_3D_TEXTURE_SIZE)) + 1;
2732         ctx.glTexImage3D(GL_TEXTURE_3D, log2Max3DTextureSize, GL_RGB, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
2733         ctx.expectError(GL_INVALID_VALUE);
2734         ctx.endSection();
2735
2736         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
2737         deUint32 log2MaxTextureSize = deLog2Floor32(ctx.getInteger(GL_MAX_TEXTURE_SIZE)) + 1;
2738         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, log2MaxTextureSize, GL_RGB, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
2739         ctx.expectError(GL_INVALID_VALUE);
2740         ctx.endSection();
2741 }
2742
2743 void teximage3d_neg_width_height_depth (NegativeTestContext& ctx)
2744 {
2745         ctx.beginSection("GL_INVALID_VALUE is generated if width or height is less than 0.");
2746         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, -1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2747         ctx.expectError(GL_INVALID_VALUE);
2748         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, -1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2749         ctx.expectError(GL_INVALID_VALUE);
2750         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2751         ctx.expectError(GL_INVALID_VALUE);
2752         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, -1, -1, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2753         ctx.expectError(GL_INVALID_VALUE);
2754
2755         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, -1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2756         ctx.expectError(GL_INVALID_VALUE);
2757         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 1, -1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2758         ctx.expectError(GL_INVALID_VALUE);
2759         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 1, 1, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2760         ctx.expectError(GL_INVALID_VALUE);
2761         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, -1, -1, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2762         ctx.expectError(GL_INVALID_VALUE);
2763
2764         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
2765         {
2766                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, -1, 1, 6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2767                 ctx.expectError(GL_INVALID_VALUE);
2768                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, 1, -1, 6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2769                 ctx.expectError(GL_INVALID_VALUE);
2770                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, 1, 1, -6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2771                 ctx.expectError(GL_INVALID_VALUE);
2772                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, -1, -1, -6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2773                 ctx.expectError(GL_INVALID_VALUE);
2774         }
2775         ctx.endSection();
2776 }
2777
2778 void teximage3d_max_width_height_depth (NegativeTestContext& ctx)
2779 {
2780         int max3DTextureSize    = ctx.getInteger(GL_MAX_3D_TEXTURE_SIZE) + 1;
2781         int maxTextureSize              = ctx.getInteger(GL_MAX_TEXTURE_SIZE) + 1;
2782
2783         ctx.beginSection("GL_INVALID_VALUE is generated if width, height or depth is greater than GL_MAX_3D_TEXTURE_SIZE.");
2784         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, max3DTextureSize, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2785         ctx.expectError(GL_INVALID_VALUE);
2786         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, max3DTextureSize, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2787         ctx.expectError(GL_INVALID_VALUE);
2788         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, max3DTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2789         ctx.expectError(GL_INVALID_VALUE);
2790         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, max3DTextureSize, max3DTextureSize, max3DTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2791         ctx.expectError(GL_INVALID_VALUE);
2792         ctx.endSection();
2793
2794         ctx.beginSection("GL_INVALID_VALUE is generated if width, height or depth is greater than GL_MAX_TEXTURE_SIZE.");
2795         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, maxTextureSize, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2796         ctx.expectError(GL_INVALID_VALUE);
2797         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 1, maxTextureSize, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2798         ctx.expectError(GL_INVALID_VALUE);
2799         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 1, 1, maxTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2800         ctx.expectError(GL_INVALID_VALUE);
2801         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, maxTextureSize, maxTextureSize, maxTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2802         ctx.expectError(GL_INVALID_VALUE);
2803         ctx.endSection();
2804 }
2805
2806 void teximage3d_invalid_border (NegativeTestContext& ctx)
2807 {
2808         ctx.beginSection("GL_INVALID_VALUE is generated if border is not 0 or 1.");
2809         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, 1, 1, 1, -1, GL_RGB, GL_UNSIGNED_BYTE, 0);
2810         ctx.expectError(GL_INVALID_VALUE);
2811         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, 1, 1, 1, 2, GL_RGB, GL_UNSIGNED_BYTE, 0);
2812         ctx.expectError(GL_INVALID_VALUE);
2813         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGB, 1, 1, 1, -1, GL_RGB, GL_UNSIGNED_BYTE, 0);
2814         ctx.expectError(GL_INVALID_VALUE);
2815         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGB, 1, 1, 1, 2, GL_RGB, GL_UNSIGNED_BYTE, 0);
2816         ctx.expectError(GL_INVALID_VALUE);
2817
2818         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
2819         {
2820                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA, 1, 1, 6, -1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2821                 ctx.expectError(GL_INVALID_VALUE);
2822                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA, 1, 1, 6, 1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2823                 ctx.expectError(GL_INVALID_VALUE);
2824         }
2825
2826         ctx.endSection();
2827 }
2828
2829 void teximage3d_invalid_buffer_target (NegativeTestContext& ctx)
2830 {
2831         deUint32                                buf = 0x1234;
2832         deUint32                                texture = 0x1234;
2833         std::vector<GLubyte>    data(512);
2834
2835         ctx.glGenBuffers                        (1, &buf);
2836         ctx.glBindBuffer                        (GL_PIXEL_UNPACK_BUFFER, buf);
2837         ctx.glBufferData                        (GL_PIXEL_UNPACK_BUFFER, 512, &data[0], GL_DYNAMIC_COPY);
2838         ctx.glGenTextures                       (1, &texture);
2839         ctx.glBindTexture                       (GL_TEXTURE_3D, texture);
2840         ctx.expectError                         (GL_NO_ERROR);
2841
2842         ctx.beginSection("GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and...");
2843
2844         ctx.beginSection("...the buffer object's data store is currently mapped.");
2845         ctx.glMapBufferRange            (GL_PIXEL_UNPACK_BUFFER, 0, 128, GL_MAP_WRITE_BIT);
2846         ctx.glTexImage3D                        (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2847         ctx.expectError                         (GL_INVALID_OPERATION);
2848         ctx.glUnmapBuffer                       (GL_PIXEL_UNPACK_BUFFER);
2849         ctx.endSection();
2850
2851         ctx.beginSection("...the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
2852         ctx.glTexImage3D                        (GL_TEXTURE_3D, 0, GL_RGBA, 64, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2853         ctx.expectError                         (GL_INVALID_OPERATION);
2854         ctx.endSection();
2855
2856         ctx.beginSection("...data is not evenly divisible into the number of bytes needed to store in memory a datum indicated by type.");
2857         ctx.getLog() << TestLog::Message << "// Set byte offset = 3" << TestLog::EndMessage;
2858         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);
2859         ctx.expectError                         (GL_INVALID_OPERATION);
2860         ctx.endSection();
2861
2862         ctx.endSection();
2863
2864         ctx.glDeleteBuffers                     (1, &buf);
2865         ctx.glDeleteTextures            (1, &texture);
2866 }
2867
2868 // glTexSubImage3D
2869
2870 void texsubimage3d (NegativeTestContext& ctx)
2871 {
2872         deUint32                        texture = 0x1234;
2873         ctx.glGenTextures               (1, &texture);
2874         ctx.glBindTexture               (GL_TEXTURE_3D, texture);
2875         ctx.glTexImage3D                (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2876         ctx.expectError                 (GL_NO_ERROR);
2877
2878         ctx.beginSection("GL_INVALID_ENUM is generated if target is invalid.");
2879         ctx.glTexSubImage3D(0, 0, 0, 0, 0, 4, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2880         ctx.expectError(GL_INVALID_ENUM);
2881         ctx.glTexSubImage3D(GL_TEXTURE_2D, 0, 0, 0, 0, 4, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2882         ctx.expectError(GL_INVALID_ENUM);
2883         ctx.endSection();
2884
2885         ctx.beginSection("GL_INVALID_ENUM is generated if format is not an accepted format constant.");
2886         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 4, 4, 4, GL_UNSIGNED_BYTE, 0);
2887         ctx.expectError(GL_INVALID_ENUM);
2888         ctx.endSection();
2889
2890         ctx.beginSection("GL_INVALID_ENUM is generated if type is not a type constant.");
2891         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGB, 0, 0);
2892         ctx.expectError(GL_INVALID_ENUM);
2893         ctx.endSection();
2894
2895         ctx.beginSection("GL_INVALID_OPERATION is generated if the combination of internalFormat of the previously specified texture array, format and type is not valid.");
2896         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, 0);
2897         ctx.expectError(GL_INVALID_OPERATION);
2898         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, 0);
2899         ctx.expectError(GL_INVALID_OPERATION);
2900         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, 0);
2901         ctx.expectError(GL_INVALID_OPERATION);
2902         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGBA_INTEGER, GL_UNSIGNED_INT, 0);
2903         ctx.expectError(GL_INVALID_OPERATION);
2904         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGB, GL_FLOAT, 0);
2905         ctx.expectError(GL_INVALID_OPERATION);
2906         ctx.endSection();
2907
2908         ctx.glDeleteTextures    (1, &texture);
2909 }
2910
2911 void texsubimage3d_neg_level (NegativeTestContext& ctx)
2912 {
2913         deUint32                        textures[3];
2914         ctx.glGenTextures               (3, &textures[0]);
2915         ctx.glBindTexture               (GL_TEXTURE_3D, textures[0]);
2916         ctx.glTexImage3D                (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2917         ctx.glBindTexture               (GL_TEXTURE_2D_ARRAY, textures[1]);
2918         ctx.glTexImage3D                (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2919         ctx.glBindTexture               (GL_TEXTURE_CUBE_MAP_ARRAY, textures[2]);
2920         ctx.glTexImage3D                (GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, 4, 4, 6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2921         ctx.expectError                 (GL_NO_ERROR);
2922
2923         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
2924         ctx.glTexSubImage3D(GL_TEXTURE_3D, -1, 0, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2925         ctx.expectError(GL_INVALID_VALUE);
2926         ctx.glTexSubImage3D(GL_TEXTURE_2D_ARRAY, -1, 0, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2927         ctx.expectError(GL_INVALID_VALUE);
2928
2929         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
2930         {
2931                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, -1, 0, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2932                 ctx.expectError(GL_INVALID_VALUE);
2933         }
2934
2935         ctx.endSection();
2936
2937         ctx.glDeleteTextures    (3, &textures[0]);
2938 }
2939
2940 void texsubimage3d_max_level (NegativeTestContext& ctx)
2941 {
2942         deUint32                        textures[2];
2943         ctx.glGenTextures               (2, &textures[0]);
2944         ctx.glBindTexture               (GL_TEXTURE_3D, textures[0]);
2945         ctx.glTexImage3D                (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2946         ctx.glBindTexture               (GL_TEXTURE_2D_ARRAY, textures[1]);
2947         ctx.glTexImage3D                (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2948         ctx.expectError                 (GL_NO_ERROR);
2949
2950         deUint32 log2Max3DTextureSize   = deLog2Floor32(ctx.getInteger(GL_MAX_3D_TEXTURE_SIZE)) + 1;
2951         deUint32 log2MaxTextureSize             = deLog2Floor32(ctx.getInteger(GL_MAX_TEXTURE_SIZE)) + 1;
2952
2953         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_3D_TEXTURE_SIZE).");
2954         ctx.glTexSubImage3D(GL_TEXTURE_3D, log2Max3DTextureSize, 0, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2955         ctx.expectError(GL_INVALID_VALUE);
2956         ctx.endSection();
2957
2958         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
2959         ctx.glTexSubImage3D(GL_TEXTURE_2D_ARRAY, log2MaxTextureSize, 0, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2960         ctx.expectError(GL_INVALID_VALUE);
2961         ctx.endSection();
2962
2963         ctx.glDeleteTextures    (2, &textures[0]);
2964 }
2965
2966 void texsubimage3d_neg_offset (NegativeTestContext& ctx)
2967 {
2968         deUint32                        textures[3];
2969         ctx.glGenTextures               (3, &textures[0]);
2970         ctx.glBindTexture               (GL_TEXTURE_3D, textures[0]);
2971         ctx.glTexImage3D                (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2972         ctx.glBindTexture               (GL_TEXTURE_2D_ARRAY, textures[1]);
2973         ctx.glTexImage3D                (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2974         ctx.glBindTexture               (GL_TEXTURE_CUBE_MAP_ARRAY, textures[2]);
2975         ctx.glTexImage3D                (GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, 4, 4, 6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2976         ctx.expectError                 (GL_NO_ERROR);
2977
2978         ctx.beginSection("GL_INVALID_VALUE is generated if xoffset, yoffset or zoffset are negative.");
2979         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, -1, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2980         ctx.expectError(GL_INVALID_VALUE);
2981         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, -1, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2982         ctx.expectError(GL_INVALID_VALUE);
2983         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, -1, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2984         ctx.expectError(GL_INVALID_VALUE);
2985         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, -1, -1, -1, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2986         ctx.expectError(GL_INVALID_VALUE);
2987         ctx.glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, -1, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2988         ctx.expectError(GL_INVALID_VALUE);
2989         ctx.glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, -1, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2990         ctx.expectError(GL_INVALID_VALUE);
2991         ctx.glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, -1, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2992         ctx.expectError(GL_INVALID_VALUE);
2993         ctx.glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, -1, -1, -1, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2994         ctx.expectError(GL_INVALID_VALUE);
2995
2996         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
2997         {
2998                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, -1, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2999                 ctx.expectError(GL_INVALID_VALUE);
3000                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, -1, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3001                 ctx.expectError(GL_INVALID_VALUE);
3002                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, 0, -1, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3003                 ctx.expectError(GL_INVALID_VALUE);
3004                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, -1, -1, -1, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3005                 ctx.expectError(GL_INVALID_VALUE);
3006         }
3007
3008         ctx.endSection();
3009
3010         ctx.glDeleteTextures    (3, &textures[0]);
3011 }
3012
3013 void texsubimage3d_invalid_offset (NegativeTestContext& ctx)
3014 {
3015         deUint32                        texture = 0x1234;
3016         ctx.glGenTextures               (1, &texture);
3017         ctx.glBindTexture               (GL_TEXTURE_3D, texture);
3018         ctx.glTexImage3D                (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3019         ctx.expectError                 (GL_NO_ERROR);
3020
3021         ctx.beginSection("GL_INVALID_VALUE is generated if xoffset + width > texture_width.");
3022         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 2, 0, 0, 4, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3023         ctx.expectError(GL_INVALID_VALUE);
3024         ctx.endSection();
3025
3026         ctx.beginSection("GL_INVALID_VALUE is generated if yoffset + height > texture_height.");
3027         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 2, 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 zoffset + depth > texture_depth.");
3032         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 2, 4, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3033         ctx.expectError(GL_INVALID_VALUE);
3034         ctx.endSection();
3035
3036         ctx.glDeleteTextures    (1, &texture);
3037 }
3038
3039 void texsubimage3d_neg_width_height (NegativeTestContext& ctx)
3040 {
3041         ctx.beginSection("GL_INVALID_VALUE is generated if width, height or depth is less than 0.");
3042         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, -1, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3043         ctx.expectError(GL_INVALID_VALUE);
3044         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3045         ctx.expectError(GL_INVALID_VALUE);
3046         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, -1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3047         ctx.expectError(GL_INVALID_VALUE);
3048         ctx.glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, -1, -1, -1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3049         ctx.expectError(GL_INVALID_VALUE);
3050
3051         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3052         {
3053                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, 0, 0, -1, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3054                 ctx.expectError(GL_INVALID_VALUE);
3055                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, 0, 0, 0, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3056                 ctx.expectError(GL_INVALID_VALUE);
3057                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, 0, 0, 0, 0, -1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3058                 ctx.expectError(GL_INVALID_VALUE);
3059                 ctx.glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, 0, 0, -1, -1, -1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3060                 ctx.expectError(GL_INVALID_VALUE);
3061         }
3062
3063         ctx.endSection();
3064 }
3065
3066 void texsubimage3d_invalid_buffer_target (NegativeTestContext& ctx)
3067 {
3068         deUint32                                buf = 0x1234;
3069         deUint32                                texture = 0x1234;
3070         std::vector<GLubyte>    data(512);
3071
3072         ctx.glGenTextures                       (1, &texture);
3073         ctx.glBindTexture                       (GL_TEXTURE_3D, texture);
3074         ctx.glTexImage3D                        (GL_TEXTURE_3D, 0, GL_RGBA, 16, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3075         ctx.glGenBuffers                        (1, &buf);
3076         ctx.glBindBuffer                        (GL_PIXEL_UNPACK_BUFFER, buf);
3077         ctx.glBufferData                        (GL_PIXEL_UNPACK_BUFFER, 512, &data[0], GL_DYNAMIC_COPY);
3078         ctx.expectError                         (GL_NO_ERROR);
3079
3080         ctx.beginSection("GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and...");
3081
3082         ctx.beginSection("...the buffer object's data store is currently mapped.");
3083         ctx.glMapBufferRange            (GL_PIXEL_UNPACK_BUFFER, 0, 512, GL_MAP_WRITE_BIT);
3084         ctx.glTexSubImage3D                     (GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3085         ctx.expectError                         (GL_INVALID_OPERATION);
3086         ctx.glUnmapBuffer                       (GL_PIXEL_UNPACK_BUFFER);
3087         ctx.endSection();
3088
3089         ctx.beginSection("...the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
3090         ctx.glTexSubImage3D                     (GL_TEXTURE_3D, 0, 0, 0, 0, 16, 16, 16, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3091         ctx.expectError                         (GL_INVALID_OPERATION);
3092         ctx.endSection();
3093
3094         ctx.beginSection("...data is not evenly divisible into the number of bytes needed to store in memory a datum indicated by type.");
3095         ctx.getLog() << TestLog::Message << "// Set byte offset = 3" << TestLog::EndMessage;
3096         ctx.glBindBuffer                        (GL_PIXEL_UNPACK_BUFFER, 0);
3097         ctx.glTexImage3D                        (GL_TEXTURE_3D, 0, GL_RGBA4, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, 0);
3098         ctx.glBindBuffer                        (GL_PIXEL_UNPACK_BUFFER, buf);
3099         ctx.expectError                         (GL_NO_ERROR);
3100         ctx.glTexSubImage3D                     (GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, (const GLvoid*)3);
3101         ctx.expectError                         (GL_INVALID_OPERATION);
3102         ctx.endSection();
3103
3104         ctx.endSection();
3105
3106         ctx.glDeleteBuffers                     (1, &buf);
3107         ctx.glDeleteTextures            (1, &texture);
3108 }
3109
3110 // glCopyTexSubImage3D
3111
3112 void copytexsubimage3d (NegativeTestContext& ctx)
3113 {
3114         GLuint texture = 0x1234;
3115         ctx.glGenTextures       (1, &texture);
3116         ctx.glBindTexture       (GL_TEXTURE_3D, texture);
3117         ctx.glTexImage3D        (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3118
3119         ctx.beginSection("GL_INVALID_ENUM is generated if target is invalid.");
3120         ctx.glCopyTexSubImage3D(0, 0, 0, 0, 0, 0, 0, 4, 4);
3121         ctx.expectError(GL_INVALID_ENUM);
3122         ctx.endSection();
3123
3124         ctx.glDeleteTextures(1, &texture);
3125 }
3126
3127 void copytexsubimage3d_neg_level (NegativeTestContext& ctx)
3128 {
3129         deUint32        textures[3];
3130         ctx.glGenTextures(3, &textures[0]);
3131         ctx.glBindTexture(GL_TEXTURE_3D, textures[0]);
3132         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3133         ctx.glBindTexture(GL_TEXTURE_2D_ARRAY, textures[1]);
3134         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3135         ctx.expectError(GL_NO_ERROR);
3136
3137         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
3138         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, -1, 0, 0, 0, 0, 0, 4, 4);
3139         ctx.expectError(GL_INVALID_VALUE);
3140         ctx.glCopyTexSubImage3D(GL_TEXTURE_2D_ARRAY, -1, 0, 0, 0, 0, 0, 4, 4);
3141         ctx.expectError(GL_INVALID_VALUE);
3142
3143         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3144         {
3145                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, textures[2]);
3146                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, 4, 4, 6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3147                 ctx.expectError(GL_NO_ERROR);
3148                 ctx.glCopyTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, -1, 0, 0, 0, 0, 0, 4, 4);
3149                 ctx.expectError(GL_INVALID_VALUE);
3150         }
3151
3152         ctx.endSection();
3153
3154         ctx.glDeleteTextures(3, &textures[0]);
3155 }
3156
3157 void copytexsubimage3d_max_level (NegativeTestContext& ctx)
3158 {
3159         deUint32        log2Max3DTextureSize            = deLog2Floor32(ctx.getInteger(GL_MAX_3D_TEXTURE_SIZE)) + 1;
3160         deUint32        log2MaxTextureSize                      = deLog2Floor32(ctx.getInteger(GL_MAX_TEXTURE_SIZE)) + 1;
3161         deUint32        log2MaxCubeMapTextureSize       = deLog2Floor32(ctx.getInteger(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
3162
3163         deUint32        textures[3];
3164         ctx.glGenTextures(3, &textures[0]);
3165         ctx.glBindTexture(GL_TEXTURE_3D, textures[0]);
3166         ctx.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3167         ctx.glBindTexture(GL_TEXTURE_2D_ARRAY, textures[1]);
3168         ctx.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3169         ctx.expectError(GL_NO_ERROR);
3170
3171         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_3D_TEXTURE_SIZE).");
3172         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, log2Max3DTextureSize, 0, 0, 0, 0, 0, 4, 4);
3173         ctx.expectError(GL_INVALID_VALUE);
3174         ctx.endSection();
3175
3176         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
3177         ctx.glCopyTexSubImage3D(GL_TEXTURE_2D_ARRAY, log2MaxTextureSize, 0, 0, 0, 0, 0, 4, 4);
3178         ctx.expectError(GL_INVALID_VALUE);
3179         ctx.endSection();
3180
3181         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3182         {
3183                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, textures[2]);
3184                 ctx.glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA, 4, 4, 6, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3185                 ctx.expectError(GL_NO_ERROR);
3186                 ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_TEXTURE_SIZE).");
3187                 ctx.glCopyTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, log2MaxCubeMapTextureSize, 0, 0, 0, 0, 0, 4, 4);
3188                 ctx.expectError(GL_INVALID_VALUE);
3189                 ctx.endSection();
3190         }
3191
3192         ctx.glDeleteTextures(3, &textures[0]);
3193 }
3194
3195 void copytexsubimage3d_neg_offset (NegativeTestContext& ctx)
3196 {
3197         GLuint texture = 0x1234;
3198         ctx.glGenTextures       (1, &texture);
3199         ctx.glBindTexture       (GL_TEXTURE_3D, texture);
3200         ctx.glTexImage3D        (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3201
3202         ctx.beginSection("GL_INVALID_VALUE is generated if xoffset, yoffset or zoffset is negative.");
3203         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, -1, 0,  0, 0, 0, 4, 4);
3204         ctx.expectError(GL_INVALID_VALUE);
3205         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, -1, 0, 0, 0, 4, 4);
3206         ctx.expectError(GL_INVALID_VALUE);
3207         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, -1, 0, 0, 4, 4);
3208         ctx.expectError(GL_INVALID_VALUE);
3209         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, -1, -1, -1, 0, 0, 4, 4);
3210         ctx.expectError(GL_INVALID_VALUE);
3211         ctx.endSection();
3212
3213         ctx.glDeleteTextures(1, &texture);
3214 }
3215
3216 void copytexsubimage3d_invalid_offset (NegativeTestContext& ctx)
3217 {
3218         GLuint texture = 0x1234;
3219         ctx.glGenTextures       (1, &texture);
3220         ctx.glBindTexture       (GL_TEXTURE_3D, texture);
3221         ctx.glTexImage3D        (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3222
3223         ctx.beginSection("GL_INVALID_VALUE is generated if xoffset + width > texture_width.");
3224         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 1, 0, 0, 0, 0, 4, 4);
3225         ctx.expectError(GL_INVALID_VALUE);
3226         ctx.endSection();
3227
3228         ctx.beginSection("GL_INVALID_VALUE is generated if yoffset + height > texture_height.");
3229         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 1, 0, 0, 0, 4, 4);
3230         ctx.expectError(GL_INVALID_VALUE);
3231         ctx.endSection();
3232
3233         ctx.beginSection("GL_INVALID_VALUE is generated if zoffset + 1 > texture_depth.");
3234         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 4, 0, 0, 4, 4);
3235         ctx.expectError(GL_INVALID_VALUE);
3236         ctx.endSection();
3237
3238         ctx.glDeleteTextures(1, &texture);
3239 }
3240
3241 void copytexsubimage3d_neg_width_height (NegativeTestContext& ctx)
3242 {
3243         GLuint texture = 0x1234;
3244         ctx.glGenTextures       (1, &texture);
3245         ctx.glBindTexture       (GL_TEXTURE_3D, texture);
3246         ctx.glTexImage3D        (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3247
3248         ctx.beginSection("GL_INVALID_VALUE is generated if width < 0.");
3249         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, -4, 4);
3250         ctx.expectError(GL_INVALID_VALUE);
3251         ctx.endSection();
3252
3253         ctx.beginSection("GL_INVALID_VALUE is generated if height < 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.glDeleteTextures(1, &texture);
3259 }
3260
3261 void copytexsubimage3d_incomplete_framebuffer (NegativeTestContext& ctx)
3262 {
3263         GLuint fbo = 0x1234;
3264         GLuint texture[2];
3265
3266         ctx.glGenTextures                       (2, texture);
3267         ctx.glBindTexture                       (GL_TEXTURE_3D, texture[0]);
3268         ctx.glTexImage3D                        (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3269         ctx.glBindTexture                       (GL_TEXTURE_2D_ARRAY, texture[1]);
3270         ctx.glTexImage3D                        (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
3271         ctx.glGenFramebuffers           (1, &fbo);
3272         ctx.glBindFramebuffer           (GL_READ_FRAMEBUFFER, fbo);
3273         ctx.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER);
3274
3275         ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
3276         ctx.glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, 4, 4);
3277         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
3278         ctx.glCopyTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 0, 0, 4, 4);
3279         ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
3280         ctx.endSection();
3281
3282         ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
3283         ctx.glDeleteFramebuffers(1, &fbo);
3284         ctx.glDeleteTextures(2, texture);
3285 }
3286
3287 // glCompressedTexImage3D
3288
3289 void compressedteximage3d (NegativeTestContext& ctx)
3290 {
3291         ctx.beginSection("GL_INVALID_ENUM is generated if target is invalid.");
3292         ctx.glCompressedTexImage3D(0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0, 0);
3293         ctx.expectError(GL_INVALID_ENUM);
3294         ctx.glCompressedTexImage3D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0, 0);
3295         ctx.expectError(GL_INVALID_ENUM);
3296         ctx.endSection();
3297
3298         ctx.beginSection("GL_INVALID_ENUM is generated if internalformat is not one of the specific compressed internal formats.");
3299         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 0, 0, 0, 0);
3300         ctx.expectError(GL_INVALID_ENUM);
3301         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA8, 0, 0, 0, 0, 0, 0);
3302         ctx.expectError(GL_INVALID_ENUM);
3303         ctx.endSection();
3304 }
3305
3306 void compressedteximage3d_neg_level (NegativeTestContext& ctx)
3307 {
3308         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
3309         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, -1, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0, 0);
3310         ctx.expectError(GL_INVALID_VALUE);
3311         ctx.endSection();
3312 }
3313
3314 void compressedteximage3d_max_level (NegativeTestContext& ctx)
3315 {
3316         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
3317         deUint32 log2MaxTextureSize = deLog2Floor32(ctx.getInteger(GL_MAX_TEXTURE_SIZE)) + 1;
3318         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, log2MaxTextureSize, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0, 0);
3319         ctx.expectError(GL_INVALID_VALUE);
3320         ctx.endSection();
3321 }
3322
3323 void compressedteximage3d_neg_width_height_depth (NegativeTestContext& ctx)
3324 {
3325         ctx.beginSection("GL_INVALID_VALUE is generated if width, height or depth is less than 0.");
3326         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0, 0, 0, 0, 0);
3327         ctx.expectError(GL_INVALID_VALUE);
3328         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, -1, 0, 0, 0, 0);
3329         ctx.expectError(GL_INVALID_VALUE);
3330         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, -1, 0, 0, 0);
3331         ctx.expectError(GL_INVALID_VALUE);
3332         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, -1, -1, 0, 0, 0);
3333         ctx.expectError(GL_INVALID_VALUE);
3334         ctx.endSection();
3335 }
3336
3337 void compressedteximage3d_max_width_height_depth (NegativeTestContext& ctx)
3338 {
3339         int maxTextureSize = ctx.getInteger(GL_MAX_TEXTURE_SIZE) + 1;
3340
3341         ctx.beginSection("GL_INVALID_VALUE is generated if width, height or depth is greater than GL_MAX_TEXTURE_SIZE.");
3342         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxTextureSize, 0, 0, 0, 0, 0);
3343         ctx.expectError(GL_INVALID_VALUE);
3344         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, maxTextureSize, 0, 0, 0, 0);
3345         ctx.expectError(GL_INVALID_VALUE);
3346         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, maxTextureSize, 0, 0, 0);
3347         ctx.expectError(GL_INVALID_VALUE);
3348         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxTextureSize, maxTextureSize, maxTextureSize, 0, 0, 0);
3349         ctx.expectError(GL_INVALID_VALUE);
3350         ctx.endSection();
3351 }
3352
3353 void compressedteximage3d_invalid_border (NegativeTestContext& ctx)
3354 {
3355         ctx.beginSection("GL_INVALID_VALUE is generated if border is not 0.");
3356         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, -1, 0, 0);
3357         ctx.expectError(GL_INVALID_VALUE);
3358         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 1, 0, 0);
3359         ctx.expectError(GL_INVALID_VALUE);
3360         ctx.endSection();
3361 }
3362
3363 void compressedteximage3d_invalid_size (NegativeTestContext& ctx)
3364 {
3365         ctx.beginSection("GL_INVALID_VALUE is generated if imageSize is not consistent with the format, dimensions, and contents of the specified compressed image data.");
3366         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, -1, 0);
3367         ctx.expectError(GL_INVALID_VALUE);
3368         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, 4*4*8, 0);
3369         ctx.expectError(GL_INVALID_VALUE);
3370         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGB8_ETC2, 16, 16, 1, 0, 4*4*16, 0);
3371         ctx.expectError(GL_INVALID_VALUE);
3372         ctx.glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_SIGNED_R11_EAC, 16, 16, 1, 0, 4*4*16, 0);
3373         ctx.expectError(GL_INVALID_VALUE);
3374         ctx.endSection();
3375 }
3376
3377 void compressedteximage3d_invalid_width_height (NegativeTestContext& ctx)
3378 {
3379         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3380         {
3381                 const int                               width           = 4;
3382                 const int                               height          = 6;
3383                 const int                               depth           = 6;
3384                 const int                               blockSize       = 16;
3385                 const int                               imageSize       = divRoundUp(width, 4) * divRoundUp(height, 4) * depth * blockSize;
3386                 std::vector<GLubyte>    data            (imageSize);
3387                 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_TEXTURE_CUBE_MAP_ARRAY and width and height are not equal.");
3388                 ctx.glCompressedTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_COMPRESSED_RGB8_ETC2, width, height, depth, 0, imageSize, &data[0]);
3389                 ctx.expectError(GL_INVALID_VALUE);
3390                 ctx.endSection();
3391         }
3392 }
3393
3394 void compressedteximage3d_invalid_buffer_target (NegativeTestContext& ctx)
3395 {
3396         deUint32                                buf = 0x1234;
3397         std::vector<GLubyte>    data(512);
3398
3399         ctx.glGenBuffers                        (1, &buf);
3400         ctx.glBindBuffer                        (GL_PIXEL_UNPACK_BUFFER, buf);
3401         ctx.glBufferData                        (GL_PIXEL_UNPACK_BUFFER, 64, &data[0], GL_DYNAMIC_COPY);
3402         ctx.expectError                         (GL_NO_ERROR);
3403
3404         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.");
3405         ctx.glMapBufferRange            (GL_PIXEL_UNPACK_BUFFER, 0, 64, GL_MAP_WRITE_BIT);
3406         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGB8_ETC2, 4, 4, 1, 0, etc2DataSize(4, 4), 0);
3407         ctx.expectError                         (GL_INVALID_OPERATION);
3408         ctx.glUnmapBuffer                       (GL_PIXEL_UNPACK_BUFFER);
3409         ctx.endSection();
3410
3411         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.");
3412         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGB8_ETC2, 16, 16, 1, 0, etc2DataSize(16, 16), 0);
3413         ctx.expectError                         (GL_INVALID_OPERATION);
3414         ctx.endSection();
3415
3416         ctx.glDeleteBuffers                     (1, &buf);
3417 }
3418
3419 // glCompressedTexSubImage3D
3420
3421 void compressedtexsubimage3d (NegativeTestContext& ctx)
3422 {
3423         ctx.beginSection("GL_INVALID_ENUM is generated if target is invalid.");
3424         ctx.glCompressedTexSubImage3D(0, 0, 0, 0, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3425         ctx.expectError(GL_INVALID_ENUM);
3426         ctx.endSection();
3427
3428         deUint32                                texture = 0x1234;
3429         ctx.glGenTextures                       (1, &texture);
3430         ctx.glBindTexture                       (GL_TEXTURE_2D_ARRAY, texture);
3431         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 1, 0, etc2EacDataSize(18, 18), 0);
3432         ctx.expectError                         (GL_NO_ERROR);
3433
3434         ctx.beginSection("GL_INVALID_OPERATION is generated if format does not match the internal format of the texture image being modified.");
3435         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 0, 0, 0, GL_COMPRESSED_RGB8_ETC2, 0, 0);
3436         ctx.expectError(GL_INVALID_OPERATION);
3437         ctx.endSection();
3438
3439         ctx.beginSection("GL_INVALID_OPERATION is generated if internalformat is an ETC2/EAC format and target is not GL_TEXTURE_2D_ARRAY.");
3440         ctx.glCompressedTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 18, 18, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(18, 18), 0);
3441         ctx.expectError(GL_INVALID_OPERATION);
3442         ctx.endSection();
3443
3444         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.");
3445         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 4, 0, 0, 10, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(10, 4), 0);
3446         ctx.expectError(GL_INVALID_OPERATION);
3447         ctx.endSection();
3448
3449         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.");
3450         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 4, 0, 4, 10, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 10), 0);
3451         ctx.expectError(GL_INVALID_OPERATION);
3452         ctx.endSection();
3453
3454         ctx.beginSection("For ETC2/EAC images GL_INVALID_OPERATION is generated if xoffset or yoffset is not a multiple of four.");
3455         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 1, 0, 0, 4, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
3456         ctx.expectError(GL_INVALID_OPERATION);
3457         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 1, 0, 4, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
3458         ctx.expectError(GL_INVALID_OPERATION);
3459         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 1, 1, 0, 4, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
3460         ctx.expectError(GL_INVALID_OPERATION);
3461         ctx.endSection();
3462
3463         ctx.glDeleteTextures            (1, &texture);
3464 }
3465
3466 void compressedtexsubimage3d_neg_level (NegativeTestContext& ctx)
3467 {
3468         deUint32                                texture = 0x1234;
3469         ctx.glGenTextures                       (1, &texture);
3470         ctx.glBindTexture                       (GL_TEXTURE_2D_ARRAY, texture);
3471         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, etc2EacDataSize(16, 16), 0);
3472         ctx.expectError                         (GL_NO_ERROR);
3473
3474         ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0.");
3475         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, -1, 0, 0, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3476         ctx.expectError(GL_INVALID_VALUE);
3477         ctx.endSection();
3478
3479         ctx.glDeleteTextures            (1, &texture);
3480 }
3481
3482 void compressedtexsubimage3d_max_level (NegativeTestContext& ctx)
3483 {
3484         deUint32                                texture = 0x1234;
3485         ctx.glGenTextures                       (1, &texture);
3486         ctx.glBindTexture                       (GL_TEXTURE_2D_ARRAY, texture);
3487         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, etc2EacDataSize(16, 16), 0);
3488         ctx.expectError                         (GL_NO_ERROR);
3489
3490         ctx.beginSection("GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
3491         deUint32 log2MaxTextureSize = deLog2Floor32(ctx.getInteger(GL_MAX_TEXTURE_SIZE)) + 1;
3492         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, log2MaxTextureSize, 0, 0, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3493         ctx.expectError(GL_INVALID_VALUE);
3494         ctx.endSection();
3495
3496         ctx.glDeleteTextures            (1, &texture);
3497 }
3498
3499 void compressedtexsubimage3d_neg_offset (NegativeTestContext& ctx)
3500 {
3501         deUint32                                texture = 0x1234;
3502         ctx.glGenTextures                       (1, &texture);
3503         ctx.glBindTexture                       (GL_TEXTURE_2D_ARRAY, texture);
3504         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, etc2EacDataSize(16, 16), 0);
3505         ctx.expectError                         (GL_NO_ERROR);
3506
3507         ctx.beginSection("GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if xoffset, yoffset or zoffset are negative.");
3508         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, -4, 0, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3509         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3510         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, -4, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3511         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3512         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, -4, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3513         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3514         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, -4, -4, -4, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3515         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3516         ctx.endSection();
3517
3518         ctx.glDeleteTextures            (1, &texture);
3519 }
3520
3521 void compressedtexsubimage3d_invalid_offset (NegativeTestContext& ctx)
3522 {
3523         deUint32                                texture = 0x1234;
3524         ctx.glGenTextures                       (1, &texture);
3525         ctx.glBindTexture                       (GL_TEXTURE_2D_ARRAY, texture);
3526         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 4, 4, 1, 0, etc2EacDataSize(4, 4), 0);
3527         ctx.expectError                         (GL_NO_ERROR);
3528
3529         ctx.beginSection("GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if xoffset + width > texture_width or yoffset + height > texture_height.");
3530
3531         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 12, 0, 0, 8, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(8, 4), 0);
3532         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3533         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 12, 0, 4, 8, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 8), 0);
3534         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3535         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 12, 4, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
3536         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3537         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 12, 12, 12, 8, 8, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(8, 8), 0);
3538         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3539         ctx.endSection();
3540
3541         ctx.glDeleteTextures            (1, &texture);
3542 }
3543
3544 void compressedtexsubimage3d_neg_width_height_depth (NegativeTestContext& ctx)
3545 {
3546         deUint32                                texture = 0x1234;
3547         ctx.glGenTextures                       (1, &texture);
3548         ctx.glBindTexture                       (GL_TEXTURE_2D_ARRAY, texture);
3549         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, etc2EacDataSize(16, 16), 0);
3550         ctx.expectError                         (GL_NO_ERROR);
3551
3552         ctx.beginSection("GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if width, height or depth are negative.");
3553         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, -4, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3554         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3555         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 0, -4, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3556         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3557         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 0, 0, -4, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3558         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3559         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, -4, -4, -4, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
3560         ctx.expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
3561         ctx.endSection();
3562
3563         ctx.glDeleteTextures            (1, &texture);
3564 }
3565
3566 void compressedtexsubimage3d_invalid_size (NegativeTestContext& ctx)
3567 {
3568         deUint32                                texture = 0x1234;
3569         ctx.glGenTextures                       (1, &texture);
3570         ctx.glBindTexture                       (GL_TEXTURE_2D_ARRAY, texture);
3571         ctx.glCompressedTexImage3D      (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, 4*4*16, 0);
3572         ctx.expectError                         (GL_NO_ERROR);
3573
3574         ctx.beginSection("GL_INVALID_VALUE is generated if imageSize is not consistent with the format, dimensions, and contents of the specified compressed image data.");
3575         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 16, 16, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0);
3576         ctx.expectError(GL_INVALID_VALUE);
3577
3578         ctx.glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 16, 16, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, 4*4*16-1, 0);
3579         ctx.expectError(GL_INVALID_VALUE);
3580         ctx.endSection();
3581
3582         ctx.glDeleteTextures            (1, &texture);
3583 }
3584
3585 void compressedtexsubimage3d_invalid_buffer_target (NegativeTestContext& ctx)
3586 {
3587         deUint32                                                buf = 0x1234;
3588         deUint32                                                texture = 0x1234;
3589         GLsizei                                                 bufferSize =  etc2EacDataSize(4, 4);
3590         std::vector<GLubyte>                    data(bufferSize);
3591
3592         ctx.glGenTextures                               (1, &texture);
3593         ctx.glBindTexture                               (GL_TEXTURE_2D_ARRAY, texture);
3594         ctx.glCompressedTexImage3D              (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, etc2EacDataSize(16, 16), 0);
3595         ctx.glGenBuffers                                (1, &buf);
3596         ctx.glBindBuffer                                (GL_PIXEL_UNPACK_BUFFER, buf);
3597         ctx.glBufferData                                (GL_PIXEL_UNPACK_BUFFER, bufferSize, &data[0], GL_DYNAMIC_COPY);
3598         ctx.expectError                                 (GL_NO_ERROR);
3599
3600         ctx.beginSection("GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and...");
3601         ctx.beginSection("...the buffer object's data store is currently mapped.");
3602         ctx.glMapBufferRange                    (GL_PIXEL_UNPACK_BUFFER, 0, bufferSize, GL_MAP_WRITE_BIT);
3603         ctx.glCompressedTexSubImage3D   (GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 4, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
3604         ctx.expectError                                 (GL_INVALID_OPERATION);
3605         ctx.glUnmapBuffer                               (GL_PIXEL_UNPACK_BUFFER);
3606         ctx.endSection();
3607
3608         ctx.beginSection("...the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
3609         ctx.glCompressedTexSubImage3D   (GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 16, 16, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(16, 16), 0);
3610         ctx.expectError                                 (GL_INVALID_OPERATION);
3611         ctx.endSection();
3612         ctx.endSection();
3613
3614         ctx.glDeleteBuffers                     (1, &buf);
3615         ctx.glDeleteTextures            (1, &texture);
3616 }
3617
3618 // glTexStorage2D
3619
3620 void texstorage2d (NegativeTestContext& ctx)
3621 {
3622         deUint32  textures[] = {0x1234, 0x1234};
3623
3624         ctx.glGenTextures(2, textures);
3625         ctx.glBindTexture(GL_TEXTURE_2D, textures[0]);
3626         ctx.expectError(GL_NO_ERROR);
3627
3628         ctx.beginSection("GL_INVALID_ENUM or GL_INVALID_VALUE is generated if internalformat is not a valid sized internal format.");
3629         ctx.glTexStorage2D(GL_TEXTURE_2D, 1, 0, 16, 16);
3630         ctx.expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
3631         ctx.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA_INTEGER, 16, 16);
3632         ctx.expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
3633         ctx.endSection();
3634
3635         ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the accepted target enumerants.");
3636         ctx.glTexStorage2D(0, 1, GL_RGBA8, 16, 16);
3637         ctx.expectError(GL_INVALID_ENUM);
3638         ctx.glTexStorage2D(GL_TEXTURE_3D, 1, GL_RGBA8, 16, 16);
3639         ctx.expectError(GL_INVALID_ENUM);
3640         ctx.glTexStorage2D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 16, 16);
3641         ctx.expectError(GL_INVALID_ENUM);
3642         ctx.endSection();
3643
3644         ctx.beginSection("GL_INVALID_VALUE is generated if width or height are less than 1.");
3645         ctx.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 0, 16);
3646         ctx.expectError(GL_INVALID_VALUE);
3647         ctx.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 16, 0);
3648         ctx.expectError(GL_INVALID_VALUE);
3649         ctx.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 0, 0);
3650         ctx.expectError(GL_INVALID_VALUE);
3651
3652         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
3653         {
3654                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP, textures[1]);
3655                 ctx.expectError(GL_NO_ERROR);
3656                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, 1, GL_RGBA8, 0, 16);
3657                 ctx.expectError(GL_INVALID_VALUE);
3658                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, 1, GL_RGBA8, 16, 0);
3659                 ctx.expectError(GL_INVALID_VALUE);
3660                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, 1, GL_RGBA8, 0, 0);
3661                 ctx.expectError(GL_INVALID_VALUE);
3662         }
3663         ctx.endSection();
3664
3665         ctx.glDeleteTextures(2, textures);
3666 }
3667
3668 void texstorage2d_invalid_binding (NegativeTestContext& ctx)
3669 {
3670         deUint32        textures[]      = {0x1234, 0x1234};
3671         deInt32         immutable       = 0x1234;
3672         const bool      isES32          = contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
3673
3674         ctx.beginSection("GL_INVALID_OPERATION is generated if the default texture object is curently bound to target.");
3675         ctx.glBindTexture(GL_TEXTURE_2D, 0);
3676         ctx.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 16, 16);
3677         ctx.expectError(GL_INVALID_OPERATION);
3678
3679         if (isES32)
3680         {
3681                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
3682                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, 1, GL_RGBA8, 16, 16);
3683                 ctx.expectError(GL_INVALID_OPERATION);
3684         }
3685         ctx.endSection();
3686
3687         ctx.glGenTextures(2, textures);
3688
3689         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.");
3690         ctx.glBindTexture(GL_TEXTURE_2D, textures[0]);
3691         ctx.glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3692         ctx.getLog() << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3693         ctx.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 16, 16);
3694         ctx.expectError(GL_NO_ERROR);
3695         ctx.glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3696         ctx.getLog() << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3697         ctx.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 16, 16);
3698         ctx.expectError(GL_INVALID_OPERATION);
3699
3700         if (isES32)
3701         {
3702                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP, textures[1]);
3703                 ctx.glGetTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3704                 ctx.getLog() << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3705                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, 1, GL_RGBA8, 16, 16);
3706                 ctx.expectError(GL_NO_ERROR);
3707                 ctx.glGetTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3708                 ctx.getLog() << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3709                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, 1, GL_RGBA8, 16, 16);
3710                 ctx.expectError(GL_INVALID_OPERATION);
3711         }
3712         ctx.endSection();
3713
3714         ctx.glDeleteTextures(2, textures);
3715 }
3716
3717 void texstorage2d_invalid_levels (NegativeTestContext& ctx)
3718 {
3719         deUint32        textures[]      = {0x1234, 0x1234};
3720         deUint32        log2MaxSize     = deLog2Floor32(deMax32(16, 16)) + 1 + 1;
3721         const bool      isES32          = contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
3722
3723         ctx.glGenTextures(2, textures);
3724         ctx.glBindTexture(GL_TEXTURE_2D, textures[0]);
3725
3726         if (isES32)
3727                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP, textures[1]);
3728
3729         ctx.expectError(GL_NO_ERROR);
3730
3731         ctx.beginSection("GL_INVALID_VALUE is generated if levels is less than 1.");
3732         ctx.glTexStorage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 16, 16);
3733         ctx.expectError(GL_INVALID_VALUE);
3734         ctx.glTexStorage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 0, 0);
3735         ctx.expectError(GL_INVALID_VALUE);
3736
3737         if (isES32)
3738         {
3739                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, 0, GL_RGBA8, 16, 16);
3740                 ctx.expectError(GL_INVALID_VALUE);
3741                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, 0, GL_RGBA8, 0, 0);
3742                 ctx.expectError(GL_INVALID_VALUE);
3743         }
3744         ctx.endSection();
3745
3746         ctx.beginSection("GL_INVALID_OPERATION is generated if levels is greater than floor(log_2(max(width, height))) + 1");
3747         ctx.glTexStorage2D(GL_TEXTURE_2D, log2MaxSize, GL_RGBA8, 16, 16);
3748         ctx.expectError(GL_INVALID_OPERATION);
3749
3750         if (isES32)
3751         {
3752                 ctx.glTexStorage2D(GL_TEXTURE_CUBE_MAP, log2MaxSize, GL_RGBA8, 16, 16);
3753                 ctx.expectError(GL_INVALID_OPERATION);
3754         }
3755         ctx.endSection();
3756
3757         ctx.glDeleteTextures(2, textures);
3758 }
3759
3760 // glTexStorage3D
3761
3762 void texstorage3d (NegativeTestContext& ctx)
3763 {
3764         deUint32 textures[] = {0x1234, 0x1234};
3765
3766         ctx.glGenTextures(2, textures);
3767         ctx.glBindTexture(GL_TEXTURE_3D, textures[0]);
3768         ctx.expectError(GL_NO_ERROR);
3769
3770         ctx.beginSection("GL_INVALID_ENUM or GL_INVALID_VALUE is generated if internalformat is not a valid sized internal format.");
3771         ctx.glTexStorage3D(GL_TEXTURE_3D, 1, 0, 4, 4, 4);
3772         ctx.expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
3773         ctx.glTexStorage3D(GL_TEXTURE_3D, 1, GL_RGBA_INTEGER, 4, 4, 4);
3774         ctx.expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
3775         ctx.endSection();
3776
3777         ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the accepted target enumerants.");
3778         ctx.glTexStorage3D(0, 1, GL_RGBA8, 4, 4, 4);
3779         ctx.expectError(GL_INVALID_ENUM);
3780         ctx.glTexStorage3D(GL_TEXTURE_CUBE_MAP, 1, GL_RGBA8, 4, 4, 4);
3781         ctx.expectError(GL_INVALID_ENUM);
3782         ctx.glTexStorage3D(GL_TEXTURE_2D, 1, GL_RGBA8, 4, 4, 4);
3783         ctx.expectError(GL_INVALID_ENUM);
3784         ctx.endSection();
3785
3786         ctx.beginSection("GL_INVALID_VALUE is generated if width, height or depth are less than 1.");
3787         ctx.glTexStorage3D(GL_TEXTURE_3D, 1, GL_RGBA8, 0, 4, 4);
3788         ctx.expectError(GL_INVALID_VALUE);
3789         ctx.glTexStorage3D(GL_TEXTURE_3D, 1, GL_RGBA8, 4, 0, 4);
3790         ctx.expectError(GL_INVALID_VALUE);
3791         ctx.glTexStorage3D(GL_TEXTURE_3D, 1, GL_RGBA8, 4, 4, 0);
3792         ctx.expectError(GL_INVALID_VALUE);
3793         ctx.glTexStorage3D(GL_TEXTURE_3D, 1, GL_RGBA8, 0, 0, 0);
3794         ctx.expectError(GL_INVALID_VALUE);
3795
3796         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3797         {
3798                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, textures[1]);
3799                 ctx.expectError(GL_NO_ERROR);
3800                 ctx.glTexStorage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA8, 0, 4, 4);
3801                 ctx.expectError(GL_INVALID_VALUE);
3802                 ctx.glTexStorage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA8, 4, 0, 4);
3803                 ctx.expectError(GL_INVALID_VALUE);
3804                 ctx.glTexStorage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA8, 4, 4, 0);
3805                 ctx.expectError(GL_INVALID_VALUE);
3806                 ctx.glTexStorage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA8, 0, 0, 0);
3807                 ctx.expectError(GL_INVALID_VALUE);
3808         }
3809         ctx.endSection();
3810
3811         ctx.glDeleteTextures(2, textures);
3812 }
3813
3814 void texstorage3d_invalid_binding (NegativeTestContext& ctx)
3815 {
3816         deUint32        textures[]      = {0x1234, 0x1234};
3817         deInt32         immutable       = 0x1234;
3818
3819         ctx.beginSection("GL_INVALID_OPERATION is generated if the default texture object is curently bound to target.");
3820         ctx.glBindTexture       (GL_TEXTURE_3D, 0);
3821         ctx.glTexStorage3D      (GL_TEXTURE_3D, 1, GL_RGBA8, 4, 4, 4);
3822         ctx.expectError         (GL_INVALID_OPERATION);
3823
3824         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3825         {
3826                 ctx.glBindTexture       (GL_TEXTURE_CUBE_MAP_ARRAY, 0);
3827                 ctx.glTexStorage3D      (GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA8, 4, 4, 6);
3828                 ctx.expectError         (GL_INVALID_OPERATION);
3829         }
3830         ctx.endSection();
3831
3832         ctx.glGenTextures       (2, textures);
3833
3834         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.");
3835         ctx.glBindTexture       (GL_TEXTURE_3D, textures[0]);
3836         ctx.glGetTexParameteriv(GL_TEXTURE_3D, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3837         ctx.getLog() << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3838         ctx.glTexStorage3D      (GL_TEXTURE_3D, 1, GL_RGBA8, 4, 4, 4);
3839         ctx.expectError         (GL_NO_ERROR);
3840         ctx.glGetTexParameteriv(GL_TEXTURE_3D, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3841         ctx.getLog() << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3842         ctx.glTexStorage3D      (GL_TEXTURE_3D, 1, GL_RGBA8, 4, 4, 4);
3843         ctx.expectError         (GL_INVALID_OPERATION);
3844
3845         if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3846         {
3847                 ctx.glBindTexture       (GL_TEXTURE_CUBE_MAP_ARRAY, textures[1]);
3848                 ctx.glGetTexParameteriv(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3849                 ctx.getLog() << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3850                 ctx.glTexStorage3D      (GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA8, 4, 4, 6);
3851                 ctx.expectError         (GL_NO_ERROR);
3852                 ctx.glGetTexParameteriv(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3853                 ctx.getLog() << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3854                 ctx.glTexStorage3D      (GL_TEXTURE_CUBE_MAP_ARRAY, 1, GL_RGBA8, 4, 4, 6);
3855                 ctx.expectError         (GL_INVALID_OPERATION);
3856         }
3857         ctx.endSection();
3858
3859         ctx.glDeleteTextures(2, textures);
3860 }
3861
3862 void texstorage3d_invalid_levels (NegativeTestContext& ctx)
3863 {
3864         deUint32        textures[]      = {0x1234, 0x1234};
3865         deUint32        log2MaxSize     = deLog2Floor32(8) + 1 + 1;
3866         const bool      isES32          = contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
3867         ctx.glGenTextures(2, textures);
3868         ctx.glBindTexture(GL_TEXTURE_3D, textures[0]);
3869
3870         ctx.beginSection("GL_INVALID_VALUE is generated if levels is less than 1.");
3871         ctx.glTexStorage3D(GL_TEXTURE_3D, 0, GL_RGBA8, 4, 4, 4);
3872         ctx.expectError(GL_INVALID_VALUE);
3873         ctx.glTexStorage3D(GL_TEXTURE_3D, 0, GL_RGBA8, 0, 0, 0);
3874         ctx.expectError(GL_INVALID_VALUE);
3875
3876         if (isES32 || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3877         {
3878                 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, textures[1]);
3879                 ctx.glTexStorage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA8, 4, 4, 6);
3880                 ctx.expectError(GL_INVALID_VALUE);
3881                 ctx.glTexStorage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA8, 0, 0, 6);
3882                 ctx.expectError(GL_INVALID_VALUE);
3883         }
3884         ctx.endSection();
3885
3886         ctx.beginSection("GL_INVALID_OPERATION is generated if levels is greater than floor(log_2(max(width, height, depth))) + 1");
3887         ctx.glTexStorage3D      (GL_TEXTURE_3D, log2MaxSize, GL_RGBA8, 8, 2, 2);
3888         ctx.expectError         (GL_INVALID_OPERATION);
3889         ctx.glTexStorage3D      (GL_TEXTURE_3D, log2MaxSize, GL_RGBA8, 2, 8, 2);
3890         ctx.expectError         (GL_INVALID_OPERATION);
3891         ctx.glTexStorage3D      (GL_TEXTURE_3D, log2MaxSize, GL_RGBA8, 2, 2, 8);
3892         ctx.expectError         (GL_INVALID_OPERATION);
3893         ctx.glTexStorage3D      (GL_TEXTURE_3D, log2MaxSize, GL_RGBA8, 8, 8, 8);
3894         ctx.expectError         (GL_INVALID_OPERATION);
3895
3896         if (isES32 || ctx.getContextInfo().isExtensionSupported("GL_OES_texture_cube_map_array"))
3897         {
3898                 ctx.glTexStorage3D      (GL_TEXTURE_CUBE_MAP_ARRAY, log2MaxSize, GL_RGBA8, 2, 2, 6);
3899                 ctx.expectError         (GL_INVALID_OPERATION);
3900                 ctx.glTexStorage3D      (GL_TEXTURE_CUBE_MAP_ARRAY, log2MaxSize, GL_RGBA8, 8, 8, 6);
3901                 ctx.expectError         (GL_INVALID_OPERATION);
3902         }
3903         ctx.endSection();
3904
3905         ctx.glDeleteTextures(2, textures);
3906 }
3907
3908 std::vector<FunctionContainer> getNegativeTextureApiTestFunctions()
3909 {
3910         FunctionContainer funcs[] =
3911         {
3912                 {activetexture,                                                                 "activetexture",                                                                        "Invalid glActiveTexture() usage"                  },
3913                 {bindtexture,                                                                   "bindtexture",                                                                          "Invalid glBindTexture() usage"                    },
3914                 {compressedteximage2d_invalid_target,                   "compressedteximage2d_invalid_target",                          "Invalid glCompressedTexImage2D() usage"   },
3915                 {compressedteximage2d_invalid_format,                   "compressedteximage2d_invalid_format",                          "Invalid glCompressedTexImage2D() usage"   },
3916                 {compressedteximage2d_neg_level,                                "compressedteximage2d_neg_level",                                       "Invalid glCompressedTexImage2D() usage"   },
3917                 {compressedteximage2d_max_level,                                "compressedteximage2d_max_level",                                       "Invalid glCompressedTexImage2D() usage"   },
3918                 {compressedteximage2d_neg_width_height,                 "compressedteximage2d_neg_width_height",                        "Invalid glCompressedTexImage2D() usage"   },
3919                 {compressedteximage2d_max_width_height,                 "compressedteximage2d_max_width_height",                        "Invalid glCompressedTexImage2D() usage"   },
3920                 {compressedteximage2d_invalid_border,                   "compressedteximage2d_invalid_border",                          "Invalid glCompressedTexImage2D() usage"   },
3921                 {compressedteximage2d_invalid_size,                             "compressedteximage2d_invalid_size",                            "Invalid glCompressedTexImage2D() usage"   },
3922                 {compressedteximage2d_neg_size,                                 "compressedteximage2d_neg_size",                                        "Invalid glCompressedTexImage2D() usage"   },
3923                 {compressedteximage2d_invalid_width_height,             "compressedteximage2d_invalid_width_height",            "Invalid glCompressedTexImage2D() usage"   },
3924                 {compressedteximage2d_invalid_buffer_target,    "compressedteximage2d_invalid_buffer_target",           "Invalid glCompressedTexImage2D() usage"   },
3925                 {copyteximage2d_invalid_target,                                 "copyteximage2d_invalid_target",                                        "Invalid glCopyTexImage2D() usage"                 },
3926                 {copyteximage2d_invalid_format,                                 "copyteximage2d_invalid_format",                                        "Invalid glCopyTexImage2D() usage"                 },
3927                 {copyteximage2d_inequal_width_height_cube,              "copyteximage2d_inequal_width_height_cube",                     "Invalid glCopyTexImage2D() usage"                 },
3928                 {copyteximage2d_neg_level,                                              "copyteximage2d_neg_level",                                                     "Invalid glCopyTexImage2D() usage"                 },
3929                 {copyteximage2d_max_level,                                              "copyteximage2d_max_level",                                                     "Invalid glCopyTexImage2D() usage"                 },
3930                 {copyteximage2d_neg_width_height,                               "copyteximage2d_neg_width_height",                                      "Invalid glCopyTexImage2D() usage"                 },
3931                 {copyteximage2d_max_width_height,                               "copyteximage2d_max_width_height",                                      "Invalid glCopyTexImage2D() usage"                 },
3932                 {copyteximage2d_invalid_border,                                 "copyteximage2d_invalid_border",                                        "Invalid glCopyTexImage2D() usage"                 },
3933                 {copyteximage2d_incomplete_framebuffer,                 "copyteximage2d_incomplete_framebuffer",                        "Invalid glCopyTexImage2D() usage"                 },
3934                 {copytexsubimage2d_invalid_target,                              "copytexsubimage2d_invalid_target",                                     "Invalid glCopyTexSubImage2D() usage"      },
3935                 {copytexsubimage2d_read_buffer_is_none,                 "copytexsubimage2d_read_buffer_is_none",                        "Invalid glCopyTexSubImage2D() usage"      },
3936                 {copytexsubimage2d_texture_internalformat,              "copytexsubimage2d_texture_internalformat",                     "Invalid glCopyTexSubImage2D() usage"      },
3937                 {copytexsubimage2d_neg_level,                                   "copytexsubimage2d_neg_level",                                          "Invalid glCopyTexSubImage2D() usage"      },
3938                 {copytexsubimage2d_max_level,                                   "copytexsubimage2d_max_level",                                          "Invalid glCopyTexSubImage2D() usage"      },
3939                 {copytexsubimage2d_neg_offset,                                  "copytexsubimage2d_neg_offset",                                         "Invalid glCopyTexSubImage2D() usage"      },
3940                 {copytexsubimage2d_invalid_offset,                              "copytexsubimage2d_invalid_offset",                                     "Invalid glCopyTexSubImage2D() usage"      },
3941                 {copytexsubimage2d_neg_width_height,                    "copytexsubimage2d_neg_width_height",                           "Invalid glCopyTexSubImage2D() usage"      },
3942                 {copytexsubimage2d_incomplete_framebuffer,              "copytexsubimage2d_incomplete_framebuffer",                     "Invalid glCopyTexSubImage2D() usage"      },
3943                 {deletetextures,                                                                "deletetextures",                                                                       "Invalid glDeleteTextures() usage"                 },
3944                 {generatemipmap,                                                                "generatemipmap",                                                                       "Invalid glGenerateMipmap() usage"                 },
3945                 {gentextures,                                                                   "gentextures",                                                                          "Invalid glGenTextures() usage"                    },
3946                 {pixelstorei,                                                                   "pixelstorei",                                                                          "Invalid glPixelStorei() usage"                    },
3947                 {teximage2d,                                                                    "teximage2d",                                                                           "Invalid glTexImage2D() usage"                     },
3948                 {teximage2d_inequal_width_height_cube,                  "teximage2d_inequal_width_height_cube",                         "Invalid glTexImage2D() usage"                     },
3949                 {teximage2d_neg_level,                                                  "teximage2d_neg_level",                                                         "Invalid glTexImage2D() usage"                     },
3950                 {teximage2d_max_level,                                                  "teximage2d_max_level",                                                         "Invalid glTexImage2D() usage"                     },
3951                 {teximage2d_neg_width_height,                                   "teximage2d_neg_width_height",                                          "Invalid glTexImage2D() usage"                     },
3952                 {teximage2d_max_width_height,                                   "teximage2d_max_width_height",                                          "Invalid glTexImage2D() usage"                     },
3953                 {teximage2d_invalid_border,                                             "teximage2d_invalid_border",                                            "Invalid glTexImage2D() usage"                     },
3954                 {teximage2d_invalid_buffer_target,                              "teximage2d_invalid_buffer_target",                                     "Invalid glTexImage2D() usage"                     },
3955                 {texsubimage2d,                                                                 "texsubimage2d",                                                                        "Invalid glTexSubImage2D() usage"                  },
3956                 {texsubimage2d_neg_level,                                               "texsubimage2d_neg_level",                                                      "Invalid glTexSubImage2D() usage"                  },
3957                 {texsubimage2d_max_level,                                               "texsubimage2d_max_level",                                                      "Invalid glTexSubImage2D() usage"                  },
3958                 {texsubimage2d_neg_offset,                                              "texsubimage2d_neg_offset",                                                     "Invalid glTexSubImage2D() usage"                  },
3959                 {texsubimage2d_invalid_offset,                                  "texsubimage2d_invalid_offset",                                         "Invalid glTexSubImage2D() usage"                  },
3960                 {texsubimage2d_neg_width_height,                                "texsubimage2d_neg_width_height",                                       "Invalid glTexSubImage2D() usage"                  },
3961                 {texsubimage2d_invalid_buffer_target,                   "texsubimage2d_invalid_buffer_target",                          "Invalid glTexSubImage2D() usage"                  },
3962                 {texparameteri,                                                                 "texparameteri",                                                                        "Invalid glTexParameteri() usage"                  },
3963                 {texparameterf,                                                                 "texparameterf",                                                                        "Invalid glTexParameterf() usage"                  },
3964                 {texparameteriv,                                                                "texparameteriv",                                                                       "Invalid glTexParameteriv() usage"                 },
3965                 {texparameterfv,                                                                "texparameterfv",                                                                       "Invalid glTexParameterfv() usage"                 },
3966                 {texparameterIiv,                                                               "texparameterIiv",                                                                      "Invalid glTexParameterIiv() usage"                },
3967                 {texparameterIuiv,                                                              "texparameterIuiv",                                                                     "Invalid glTexParameterIuiv() usage"       },
3968                 {compressedtexsubimage2d,                                               "compressedtexsubimage2d",                                                      "Invalid glCompressedTexSubImage2D() usage"},
3969                 {compressedtexsubimage2d_neg_level,                             "compressedtexsubimage2d_neg_level",                            "Invalid glCompressedTexSubImage2D() usage"},
3970                 {compressedtexsubimage2d_max_level,                             "compressedtexsubimage2d_max_level",                            "Invalid glCompressedTexSubImage2D() usage"},
3971                 {compressedtexsubimage2d_neg_offset,                    "compressedtexsubimage2d_neg_offset",                           "Invalid glCompressedTexSubImage2D() usage"},
3972                 {compressedtexsubimage2d_invalid_offset,                "compressedtexsubimage2d_invalid_offset",                       "Invalid glCompressedTexSubImage2D() usage"},
3973                 {compressedtexsubimage2d_neg_width_height,              "compressedtexsubimage2d_neg_width_height",                     "Invalid glCompressedTexSubImage2D() usage"},
3974                 {compressedtexsubimage2d_invalid_size,                  "compressedtexsubimage2d_invalid_size",                         "Invalid glCompressedTexImage2D() usage"   },
3975                 {compressedtexsubimage2d_invalid_buffer_target, "compressedtexsubimage2d_invalid_buffer_target",        "Invalid glCompressedTexSubImage2D() usage"},
3976                 {teximage3d,                                                                    "teximage3d",                                                                           "Invalid glTexImage3D() usage"                     },
3977                 {teximage3d_neg_level,                                                  "teximage3d_neg_level",                                                         "Invalid glTexImage3D() usage"                     },
3978                 {teximage3d_max_level,                                                  "teximage3d_max_level",                                                         "Invalid glTexImage3D() usage"                     },
3979                 {teximage3d_neg_width_height_depth,                             "teximage3d_neg_width_height_depth",                            "Invalid glTexImage3D() usage"                     },
3980                 {teximage3d_max_width_height_depth,                             "teximage3d_max_width_height_depth",                            "Invalid glTexImage3D() usage"                     },
3981                 {teximage3d_invalid_border,                                             "teximage3d_invalid_border",                                            "Invalid glTexImage3D() usage"                     },
3982                 {teximage3d_invalid_buffer_target,                              "teximage3d_invalid_buffer_target",                                     "Invalid glTexImage3D() usage"                     },
3983                 {texsubimage3d,                                                                 "texsubimage3d",                                                                        "Invalid glTexSubImage3D() usage"                  },
3984                 {texsubimage3d_neg_level,                                               "texsubimage3d_neg_level",                                                      "Invalid glTexSubImage3D() usage"                  },
3985                 {texsubimage3d_max_level,                                               "texsubimage3d_max_level",                                                      "Invalid glTexSubImage3D() usage"                  },
3986                 {texsubimage3d_neg_offset,                                              "texsubimage3d_neg_offset",                                                     "Invalid glTexSubImage3D() usage"                  },
3987                 {texsubimage3d_invalid_offset,                                  "texsubimage3d_invalid_offset",                                         "Invalid glTexSubImage3D() usage"                  },
3988                 {texsubimage3d_neg_width_height,                                "texsubimage3d_neg_width_height",                                       "Invalid glTexSubImage3D() usage"                  },
3989                 {texsubimage3d_invalid_buffer_target,                   "texsubimage3d_invalid_buffer_target",                          "Invalid glTexSubImage3D() usage"                  },
3990                 {copytexsubimage3d,                                                             "copytexsubimage3d",                                                            "Invalid glCopyTexSubImage3D() usage"      },
3991                 {copytexsubimage3d_neg_level,                                   "copytexsubimage3d_neg_level",                                          "Invalid glCopyTexSubImage3D() usage"      },
3992                 {copytexsubimage3d_max_level,                                   "copytexsubimage3d_max_level",                                          "Invalid glCopyTexSubImage3D() usage"      },
3993                 {copytexsubimage3d_neg_offset,                                  "copytexsubimage3d_neg_offset",                                         "Invalid glCopyTexSubImage3D() usage"      },
3994                 {copytexsubimage3d_invalid_offset,                              "copytexsubimage3d_invalid_offset",                                     "Invalid glCopyTexSubImage3D() usage"      },
3995                 {copytexsubimage3d_neg_width_height,                    "copytexsubimage3d_neg_width_height",                           "Invalid glCopyTexSubImage3D() usage"      },
3996                 {copytexsubimage3d_incomplete_framebuffer,              "copytexsubimage3d_incomplete_framebuffer",                     "Invalid glCopyTexSubImage3D() usage"      },
3997                 {compressedteximage3d,                                                  "compressedteximage3d",                                                         "Invalid glCompressedTexImage3D() usage"   },
3998                 {compressedteximage3d_neg_level,                                "compressedteximage3d_neg_level",                                       "Invalid glCompressedTexImage3D() usage"   },
3999                 {compressedteximage3d_max_level,                                "compressedteximage3d_max_level",                                       "Invalid glCompressedTexImage3D() usage"   },
4000                 {compressedteximage3d_neg_width_height_depth,   "compressedteximage3d_neg_width_height_depth",          "Invalid glCompressedTexImage3D() usage"   },
4001                 {compressedteximage3d_max_width_height_depth,   "compressedteximage3d_max_width_height_depth",          "Invalid glCompressedTexImage3D() usage"   },
4002                 {compressedteximage3d_invalid_border,                   "compressedteximage3d_invalid_border",                          "Invalid glCompressedTexImage3D() usage"   },
4003                 {compressedteximage3d_invalid_size,                             "compressedteximage3d_invalid_size",                            "Invalid glCompressedTexImage3D() usage"   },
4004                 {compressedteximage3d_invalid_width_height,             "compressedteximage3d_invalid_width_height",            "Invalid glCompressedTexImage3D() usage"   },
4005                 {compressedteximage3d_invalid_buffer_target,    "compressedteximage3d_invalid_buffer_target",           "Invalid glCompressedTexImage3D() usage"   },
4006                 {compressedtexsubimage3d,                                               "compressedtexsubimage3d",                                                      "Invalid glCompressedTexSubImage3D() usage"},
4007                 {compressedtexsubimage3d_neg_level,                             "compressedtexsubimage3d_neg_level",                            "Invalid glCompressedTexSubImage3D() usage"},
4008                 {compressedtexsubimage3d_max_level,                             "compressedtexsubimage3d_max_level",                            "Invalid glCompressedTexSubImage3D() usage"},
4009                 {compressedtexsubimage3d_neg_offset,                    "compressedtexsubimage3d_neg_offset",                           "Invalid glCompressedTexSubImage3D() usage"},
4010                 {compressedtexsubimage3d_invalid_offset,                "compressedtexsubimage3d_invalid_offset",                       "Invalid glCompressedTexSubImage3D() usage"},
4011                 {compressedtexsubimage3d_neg_width_height_depth,"compressedtexsubimage3d_neg_width_height_depth",       "Invalid glCompressedTexSubImage3D() usage"},
4012                 {compressedtexsubimage3d_invalid_size,                  "compressedtexsubimage3d_invalid_size",                         "Invalid glCompressedTexSubImage3D() usage"},
4013                 {compressedtexsubimage3d_invalid_buffer_target, "compressedtexsubimage3d_invalid_buffer_target",        "Invalid glCompressedTexSubImage3D() usage"},
4014                 {texstorage2d,                                                                  "texstorage2d",                                                                         "Invalid glTexStorage2D() usage"                   },
4015                 {texstorage2d_invalid_binding,                                  "texstorage2d_invalid_binding",                                         "Invalid glTexStorage2D() usage"                   },
4016                 {texstorage2d_invalid_levels,                                   "texstorage2d_invalid_levels",                                          "Invalid glTexStorage2D() usage"                   },
4017                 {texstorage3d,                                                                  "texstorage3d",                                                                         "Invalid glTexStorage3D() usage"                   },
4018                 {texstorage3d_invalid_binding,                                  "texstorage3d_invalid_binding",                                         "Invalid glTexStorage3D() usage"                   },
4019                 {texstorage3d_invalid_levels,                                   "texstorage3d_invalid_levels",                                          "Invalid glTexStorage3D() usage"                   },
4020         };
4021
4022         return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
4023 }
4024
4025 } // NegativeTestShared
4026 } // Functional
4027 } // gles31
4028 } // deqp