modules/gles3/functional/es3fNegativeTextureApiTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.0 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Negative Texture API tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es3fNegativeTextureApiTests.hpp"
  25 #include "es3fApiCase.hpp"
  26 #include "gluContextInfo.hpp"
  27 #include "tcuFormatUtil.hpp"
  28 #include "gluTextureUtil.hpp"
  29
  30 #include <vector>
  31 #include <algorithm>
  32
  33 #include "glwDefs.hpp"
  34 #include "glwEnums.hpp"
  35
  36 using namespace glw; // GL types
  37
  38 namespace deqp
  39 {
  40 namespace gles3
  41 {
  42 namespace Functional
  43 {
  44
  45 using tcu::TestLog;
  46 using tcu::CompressedTexFormat;
  47 using tcu::getBlockSize;
  48 using tcu::getBlockPixelSize;
  49 using tcu::IVec3;
  50 using glu::mapGLCompressedTexFormat;
  51 using std::vector;
  52
  53 static inline int divRoundUp (int a, int b)
  54 {
  55         return a/b + (a%b != 0 ? 1 : 0);
  56 }
  57
  58 static inline int etc2DataSize (int width, int height)
  59 {
  60         return (int)(divRoundUp(width, 4) * divRoundUp(height, 4) * sizeof(deUint64));
  61 }
  62
  63 static inline int etc2EacDataSize (int width, int height)
  64 {
  65         return 2 * etc2DataSize(width, height);
  66 }
  67
  68 static const GLuint s_astcFormats[] =
  69 {
  70         GL_COMPRESSED_RGBA_ASTC_4x4_KHR,
  71         GL_COMPRESSED_RGBA_ASTC_5x4_KHR,
  72         GL_COMPRESSED_RGBA_ASTC_5x5_KHR,
  73         GL_COMPRESSED_RGBA_ASTC_6x5_KHR,
  74         GL_COMPRESSED_RGBA_ASTC_6x6_KHR,
  75         GL_COMPRESSED_RGBA_ASTC_8x5_KHR,
  76         GL_COMPRESSED_RGBA_ASTC_8x6_KHR,
  77         GL_COMPRESSED_RGBA_ASTC_8x8_KHR,
  78         GL_COMPRESSED_RGBA_ASTC_10x5_KHR,
  79         GL_COMPRESSED_RGBA_ASTC_10x6_KHR,
  80         GL_COMPRESSED_RGBA_ASTC_10x8_KHR,
  81         GL_COMPRESSED_RGBA_ASTC_10x10_KHR,
  82         GL_COMPRESSED_RGBA_ASTC_12x10_KHR,
  83         GL_COMPRESSED_RGBA_ASTC_12x12_KHR,
  84         GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
  85         GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR,
  86         GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
  87         GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
  88         GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
  89         GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
  90         GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
  91         GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
  92         GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
  93         GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
  94         GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
  95         GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
  96         GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
  97         GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR
  98 };
  99
 100 static deUint32 cubeFaceToGLFace (tcu::CubeFace face)
 101 {
 102         switch (face)
 103         {
 104                 case tcu::CUBEFACE_NEGATIVE_X: return GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
 105                 case tcu::CUBEFACE_POSITIVE_X: return GL_TEXTURE_CUBE_MAP_POSITIVE_X;
 106                 case tcu::CUBEFACE_NEGATIVE_Y: return GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
 107                 case tcu::CUBEFACE_POSITIVE_Y: return GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
 108                 case tcu::CUBEFACE_NEGATIVE_Z: return GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
 109                 case tcu::CUBEFACE_POSITIVE_Z: return GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
 110                 default:
 111                         DE_ASSERT(DE_FALSE);
 112                         return GL_NONE;
 113         }
 114 }
 115
 116 #define FOR_CUBE_FACES(FACE_GL_VAR, BODY)                                                                                               \
 117         do                                                                                                                                                                      \
 118         {                                                                                                                                                                       \
 119                 for (int faceIterTcu = 0; faceIterTcu < tcu::CUBEFACE_LAST; faceIterTcu++)              \
 120                 {                                                                                                                                                               \
 121                         const GLenum FACE_GL_VAR = cubeFaceToGLFace((tcu::CubeFace)faceIterTcu);        \
 122                         BODY                                                                                                                                            \
 123                 }                                                                                                                                                               \
 124         } while (false)
 125
 126 NegativeTextureApiTests::NegativeTextureApiTests (Context& context)
 127         : TestCaseGroup(context, "texture", "Negative Texture API Cases")
 128 {
 129 }
 130
 131 NegativeTextureApiTests::~NegativeTextureApiTests (void)
 132 {
 133 }
 134
 135 void NegativeTextureApiTests::init (void)
 136 {
 137         // glActiveTexture
 138
 139         ES3F_ADD_API_CASE(activetexture, "Invalid glActiveTexture() usage",
 140                 {
 141                         m_log << TestLog::Section("", "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).");
 142                         glActiveTexture(-1);
 143                         expectError(GL_INVALID_ENUM);
 144                         int numMaxTextureUnits = m_context.getContextInfo().getInt(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS);
 145                         glActiveTexture(GL_TEXTURE0 + numMaxTextureUnits);
 146                         expectError(GL_INVALID_ENUM);
 147                         m_log << TestLog::EndSection;
 148                 });
 149
 150         // glBindTexture
 151
 152         ES3F_ADD_API_CASE(bindtexture, "Invalid glBindTexture() usage",
 153                 {
 154                         GLuint texture[2];
 155                         glGenTextures(2, texture);
 156
 157                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not one of the allowable values.");
 158                         glBindTexture(0, 1);
 159                         expectError(GL_INVALID_ENUM);
 160                         glBindTexture(GL_FRAMEBUFFER, 1);
 161                         expectError(GL_INVALID_ENUM);
 162                         m_log << TestLog::EndSection;
 163
 164                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if texture was previously created with a target that doesn't match that of target.");
 165                         glBindTexture(GL_TEXTURE_2D, texture[0]);
 166                         expectError(GL_NO_ERROR);
 167                         glBindTexture(GL_TEXTURE_CUBE_MAP, texture[0]);
 168                         expectError(GL_INVALID_OPERATION);
 169                         glBindTexture(GL_TEXTURE_3D, texture[0]);
 170                         expectError(GL_INVALID_OPERATION);
 171                         glBindTexture(GL_TEXTURE_2D_ARRAY, texture[0]);
 172                         expectError(GL_INVALID_OPERATION);
 173
 174                         glBindTexture(GL_TEXTURE_CUBE_MAP, texture[1]);
 175                         expectError(GL_NO_ERROR);
 176                         glBindTexture(GL_TEXTURE_2D, texture[1]);
 177                         expectError(GL_INVALID_OPERATION);
 178                         glBindTexture(GL_TEXTURE_3D, texture[1]);
 179                         expectError(GL_INVALID_OPERATION);
 180                         glBindTexture(GL_TEXTURE_2D_ARRAY, texture[1]);
 181                         expectError(GL_INVALID_OPERATION);
 182                         m_log << TestLog::EndSection;
 183
 184                         glDeleteTextures(2, texture);
 185                 });
 186
 187         // glCompressedTexImage2D
 188
 189         ES3F_ADD_API_CASE(compressedteximage2d_invalid_target, "Invalid glCompressedTexImage2D() usage",
 190                 {
 191                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is invalid.");
 192                         glCompressedTexImage2D(0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 193                         expectError(GL_INVALID_ENUM);
 194                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 195                         expectError(GL_INVALID_ENUM);
 196                         m_log << TestLog::EndSection;
 197                 });
 198         ES3F_ADD_API_CASE(compressedteximage2d_invalid_format, "Invalid glCompressedTexImage2D() usage",
 199                 {
 200                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if internalformat is not a supported format returned in GL_COMPRESSED_TEXTURE_FORMATS.");
 201                         glCompressedTexImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 0);
 202                         expectError(GL_INVALID_ENUM);
 203                         glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 0, 0, 0);
 204                         expectError(GL_INVALID_ENUM);
 205                         glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 0, 0, 0, 0, 0);
 206                         expectError(GL_INVALID_ENUM);
 207                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, 0, 0, 0, 0, 0, 0);
 208                         expectError(GL_INVALID_ENUM);
 209                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, 0, 0, 0, 0, 0, 0);
 210                         expectError(GL_INVALID_ENUM);
 211                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, 0, 0, 0, 0, 0, 0);
 212                         expectError(GL_INVALID_ENUM);
 213                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, 0, 0, 0, 0, 0, 0);
 214                         expectError(GL_INVALID_ENUM);
 215                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, 0, 0, 0, 0, 0, 0);
 216                         expectError(GL_INVALID_ENUM);
 217                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, 0, 0, 0, 0, 0, 0);
 218                         expectError(GL_INVALID_ENUM);
 219                         m_log << TestLog::EndSection;
 220                 });
 221         ES3F_ADD_API_CASE(compressedteximage2d_neg_level, "Invalid glCompressedTexImage2D() usage",
 222                 {
 223                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
 224                         glCompressedTexImage2D(GL_TEXTURE_2D, -1, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 225                         expectError(GL_INVALID_VALUE);
 226                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, -1, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 227                         expectError(GL_INVALID_VALUE);
 228                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, -1, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 229                         expectError(GL_INVALID_VALUE);
 230                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, -1, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 231                         expectError(GL_INVALID_VALUE);
 232                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, -1, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 233                         expectError(GL_INVALID_VALUE);
 234                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, -1, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 235                         expectError(GL_INVALID_VALUE);
 236                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, -1, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
 237                         expectError(GL_INVALID_VALUE);
 238                         m_log << TestLog::EndSection;
 239                 });
 240         ES3F_ADD_API_CASE(compressedteximage2d_max_level, "Invalid glCompressedTexImage2D() usage",
 241                 {
 242                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE) for a 2d texture target.");
 243                         deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
 244                         glCompressedTexImage2D(GL_TEXTURE_2D, log2MaxTextureSize, GL_COMPRESSED_RGB8_ETC2, 16, 16, 0, etc2DataSize(16, 16), 0);
 245                         expectError(GL_INVALID_VALUE);
 246                         m_log << TestLog::EndSection;
 247
 248                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_TEXTURE_SIZE) for a cubemap target.");
 249                         deUint32 log2MaxCubemapSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
 250                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, log2MaxCubemapSize, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
 251                         expectError(GL_INVALID_VALUE);
 252                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, log2MaxCubemapSize, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
 253                         expectError(GL_INVALID_VALUE);
 254                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, log2MaxCubemapSize, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
 255                         expectError(GL_INVALID_VALUE);
 256                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, log2MaxCubemapSize, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
 257                         expectError(GL_INVALID_VALUE);
 258                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, log2MaxCubemapSize, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
 259                         expectError(GL_INVALID_VALUE);
 260                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, log2MaxCubemapSize, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
 261                         expectError(GL_INVALID_VALUE);
 262                         m_log << TestLog::EndSection;
 263                 });
 264         ES3F_ADD_API_CASE(compressedteximage2d_neg_width_height, "Invalid glCompressedTexImage2D() usage",
 265                 {
 266                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
 267
 268                         m_log << TestLog::Section("", "GL_TEXTURE_2D target");
 269                         glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0, 0, 0, 0);
 270                         expectError(GL_INVALID_VALUE);
 271                         glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, -1, 0, 0, 0);
 272                         expectError(GL_INVALID_VALUE);
 273                         glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, -1, 0, 0, 0);
 274                         expectError(GL_INVALID_VALUE);
 275                         m_log << TestLog::EndSection;
 276
 277                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_X target");
 278                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0, 0, 0, 0);
 279                         expectError(GL_INVALID_VALUE);
 280                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, -1, 0, 0, 0);
 281                         expectError(GL_INVALID_VALUE);
 282                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, -1, 0, 0, 0);
 283                         expectError(GL_INVALID_VALUE);
 284                         m_log << TestLog::EndSection;
 285
 286                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_Y target");
 287                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0, 0, 0, 0);
 288                         expectError(GL_INVALID_VALUE);
 289                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, -1, 0, 0, 0);
 290                         expectError(GL_INVALID_VALUE);
 291                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, -1, 0, 0, 0);
 292                         expectError(GL_INVALID_VALUE);
 293                         m_log << TestLog::EndSection;
 294
 295                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_Z target");
 296                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0, 0, 0, 0);
 297                         expectError(GL_INVALID_VALUE);
 298                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, -1, 0, 0, 0);
 299                         expectError(GL_INVALID_VALUE);
 300                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, -1, 0, 0, 0);
 301                         expectError(GL_INVALID_VALUE);
 302                         m_log << TestLog::EndSection;
 303
 304                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_X target");
 305                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0, 0, 0, 0);
 306                         expectError(GL_INVALID_VALUE);
 307                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, -1, 0, 0, 0);
 308                         expectError(GL_INVALID_VALUE);
 309                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, -1, 0, 0, 0);
 310                         expectError(GL_INVALID_VALUE);
 311                         m_log << TestLog::EndSection;
 312
 313                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y target");
 314                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0, 0, 0, 0);
 315                         expectError(GL_INVALID_VALUE);
 316                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, -1, 0, 0, 0);
 317                         expectError(GL_INVALID_VALUE);
 318                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, -1, 0, 0, 0);
 319                         expectError(GL_INVALID_VALUE);
 320                         m_log << TestLog::EndSection;
 321
 322                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z target");
 323                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0, 0, 0, 0);
 324                         expectError(GL_INVALID_VALUE);
 325                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, -1, 0, 0, 0);
 326                         expectError(GL_INVALID_VALUE);
 327                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, -1, 0, 0, 0);
 328                         expectError(GL_INVALID_VALUE);
 329                         m_log << TestLog::EndSection;
 330
 331                         m_log << TestLog::EndSection;
 332                 });
 333         ES3F_ADD_API_CASE(compressedteximage2d_max_width_height, "Invalid glCompressedTexImage2D() usage",
 334                 {
 335                         int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE) + 1;
 336                         int maxCubemapSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
 337                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_TEXTURE_SIZE.");
 338
 339                         m_log << TestLog::Section("", "GL_TEXTURE_2D target");
 340                         glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxTextureSize, 1, 0, etc2EacDataSize(maxTextureSize, 1), 0);
 341                         expectError(GL_INVALID_VALUE);
 342                         glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 1, maxTextureSize, 0, etc2EacDataSize(1, maxTextureSize), 0);
 343                         expectError(GL_INVALID_VALUE);
 344                         glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxTextureSize, maxTextureSize, 0, etc2EacDataSize(maxTextureSize, maxTextureSize), 0);
 345                         expectError(GL_INVALID_VALUE);
 346                         m_log << TestLog::EndSection;
 347
 348                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_X target");
 349                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, 1, 0, etc2EacDataSize(maxCubemapSize, 1), 0);
 350                         expectError(GL_INVALID_VALUE);
 351                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 1, maxCubemapSize, 0, etc2EacDataSize(1, maxCubemapSize), 0);
 352                         expectError(GL_INVALID_VALUE);
 353                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, maxCubemapSize, 0, etc2EacDataSize(maxCubemapSize, maxCubemapSize), 0);
 354                         expectError(GL_INVALID_VALUE);
 355                         m_log << TestLog::EndSection;
 356
 357                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_Y target");
 358                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, 1, 0, etc2EacDataSize(maxCubemapSize, 1), 0);
 359                         expectError(GL_INVALID_VALUE);
 360                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 1, maxCubemapSize, 0, etc2EacDataSize(1, maxCubemapSize), 0);
 361                         expectError(GL_INVALID_VALUE);
 362                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, maxCubemapSize, 0, etc2EacDataSize(maxCubemapSize, maxCubemapSize), 0);
 363                         expectError(GL_INVALID_VALUE);
 364                         m_log << TestLog::EndSection;
 365
 366                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_Z target");
 367                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, 1, 0, etc2EacDataSize(maxCubemapSize, 1), 0);
 368                         expectError(GL_INVALID_VALUE);
 369                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 1, maxCubemapSize, 0, etc2EacDataSize(1, maxCubemapSize), 0);
 370                         expectError(GL_INVALID_VALUE);
 371                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, maxCubemapSize, 0, etc2EacDataSize(maxCubemapSize, maxCubemapSize), 0);
 372                         expectError(GL_INVALID_VALUE);
 373                         m_log << TestLog::EndSection;
 374
 375                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_X target");
 376                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, 1, 0, etc2EacDataSize(maxCubemapSize, 1), 0);
 377                         expectError(GL_INVALID_VALUE);
 378                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 1, maxCubemapSize, 0, etc2EacDataSize(1, maxCubemapSize), 0);
 379                         expectError(GL_INVALID_VALUE);
 380                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, maxCubemapSize, 0, etc2EacDataSize(maxCubemapSize, maxCubemapSize), 0);
 381                         expectError(GL_INVALID_VALUE);
 382                         m_log << TestLog::EndSection;
 383
 384                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y target");
 385                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, 1, 0, etc2EacDataSize(maxCubemapSize, 1), 0);
 386                         expectError(GL_INVALID_VALUE);
 387                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 1, maxCubemapSize, 0, etc2EacDataSize(1, maxCubemapSize), 0);
 388                         expectError(GL_INVALID_VALUE);
 389                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, maxCubemapSize, 0, etc2EacDataSize(maxCubemapSize, maxCubemapSize), 0);
 390                         expectError(GL_INVALID_VALUE);
 391                         m_log << TestLog::EndSection;
 392
 393                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z target");
 394                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, 1, 0, etc2EacDataSize(maxCubemapSize, 1), 0);
 395                         expectError(GL_INVALID_VALUE);
 396                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 1, maxCubemapSize, 0, etc2EacDataSize(1, maxCubemapSize), 0);
 397                         expectError(GL_INVALID_VALUE);
 398                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxCubemapSize, maxCubemapSize, 0, etc2EacDataSize(maxCubemapSize, maxCubemapSize), 0);
 399                         expectError(GL_INVALID_VALUE);
 400                         m_log << TestLog::EndSection;
 401
 402                         m_log << TestLog::EndSection;
 403                 });
 404         ES3F_ADD_API_CASE(compressedteximage2d_invalid_border, "Invalid glCompressedTexImage2D() usage",
 405                 {
 406                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
 407
 408                         m_log << TestLog::Section("", "GL_TEXTURE_2D target");
 409                         glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 1, 0, 0);
 410                         expectError(GL_INVALID_VALUE);
 411                         glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, -1, 0, 0);
 412                         expectError(GL_INVALID_VALUE);
 413                         m_log << TestLog::EndSection;
 414
 415                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_X target");
 416                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 1, 0, 0);
 417                         expectError(GL_INVALID_VALUE);
 418                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, -1, 0, 0);
 419                         expectError(GL_INVALID_VALUE);
 420                         m_log << TestLog::EndSection;
 421
 422                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_Y target");
 423                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 1, 0, 0);
 424                         expectError(GL_INVALID_VALUE);
 425                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, -1, 0, 0);
 426                         expectError(GL_INVALID_VALUE);
 427                         m_log << TestLog::EndSection;
 428
 429                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_Z target");
 430                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 1, 0, 0);
 431                         expectError(GL_INVALID_VALUE);
 432                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, -1, 0, 0);
 433                         expectError(GL_INVALID_VALUE);
 434                         m_log << TestLog::EndSection;
 435
 436                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_X target");
 437                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 1, 0, 0);
 438                         expectError(GL_INVALID_VALUE);
 439                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, -1, 0, 0);
 440                         expectError(GL_INVALID_VALUE);
 441                         m_log << TestLog::EndSection;
 442
 443                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y target");
 444                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 1, 0, 0);
 445                         expectError(GL_INVALID_VALUE);
 446                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, -1, 0, 0);
 447                         expectError(GL_INVALID_VALUE);
 448                         m_log << TestLog::EndSection;
 449
 450                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z target");
 451                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 1, 0, 0);
 452                         expectError(GL_INVALID_VALUE);
 453                         glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, -1, 0, 0);
 454                         expectError(GL_INVALID_VALUE);
 455                         m_log << TestLog::EndSection;
 456
 457                         m_log << TestLog::EndSection;
 458                 });
 459         ES3F_ADD_API_CASE(compressedteximage2d_invalid_size, "Invalid glCompressedTexImage2D() usage",
 460                 {
 461                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if imageSize is not consistent with the format, dimensions, and contents of the specified compressed image data.");
 462                         glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, -1, 0);
 463                         expectError(GL_INVALID_VALUE);
 464                         glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, 4*4*8, 0);
 465                         expectError(GL_INVALID_VALUE);
 466                         glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB8_ETC2, 16, 16, 0, 4*4*16, 0);
 467                         expectError(GL_INVALID_VALUE);
 468                         glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SIGNED_R11_EAC, 16, 16, 0, 4*4*16, 0);
 469                         expectError(GL_INVALID_VALUE);
 470                         m_log << TestLog::EndSection;
 471                 });
 472         ES3F_ADD_API_CASE(compressedteximage2d_invalid_buffer_target, "Invalid glCompressedTexImage2D() usage",
 473                 {
 474                         deUint32                                buf;
 475                         std::vector<GLubyte>    data(64);
 476
 477                         glGenBuffers                    (1, &buf);
 478                         glBindBuffer                    (GL_PIXEL_UNPACK_BUFFER, buf);
 479                         glBufferData                    (GL_PIXEL_UNPACK_BUFFER, 64, &data[0], GL_DYNAMIC_COPY);
 480                         expectError                             (GL_NO_ERROR);
 481
 482                         m_log << TestLog::Section("", "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.");
 483                         glMapBufferRange                (GL_PIXEL_UNPACK_BUFFER, 0, 32, GL_MAP_WRITE_BIT);
 484                         glCompressedTexImage2D  (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB8_ETC2, 4, 4, 0, etc2DataSize(4, 4), 0);
 485                         expectError                             (GL_INVALID_OPERATION);
 486                         glUnmapBuffer                   (GL_PIXEL_UNPACK_BUFFER);
 487                         m_log << TestLog::EndSection;
 488
 489                         m_log << TestLog::Section("", "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.");
 490                         glCompressedTexImage2D  (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB8_ETC2, 16, 16, 0, etc2DataSize(16, 16), 0);
 491                         expectError                             (GL_INVALID_OPERATION);
 492                         m_log << TestLog::EndSection;
 493
 494                         glDeleteBuffers                 (1, &buf);
 495                 });
 496         ES3F_ADD_API_CASE(compressedteximage2d_invalid_astc_target, "Invalid glCompressedTexImage2D() ASTC 2D targets",
 497                 {
 498                         // GLES 3.0.4, Sec 3.8.6, p.147: For example, the
 499                         // compressed image format might be supported only for 2D
 500                         // textures ... result in an INVALID_OPERATION error.
 501                         // Also, if LDR is supported, formats cannot be invalid enums
 502
 503                         if (m_context.getContextInfo().isExtensionSupported("GL_KHR_texture_compression_astc_hdr") ||
 504                                 m_context.getContextInfo().isExtensionSupported("GL_OES_texture_compression_astc"))
 505                         {
 506                                 m_log.writeMessage("Full ASTC supported. No negative API requirements.");
 507                         }
 508                         else
 509                         {
 510                                 const GLuint requiredError = m_context.getContextInfo().isExtensionSupported("GL_KHR_texture_compression_astc_ldr") ? GL_INVALID_OPERATION : GL_INVALID_ENUM;
 511
 512                                 if (requiredError == GL_INVALID_OPERATION)
 513                                         m_log.writeMessage("GL_INVALID_OPERATION should be generated if cube map targets work with LDR ASTC.");
 514                                 else
 515                                         m_log.writeMessage("GL_INVALID_ENUM should be generated if no ASTC extensions are present.");
 516
 517                                 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(s_astcFormats); formatNdx++)
 518                                 {
 519                                         const GLuint                            format          = s_astcFormats[formatNdx];
 520                                         const CompressedTexFormat       tcuFormat       = mapGLCompressedTexFormat(format);
 521                                         const IVec3                             blockPixels = getBlockPixelSize(tcuFormat);
 522                                         const size_t                            blockBytes      = getBlockSize(tcuFormat);
 523                                         const vector<deUint8>           dummyData       (blockBytes);
 524
 525                                         FOR_CUBE_FACES(faceGL,
 526                                         {
 527                                                 glCompressedTexImage2D(faceGL, 0, format, blockPixels.x(), blockPixels.y(), 0, blockBytes, &dummyData[0]);
 528                                                 expectError(requiredError);
 529                                         });
 530                                 }
 531                         }
 532                 });
 533
 534         // glCopyTexImage2D
 535
 536         ES3F_ADD_API_CASE(copyteximage2d_invalid_target, "Invalid glCopyTexImage2D() usage",
 537                 {
 538                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is invalid.");
 539                         glCopyTexImage2D(0, 0, GL_RGB, 0, 0, 64, 64, 0);
 540                         expectError(GL_INVALID_ENUM);
 541                         m_log << TestLog::EndSection;
 542                 });
 543         ES3F_ADD_API_CASE(copyteximage2d_invalid_format, "Invalid glCopyTexImage2D() usage",
 544                 {
 545                         m_log << TestLog::Section("", "GL_INVALID_ENUM or GL_INVALID_VALUE is generated if internalformat is not an accepted format.");
 546                         glCopyTexImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 64, 64, 0);
 547                         expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
 548                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, 0, 0, 0, 16, 16, 0);
 549                         expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
 550                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, 0, 0, 0, 16, 16, 0);
 551                         expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
 552                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, 0, 0, 0, 16, 16, 0);
 553                         expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
 554                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, 0, 0, 0, 16, 16, 0);
 555                         expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
 556                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, 0, 0, 0, 16, 16, 0);
 557                         expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
 558                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, 0, 0, 0, 16, 16, 0);
 559                         expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
 560                         m_log << TestLog::EndSection;
 561                 });
 562         ES3F_ADD_API_CASE(copyteximage2d_inequal_width_height_cube, "Invalid glCopyTexImage2D() usage",
 563                 {
 564                         m_log << TestLog::Section("", "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.");
 565                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 16, 17, 0);
 566                         expectError(GL_INVALID_VALUE);
 567                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, 16, 17, 0);
 568                         expectError(GL_INVALID_VALUE);
 569                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, 16, 17, 0);
 570                         expectError(GL_INVALID_VALUE);
 571                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, 16, 17, 0);
 572                         expectError(GL_INVALID_VALUE);
 573                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, 16, 17, 0);
 574                         expectError(GL_INVALID_VALUE);
 575                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, 16, 17, 0);
 576                         expectError(GL_INVALID_VALUE);
 577                         m_log << TestLog::EndSection;
 578                 });
 579         ES3F_ADD_API_CASE(copyteximage2d_neg_level, "Invalid glCopyTexImage2D() usage",
 580                 {
 581                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
 582                         glCopyTexImage2D(GL_TEXTURE_2D, -1, GL_RGB, 0, 0, 64, 64, 0);
 583                         expectError(GL_INVALID_VALUE);
 584                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, -1, GL_RGB, 0, 0, 16, 16, 0);
 585                         expectError(GL_INVALID_VALUE);
 586                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, -1, GL_RGB, 0, 0, 16, 16, 0);
 587                         expectError(GL_INVALID_VALUE);
 588                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, -1, GL_RGB, 0, 0, 16, 16, 0);
 589                         expectError(GL_INVALID_VALUE);
 590                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, -1, GL_RGB, 0, 0, 16, 16, 0);
 591                         expectError(GL_INVALID_VALUE);
 592                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, -1, GL_RGB, 0, 0, 16, 16, 0);
 593                         expectError(GL_INVALID_VALUE);
 594                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, -1, GL_RGB, 0, 0, 16, 16, 0);
 595                         expectError(GL_INVALID_VALUE);
 596                         m_log << TestLog::EndSection;
 597                 });
 598         ES3F_ADD_API_CASE(copyteximage2d_max_level, "Invalid glCopyTexImage2D() usage",
 599                 {
 600                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
 601                         deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
 602                         glCopyTexImage2D(GL_TEXTURE_2D, log2MaxTextureSize, GL_RGB, 0, 0, 64, 64, 0);
 603                         expectError(GL_INVALID_VALUE);
 604                         m_log << TestLog::EndSection;
 605
 606                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_TEXTURE_SIZE).");
 607                         deUint32 log2MaxCubemapSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
 608                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, log2MaxCubemapSize, GL_RGB, 0, 0, 16, 16, 0);
 609                         expectError(GL_INVALID_VALUE);
 610                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, log2MaxCubemapSize, GL_RGB, 0, 0, 16, 16, 0);
 611                         expectError(GL_INVALID_VALUE);
 612                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, log2MaxCubemapSize, GL_RGB, 0, 0, 16, 16, 0);
 613                         expectError(GL_INVALID_VALUE);
 614                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, log2MaxCubemapSize, GL_RGB, 0, 0, 16, 16, 0);
 615                         expectError(GL_INVALID_VALUE);
 616                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, log2MaxCubemapSize, GL_RGB, 0, 0, 16, 16, 0);
 617                         expectError(GL_INVALID_VALUE);
 618                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, log2MaxCubemapSize, GL_RGB, 0, 0, 16, 16, 0);
 619                         expectError(GL_INVALID_VALUE);
 620                         m_log << TestLog::EndSection;
 621                 });
 622         ES3F_ADD_API_CASE(copyteximage2d_neg_width_height, "Invalid glCopyTexImage2D() usage",
 623                 {
 624                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
 625
 626                         m_log << TestLog::Section("", "GL_TEXTURE_2D target");
 627                         glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, -1, 1, 0);
 628                         expectError(GL_INVALID_VALUE);
 629                         glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 1, -1, 0);
 630                         expectError(GL_INVALID_VALUE);
 631                         glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, -1, -1, 0);
 632                         expectError(GL_INVALID_VALUE);
 633                         m_log << TestLog::EndSection;
 634
 635                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_X target");
 636                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, -1, 1, 0);
 637                         expectError(GL_INVALID_VALUE);
 638                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 1, -1, 0);
 639                         expectError(GL_INVALID_VALUE);
 640                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, -1, -1, 0);
 641                         expectError(GL_INVALID_VALUE);
 642                         m_log << TestLog::EndSection;
 643
 644                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_Y target");
 645                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, -1, 1, 0);
 646                         expectError(GL_INVALID_VALUE);
 647                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, 1, -1, 0);
 648                         expectError(GL_INVALID_VALUE);
 649                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, -1, -1, 0);
 650                         expectError(GL_INVALID_VALUE);
 651                         m_log << TestLog::EndSection;
 652
 653                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_Z target");
 654                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, -1, 1, 0);
 655                         expectError(GL_INVALID_VALUE);
 656                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, 1, -1, 0);
 657                         expectError(GL_INVALID_VALUE);
 658                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, -1, -1, 0);
 659                         expectError(GL_INVALID_VALUE);
 660                         m_log << TestLog::EndSection;
 661
 662                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_X target");
 663                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, -1, 1, 0);
 664                         expectError(GL_INVALID_VALUE);
 665                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, 1, -1, 0);
 666                         expectError(GL_INVALID_VALUE);
 667                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, -1, -1, 0);
 668                         expectError(GL_INVALID_VALUE);
 669                         m_log << TestLog::EndSection;
 670
 671                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y target");
 672                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, -1, 1, 0);
 673                         expectError(GL_INVALID_VALUE);
 674                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, 1, -1, 0);
 675                         expectError(GL_INVALID_VALUE);
 676                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, -1, -1, 0);
 677                         expectError(GL_INVALID_VALUE);
 678                         m_log << TestLog::EndSection;
 679
 680                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z target");
 681                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, -1, 1, 0);
 682                         expectError(GL_INVALID_VALUE);
 683                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, 1, -1, 0);
 684                         expectError(GL_INVALID_VALUE);
 685                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, -1, -1, 0);
 686                         expectError(GL_INVALID_VALUE);
 687                         m_log << TestLog::EndSection;
 688
 689                         m_log << TestLog::EndSection;
 690                 });
 691         ES3F_ADD_API_CASE(copyteximage2d_max_width_height, "Invalid glCopyTexImage2D() usage",
 692                 {
 693                         int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE) + 1;
 694                         int maxCubemapSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
 695
 696                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_TEXTURE_SIZE.");
 697
 698                         m_log << TestLog::Section("", "GL_TEXTURE_2D target");
 699                         glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, maxTextureSize, 1, 0);
 700                         expectError(GL_INVALID_VALUE);
 701                         glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 1, maxTextureSize, 0);
 702                         expectError(GL_INVALID_VALUE);
 703                         glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, maxTextureSize, maxTextureSize, 0);
 704                         expectError(GL_INVALID_VALUE);
 705                         m_log << TestLog::EndSection;
 706
 707                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_X target");
 708                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 1, maxCubemapSize, 0);
 709                         expectError(GL_INVALID_VALUE);
 710                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, maxCubemapSize, 1, 0);
 711                         expectError(GL_INVALID_VALUE);
 712                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, maxCubemapSize, maxCubemapSize, 0);
 713                         expectError(GL_INVALID_VALUE);
 714                         m_log << TestLog::EndSection;
 715
 716                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_Y target");
 717                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, 1, maxCubemapSize, 0);
 718                         expectError(GL_INVALID_VALUE);
 719                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, maxCubemapSize, 1, 0);
 720                         expectError(GL_INVALID_VALUE);
 721                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, maxCubemapSize, maxCubemapSize, 0);
 722                         expectError(GL_INVALID_VALUE);
 723                         m_log << TestLog::EndSection;
 724
 725                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_Z target");
 726                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, 1, maxCubemapSize, 0);
 727                         expectError(GL_INVALID_VALUE);
 728                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, maxCubemapSize, 1, 0);
 729                         expectError(GL_INVALID_VALUE);
 730                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, maxCubemapSize, maxCubemapSize, 0);
 731                         expectError(GL_INVALID_VALUE);
 732                         m_log << TestLog::EndSection;
 733
 734                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_X target");
 735                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, 1, maxCubemapSize, 0);
 736                         expectError(GL_INVALID_VALUE);
 737                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, maxCubemapSize, 1, 0);
 738                         expectError(GL_INVALID_VALUE);
 739                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, maxCubemapSize, maxCubemapSize, 0);
 740                         expectError(GL_INVALID_VALUE);
 741                         m_log << TestLog::EndSection;
 742
 743                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y target");
 744                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, 1, maxCubemapSize, 0);
 745                         expectError(GL_INVALID_VALUE);
 746                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, maxCubemapSize, 1, 0);
 747                         expectError(GL_INVALID_VALUE);
 748                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, maxCubemapSize, maxCubemapSize, 0);
 749                         expectError(GL_INVALID_VALUE);
 750                         m_log << TestLog::EndSection;
 751
 752                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z target");
 753                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, 1, maxCubemapSize, 0);
 754                         expectError(GL_INVALID_VALUE);
 755                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, maxCubemapSize, 1, 0);
 756                         expectError(GL_INVALID_VALUE);
 757                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, maxCubemapSize, maxCubemapSize, 0);
 758                         expectError(GL_INVALID_VALUE);
 759                         m_log << TestLog::EndSection;
 760
 761                         m_log << TestLog::EndSection;
 762                 });
 763         ES3F_ADD_API_CASE(copyteximage2d_invalid_border, "Invalid glCopyTexImage2D() usage",
 764                 {
 765                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
 766
 767                         m_log << TestLog::Section("", "GL_TEXTURE_2D target");
 768                         glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 0, 0, -1);
 769                         expectError(GL_INVALID_VALUE);
 770                         glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 0, 0, 1);
 771                         expectError(GL_INVALID_VALUE);
 772                         m_log << TestLog::EndSection;
 773
 774                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_X target");
 775                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 0, 0, -1);
 776                         expectError(GL_INVALID_VALUE);
 777                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 0, 0, 1);
 778                         expectError(GL_INVALID_VALUE);
 779                         m_log << TestLog::EndSection;
 780
 781                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_Y target");
 782                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, 0, 0, -1);
 783                         expectError(GL_INVALID_VALUE);
 784                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, 0, 0, 1);
 785                         expectError(GL_INVALID_VALUE);
 786                         m_log << TestLog::EndSection;
 787
 788                         m_log << TestLog::Section("", "GL_TEXTURE_2D target");
 789                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, 0, 0, -1);
 790                         expectError(GL_INVALID_VALUE);
 791                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, 0, 0, 1);
 792                         expectError(GL_INVALID_VALUE);
 793                         m_log << TestLog::EndSection;
 794
 795                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_X target");
 796                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, 0, 0, -1);
 797                         expectError(GL_INVALID_VALUE);
 798                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, 0, 0, 1);
 799                         expectError(GL_INVALID_VALUE);
 800                         m_log << TestLog::EndSection;
 801
 802                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y target");
 803                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, 0, 0, -1);
 804                         expectError(GL_INVALID_VALUE);
 805                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, 0, 0, 1);
 806                         expectError(GL_INVALID_VALUE);
 807                         m_log << TestLog::EndSection;
 808
 809                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z target");
 810                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, 0, 0, -1);
 811                         expectError(GL_INVALID_VALUE);
 812                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, 0, 0, 1);
 813                         expectError(GL_INVALID_VALUE);
 814                         m_log << TestLog::EndSection;
 815
 816                         m_log << TestLog::EndSection;
 817                 });
 818         ES3F_ADD_API_CASE(copyteximage2d_incomplete_framebuffer, "Invalid glCopyTexImage2D() usage",
 819                 {
 820                         GLuint fbo;
 821                         glGenFramebuffers               (1, &fbo);
 822                         glBindFramebuffer               (GL_FRAMEBUFFER, fbo);
 823                         glCheckFramebufferStatus(GL_FRAMEBUFFER);
 824
 825                         m_log << tcu::TestLog::Section("", "GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
 826                         glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 0, 0, 0, 0, 0);
 827                         expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 828                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA8, 0, 0, 0, 0, 0);
 829                         expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 830                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGBA8, 0, 0, 0, 0, 0);
 831                         expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 832                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGBA8, 0, 0, 0, 0, 0);
 833                         expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 834                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGBA8, 0, 0, 0, 0, 0);
 835                         expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 836                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGBA8, 0, 0, 0, 0, 0);
 837                         expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 838                         glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGBA8, 0, 0, 0, 0, 0);
 839                         expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 840                         m_log << tcu::TestLog::EndSection;
 841
 842                         glBindFramebuffer       (GL_FRAMEBUFFER, 0);
 843                         glDeleteFramebuffers(1, &fbo);
 844                 });
 845
 846         // glCopyTexSubImage2D
 847
 848         ES3F_ADD_API_CASE(copytexsubimage2d_invalid_target, "Invalid glCopyTexSubImage2D() usage",
 849                 {
 850                         GLuint texture;
 851                         glGenTextures   (1, &texture);
 852                         glBindTexture   (GL_TEXTURE_2D, texture);
 853                         glTexImage2D    (GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 854
 855                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is invalid.");
 856                         glCopyTexSubImage2D(0, 0, 0, 0, 0, 0, 4, 4);
 857                         expectError(GL_INVALID_ENUM);
 858                         m_log << TestLog::EndSection;
 859
 860                         glDeleteTextures(1, &texture);
 861                 });
 862         ES3F_ADD_API_CASE(copytexsubimage2d_neg_level, "Invalid glCopyTexSubImage2D() usage",
 863                 {
 864                         GLuint textures[2];
 865                         glGenTextures   (2, &textures[0]);
 866                         glBindTexture   (GL_TEXTURE_2D, textures[0]);
 867                         glTexImage2D    (GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 868                         glBindTexture   (GL_TEXTURE_CUBE_MAP, textures[1]);
 869                         FOR_CUBE_FACES(faceGL, glTexImage2D(faceGL, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0););
 870
 871                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
 872                         glCopyTexSubImage2D(GL_TEXTURE_2D, -1, 0, 0, 0, 0, 4, 4);
 873                         expectError(GL_INVALID_VALUE);
 874                         FOR_CUBE_FACES(faceGL,
 875                         {
 876                                 glCopyTexSubImage2D(faceGL, -1, 0, 0, 0, 0, 4, 4);
 877                                 expectError(GL_INVALID_VALUE);
 878                         });
 879                         m_log << TestLog::EndSection;
 880
 881                         glDeleteTextures(2, &textures[0]);
 882                 });
 883         ES3F_ADD_API_CASE(copytexsubimage2d_max_level, "Invalid glCopyTexSubImage2D() usage",
 884                 {
 885                         GLuint textures[2];
 886                         glGenTextures   (2, &textures[0]);
 887                         glBindTexture   (GL_TEXTURE_2D, textures[0]);
 888                         glTexImage2D    (GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 889                         glBindTexture   (GL_TEXTURE_CUBE_MAP, textures[1]);
 890                         FOR_CUBE_FACES(faceGL, glTexImage2D(faceGL, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0););
 891
 892                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE) for 2D texture targets.");
 893                         deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
 894                         glCopyTexSubImage2D(GL_TEXTURE_2D, log2MaxTextureSize, 0, 0, 0, 0, 4, 4);
 895                         expectError(GL_INVALID_VALUE);
 896                         m_log << TestLog::EndSection;
 897
 898                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_SIZE) for cubemap targets.");
 899                         deUint32 log2MaxCubemapSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
 900                         FOR_CUBE_FACES(faceGL,
 901                         {
 902                                 glCopyTexSubImage2D(faceGL, log2MaxCubemapSize, 0, 0, 0, 0, 4, 4);
 903                                 expectError(GL_INVALID_VALUE);
 904                         });
 905                         m_log << TestLog::EndSection;
 906
 907                         glDeleteTextures(2, &textures[0]);
 908                 });
 909         ES3F_ADD_API_CASE(copytexsubimage2d_neg_offset, "Invalid glCopyTexSubImage2D() usage",
 910                 {
 911                         GLuint texture;
 912                         glGenTextures   (1, &texture);
 913                         glBindTexture   (GL_TEXTURE_2D, texture);
 914                         glTexImage2D    (GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 915
 916                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if xoffset < 0 or yoffset < 0.");
 917                         glCopyTexSubImage2D(GL_TEXTURE_2D, 0, -1, 0, 0, 0, 4, 4);
 918                         expectError(GL_INVALID_VALUE);
 919                         glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, -1, 0, 0, 4, 4);
 920                         expectError(GL_INVALID_VALUE);
 921                         glCopyTexSubImage2D(GL_TEXTURE_2D, 0, -1, -1, 0, 0, 4, 4);
 922                         expectError(GL_INVALID_VALUE);
 923                         m_log << TestLog::EndSection;
 924
 925                         glDeleteTextures(1, &texture);
 926                 });
 927         ES3F_ADD_API_CASE(copytexsubimage2d_invalid_offset, "Invalid glCopyTexSubImage2D() usage",
 928                 {
 929                         GLuint texture;
 930                         glGenTextures   (1, &texture);
 931                         glBindTexture   (GL_TEXTURE_2D, texture);
 932                         glTexImage2D    (GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 933
 934                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if xoffset + width > texture_width or yoffset + height > texture_height.");
 935                         glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 14, 0, 0, 0, 4, 4);
 936                         expectError(GL_INVALID_VALUE);
 937                         glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 14, 0, 0, 4, 4);
 938                         expectError(GL_INVALID_VALUE);
 939                         glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 14, 14, 0, 0, 4, 4);
 940                         expectError(GL_INVALID_VALUE);
 941                         m_log << TestLog::EndSection;
 942
 943                         glDeleteTextures(1, &texture);
 944                 });
 945         ES3F_ADD_API_CASE(copytexsubimage2d_neg_width_height, "Invalid glCopyTexSubImage2D() usage",
 946                 {
 947                         GLuint texture;
 948                         glGenTextures   (1, &texture);
 949                         glBindTexture   (GL_TEXTURE_2D, texture);
 950                         glTexImage2D    (GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 951
 952                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
 953                         glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, -1, 0);
 954                         expectError(GL_INVALID_VALUE);
 955                         glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, -1);
 956                         expectError(GL_INVALID_VALUE);
 957                         glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, -1, -1);
 958                         expectError(GL_INVALID_VALUE);
 959                         m_log << TestLog::EndSection;
 960
 961                         glDeleteTextures(1, &texture);
 962                 });
 963         ES3F_ADD_API_CASE(copytexsubimage2d_incomplete_framebuffer, "Invalid glCopyTexSubImage2D() usage",
 964                 {
 965                         m_log << tcu::TestLog::Section("", "GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
 966
 967                         GLuint texture[2];
 968                         GLuint fbo;
 969
 970                         glGenTextures                   (2, texture);
 971                         glBindTexture                   (GL_TEXTURE_2D, texture[0]);
 972                         glTexImage2D                    (GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 973                         glBindTexture                   (GL_TEXTURE_CUBE_MAP, texture[1]);
 974                         glTexImage2D                    (GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 975                         glTexImage2D                    (GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 976                         glTexImage2D                    (GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 977                         glTexImage2D                    (GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 978                         glTexImage2D                    (GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 979                         glTexImage2D                    (GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 980                         expectError(GL_NO_ERROR);
 981
 982                         glGenFramebuffers(1, &fbo);
 983                         glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 984                         glCheckFramebufferStatus(GL_FRAMEBUFFER);
 985                         expectError(GL_NO_ERROR);
 986
 987                         glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 0);
 988                         expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 989                         glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, 0, 0, 0, 0, 0, 0);
 990                         expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 991                         glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, 0, 0, 0, 0, 0, 0);
 992                         expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 993                         glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, 0, 0, 0, 0, 0, 0);
 994                         expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 995                         glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, 0, 0, 0, 0, 0, 0);
 996                         expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 997                         glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, 0, 0, 0, 0, 0, 0);
 998                         expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
 999                         glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, 0, 0, 0, 0, 0, 0);
1000                         expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1001
1002                         glBindFramebuffer(GL_FRAMEBUFFER, 0);
1003                         glDeleteFramebuffers(1, &fbo);
1004                         glDeleteTextures(2, texture);
1005
1006                         m_log << tcu::TestLog::EndSection;
1007                 });
1008
1009         // glDeleteTextures
1010
1011         ES3F_ADD_API_CASE(deletetextures, "Invalid glDeleteTextures() usage",
1012                 {
1013                         GLuint texture;
1014                         glGenTextures(1, &texture);
1015
1016                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
1017                         glDeleteTextures(-1, 0);
1018                         expectError(GL_INVALID_VALUE);
1019
1020                         glBindTexture(GL_TEXTURE_2D, texture);
1021                         glDeleteTextures(-1, 0);
1022                         expectError(GL_INVALID_VALUE);
1023                         m_log << TestLog::EndSection;
1024
1025                         glDeleteTextures(1, &texture);
1026                 });
1027
1028         // glGenerateMipmap
1029
1030         ES3F_ADD_API_CASE(generatemipmap, "Invalid glGenerateMipmap() usage",
1031                 {
1032                         GLuint texture[2];
1033                         glGenTextures(2, texture);
1034
1035                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_TEXTURE_2D or GL_TEXTURE_CUBE_MAP.");
1036                         glGenerateMipmap(0);
1037                         expectError(GL_INVALID_ENUM);
1038                         m_log << TestLog::EndSection;
1039
1040                         m_log << TestLog::Section("", "INVALID_OPERATION is generated if the texture bound to target is not cube complete.");
1041                         glBindTexture(GL_TEXTURE_CUBE_MAP, texture[0]);
1042                         glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_REPEAT);
1043                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1044                         glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
1045                         expectError(GL_INVALID_OPERATION);
1046
1047                         glBindTexture(GL_TEXTURE_CUBE_MAP, texture[0]);
1048                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1049                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1050                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1051                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1052                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1053                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 32, 32, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1054                         glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
1055                         expectError(GL_INVALID_OPERATION);
1056                         m_log << TestLog::EndSection;
1057
1058                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the zero level array is stored in a compressed internal format.");
1059                         glBindTexture(GL_TEXTURE_2D, texture[1]);
1060                         glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0);
1061                         glGenerateMipmap(GL_TEXTURE_2D);
1062                         expectError(GL_INVALID_OPERATION);
1063                         m_log << TestLog::EndSection;
1064
1065                         m_log << TestLog::Section("", "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.");
1066                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8_SNORM, 0, 0, 0, GL_RGB, GL_BYTE, 0);
1067                         glGenerateMipmap(GL_TEXTURE_2D);
1068                         expectError(GL_INVALID_OPERATION);
1069                         glTexImage2D(GL_TEXTURE_2D, 0, GL_R8I, 0, 0, 0, GL_RED_INTEGER, GL_BYTE, 0);
1070                         glGenerateMipmap(GL_TEXTURE_2D);
1071                         expectError(GL_INVALID_OPERATION);
1072
1073                         if (!(m_context.getContextInfo().isExtensionSupported("GL_EXT_color_buffer_float") && m_context.getContextInfo().isExtensionSupported("GL_OES_texture_float_linear")))
1074                         {
1075                                 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 0, 0, 0, GL_RGBA, GL_FLOAT, 0);
1076                                 glGenerateMipmap(GL_TEXTURE_2D);
1077                                 expectError(GL_INVALID_OPERATION);
1078                         }
1079
1080                         m_log << TestLog::EndSection;
1081
1082                         glDeleteTextures(2, texture);
1083                 });
1084
1085         // glGenTextures
1086
1087         ES3F_ADD_API_CASE(gentextures, "Invalid glGenTextures() usage",
1088                 {
1089                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
1090                         glGenTextures(-1, 0);
1091                         expectError(GL_INVALID_VALUE);
1092                         m_log << TestLog::EndSection;
1093                 });
1094
1095         // glPixelStorei
1096
1097         ES3F_ADD_API_CASE(pixelstorei, "Invalid glPixelStorei() usage",
1098                 {
1099                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not an accepted value.");
1100                         glPixelStorei(0,1);
1101                         expectError(GL_INVALID_ENUM);
1102                         m_log << TestLog::EndSection;
1103
1104                         m_log << TestLog::Section("", "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.");
1105                         glPixelStorei(GL_PACK_ROW_LENGTH, -1);
1106                         expectError(GL_INVALID_VALUE);
1107                         glPixelStorei(GL_PACK_SKIP_ROWS, -1);
1108                         expectError(GL_INVALID_VALUE);
1109                         glPixelStorei(GL_PACK_SKIP_PIXELS, -1);
1110                         expectError(GL_INVALID_VALUE);
1111                         glPixelStorei(GL_UNPACK_ROW_LENGTH, -1);
1112                         expectError(GL_INVALID_VALUE);
1113                         glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, -1);
1114                         expectError(GL_INVALID_VALUE);
1115                         glPixelStorei(GL_UNPACK_SKIP_ROWS, -1);
1116                         expectError(GL_INVALID_VALUE);
1117                         glPixelStorei(GL_UNPACK_SKIP_PIXELS, -1);
1118                         expectError(GL_INVALID_VALUE);
1119                         glPixelStorei(GL_UNPACK_SKIP_IMAGES, -1);
1120                         expectError(GL_INVALID_VALUE);
1121                         glPixelStorei(GL_PACK_ALIGNMENT, 0);
1122                         expectError(GL_INVALID_VALUE);
1123                         glPixelStorei(GL_UNPACK_ALIGNMENT, 0);
1124                         expectError(GL_INVALID_VALUE);
1125                         glPixelStorei(GL_PACK_ALIGNMENT, 16);
1126                         expectError(GL_INVALID_VALUE);
1127                         glPixelStorei(GL_UNPACK_ALIGNMENT, 16);
1128                         expectError(GL_INVALID_VALUE);
1129                         m_log << TestLog::EndSection;
1130                 });
1131
1132         // glTexImage2D
1133
1134         ES3F_ADD_API_CASE(teximage2d, "Invalid glTexImage2D() usage",
1135                 {
1136                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is invalid.");
1137                         glTexImage2D(0, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1138                         expectError(GL_INVALID_ENUM);
1139                         m_log << TestLog::EndSection;
1140
1141                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if type is not a type constant.");
1142                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, 0, 0);
1143                         expectError(GL_INVALID_ENUM);
1144                         m_log << TestLog::EndSection;
1145
1146                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the combination of internalFormat, format and type is invalid.");
1147                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1148                         expectError(GL_INVALID_OPERATION);
1149                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, 0);
1150                         expectError(GL_INVALID_OPERATION);
1151                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB5_A1, 1, 1, 0, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, 0);
1152                         expectError(GL_INVALID_OPERATION);
1153                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB10_A2, 1, 1, 0, GL_RGB, GL_UNSIGNED_INT_2_10_10_10_REV, 0);
1154                         expectError(GL_INVALID_OPERATION);
1155                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32UI, 1, 1, 0, GL_RGBA_INTEGER, GL_INT, 0);
1156                         expectError(GL_INVALID_OPERATION);
1157                         m_log << TestLog::EndSection;
1158                 });
1159         ES3F_ADD_API_CASE(teximage2d_inequal_width_height_cube, "Invalid glTexImage2D() usage",
1160                 {
1161                         m_log << TestLog::Section("", "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.");
1162                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1163                         expectError(GL_INVALID_VALUE);
1164                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1165                         expectError(GL_INVALID_VALUE);
1166                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1167                         expectError(GL_INVALID_VALUE);
1168                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1169                         expectError(GL_INVALID_VALUE);
1170                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1171                         expectError(GL_INVALID_VALUE);
1172                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1173                         expectError(GL_INVALID_VALUE);
1174                         m_log << TestLog::EndSection;
1175                 });
1176         ES3F_ADD_API_CASE(teximage2d_neg_level, "Invalid glTexImage2D() usage",
1177                 {
1178                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
1179                         glTexImage2D(GL_TEXTURE_2D, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1180                         expectError(GL_INVALID_VALUE);
1181                         m_log << TestLog::EndSection;
1182
1183                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
1184                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1185                         expectError(GL_INVALID_VALUE);
1186                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1187                         expectError(GL_INVALID_VALUE);
1188                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1189                         expectError(GL_INVALID_VALUE);
1190                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1191                         expectError(GL_INVALID_VALUE);
1192                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1193                         expectError(GL_INVALID_VALUE);
1194                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1195                         expectError(GL_INVALID_VALUE);
1196                         m_log << TestLog::EndSection;
1197                 });
1198         ES3F_ADD_API_CASE(teximage2d_max_level, "Invalid glTexImage2D() usage",
1199                 {
1200                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
1201                         deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
1202                         glTexImage2D(GL_TEXTURE_2D, log2MaxTextureSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1203                         expectError(GL_INVALID_VALUE);
1204                         m_log << TestLog::EndSection;
1205
1206                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_TEXTURE_SIZE).");
1207                         deUint32 log2MaxCubemapSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
1208                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, log2MaxCubemapSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1209                         expectError(GL_INVALID_VALUE);
1210                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, log2MaxCubemapSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1211                         expectError(GL_INVALID_VALUE);
1212                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, log2MaxCubemapSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1213                         expectError(GL_INVALID_VALUE);
1214                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, log2MaxCubemapSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1215                         expectError(GL_INVALID_VALUE);
1216                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, log2MaxCubemapSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1217                         expectError(GL_INVALID_VALUE);
1218                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, log2MaxCubemapSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1219                         expectError(GL_INVALID_VALUE);
1220                         m_log << TestLog::EndSection;
1221                 });
1222         ES3F_ADD_API_CASE(teximage2d_neg_width_height, "Invalid glTexImage2D() usage",
1223                 {
1224                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
1225
1226                         m_log << TestLog::Section("", "GL_TEXTURE_2D target");
1227                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1228                         expectError(GL_INVALID_VALUE);
1229                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1230                         expectError(GL_INVALID_VALUE);
1231                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1232                         expectError(GL_INVALID_VALUE);
1233                         m_log << TestLog::EndSection;
1234
1235                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_X target");
1236                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1237                         expectError(GL_INVALID_VALUE);
1238                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1239                         expectError(GL_INVALID_VALUE);
1240                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1241                         expectError(GL_INVALID_VALUE);
1242                         m_log << TestLog::EndSection;
1243
1244                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_Y target");
1245                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1246                         expectError(GL_INVALID_VALUE);
1247                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1248                         expectError(GL_INVALID_VALUE);
1249                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1250                         expectError(GL_INVALID_VALUE);
1251                         m_log << TestLog::EndSection;
1252
1253                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_Z target");
1254                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1255                         expectError(GL_INVALID_VALUE);
1256                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1257                         expectError(GL_INVALID_VALUE);
1258                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1259                         expectError(GL_INVALID_VALUE);
1260                         m_log << TestLog::EndSection;
1261
1262                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_X target");
1263                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1264                         expectError(GL_INVALID_VALUE);
1265                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1266                         expectError(GL_INVALID_VALUE);
1267                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1268                         expectError(GL_INVALID_VALUE);
1269                         m_log << TestLog::EndSection;
1270
1271                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y target");
1272                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1273                         expectError(GL_INVALID_VALUE);
1274                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1275                         expectError(GL_INVALID_VALUE);
1276                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1277                         expectError(GL_INVALID_VALUE);
1278                         m_log << TestLog::EndSection;
1279
1280                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z target");
1281                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1282                         expectError(GL_INVALID_VALUE);
1283                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1284                         expectError(GL_INVALID_VALUE);
1285                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1286                         expectError(GL_INVALID_VALUE);
1287                         m_log << TestLog::EndSection;
1288
1289                         m_log << TestLog::EndSection;
1290                 });
1291         ES3F_ADD_API_CASE(teximage2d_max_width_height, "Invalid glTexImage2D() usage",
1292                 {
1293                         int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE) + 1;
1294                         int maxCubemapSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
1295
1296                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_TEXTURE_SIZE.");
1297                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, maxTextureSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1298                         expectError(GL_INVALID_VALUE);
1299                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1300                         expectError(GL_INVALID_VALUE);
1301                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, maxTextureSize, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1302                         expectError(GL_INVALID_VALUE);
1303                         m_log << TestLog::EndSection;
1304
1305                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
1306
1307                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_X target");
1308                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, maxCubemapSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1309                         expectError(GL_INVALID_VALUE);
1310                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 1, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1311                         expectError(GL_INVALID_VALUE);
1312                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, maxCubemapSize, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1313                         expectError(GL_INVALID_VALUE);
1314                         m_log << TestLog::EndSection;
1315
1316                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_Y target");
1317                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, maxCubemapSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1318                         expectError(GL_INVALID_VALUE);
1319                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 1, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1320                         expectError(GL_INVALID_VALUE);
1321                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, maxCubemapSize, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1322                         expectError(GL_INVALID_VALUE);
1323                         m_log << TestLog::EndSection;
1324
1325                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_POSITIVE_Z target");
1326                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, maxCubemapSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1327                         expectError(GL_INVALID_VALUE);
1328                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 1, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1329                         expectError(GL_INVALID_VALUE);
1330                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, maxCubemapSize, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1331                         expectError(GL_INVALID_VALUE);
1332                         m_log << TestLog::EndSection;
1333
1334                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_X target");
1335                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, maxCubemapSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1336                         expectError(GL_INVALID_VALUE);
1337                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 1, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1338                         expectError(GL_INVALID_VALUE);
1339                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, maxCubemapSize, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1340                         expectError(GL_INVALID_VALUE);
1341                         m_log << TestLog::EndSection;
1342
1343                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y target");
1344                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, maxCubemapSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1345                         expectError(GL_INVALID_VALUE);
1346                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 1, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1347                         expectError(GL_INVALID_VALUE);
1348                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, maxCubemapSize, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1349                         expectError(GL_INVALID_VALUE);
1350                         m_log << TestLog::EndSection;
1351
1352                         m_log << TestLog::Section("", "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z target");
1353                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, maxCubemapSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1354                         expectError(GL_INVALID_VALUE);
1355                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 1, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1356                         expectError(GL_INVALID_VALUE);
1357                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, maxCubemapSize, maxCubemapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1358                         expectError(GL_INVALID_VALUE);
1359                         m_log << TestLog::EndSection;
1360
1361                         m_log << TestLog::EndSection;
1362                 });
1363         ES3F_ADD_API_CASE(teximage2d_invalid_border, "Invalid glTexImage2D() usage",
1364                 {
1365                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
1366                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1367                         expectError(GL_INVALID_VALUE);
1368                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, -1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1369                         expectError(GL_INVALID_VALUE);
1370                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 1, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1371                         expectError(GL_INVALID_VALUE);
1372                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 1, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1373                         expectError(GL_INVALID_VALUE);
1374                         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 1, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1375                         expectError(GL_INVALID_VALUE);
1376                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 1, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1377                         expectError(GL_INVALID_VALUE);
1378                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 1, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1379                         expectError(GL_INVALID_VALUE);
1380                         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 1, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1381                         expectError(GL_INVALID_VALUE);
1382                         m_log << TestLog::EndSection;
1383                 });
1384         ES3F_ADD_API_CASE(teximage2d_invalid_buffer_target, "Invalid glTexImage2D() usage",
1385                 {
1386                         deUint32                                buf;
1387                         deUint32                                texture;
1388                         std::vector<GLubyte>    data(64);
1389
1390                         glGenBuffers                    (1, &buf);
1391                         glBindBuffer                    (GL_PIXEL_UNPACK_BUFFER, buf);
1392                         glBufferData                    (GL_PIXEL_UNPACK_BUFFER, 64, &data[0], GL_DYNAMIC_COPY);
1393                         glGenTextures                   (1, &texture);
1394                         glBindTexture                   (GL_TEXTURE_2D, texture);
1395                         expectError                             (GL_NO_ERROR);
1396
1397                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and...");
1398                         m_log << TestLog::Section("", "...the buffer object's data store is currently mapped.");
1399                         glMapBufferRange                (GL_PIXEL_UNPACK_BUFFER, 0, 32, GL_MAP_WRITE_BIT);
1400                         glTexImage2D                    (GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1401                         expectError                             (GL_INVALID_OPERATION);
1402                         glUnmapBuffer                   (GL_PIXEL_UNPACK_BUFFER);
1403                         m_log << TestLog::EndSection;
1404
1405                         m_log << TestLog::Section("", "...the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
1406                         glTexImage2D                    (GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1407                         expectError                             (GL_INVALID_OPERATION);
1408                         m_log << TestLog::EndSection;
1409
1410                         m_log << TestLog::Section("", "...data is not evenly divisible into the number of bytes needed to store in memory a datum indicated by type.");
1411                         m_log << TestLog::Message << "// Set byte offset = 3" << TestLog::EndMessage;
1412                         glTexImage2D                    (GL_TEXTURE_2D, 0, GL_RGB5_A1, 4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, (const GLvoid*)3);
1413                         expectError                             (GL_INVALID_OPERATION);
1414                         m_log << TestLog::EndSection;
1415                         m_log << TestLog::EndSection;
1416
1417                         glDeleteBuffers                 (1, &buf);
1418                         glDeleteTextures                (1, &texture);
1419                 });
1420
1421         // glTexSubImage2D
1422
1423         ES3F_ADD_API_CASE(texsubimage2d, "Invalid glTexSubImage2D() usage",
1424                 {
1425                         deUint32                        texture;
1426                         glGenTextures           (1, &texture);
1427                         glBindTexture           (GL_TEXTURE_2D, texture);
1428                         glTexImage2D            (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1429                         expectError                     (GL_NO_ERROR);
1430
1431                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is invalid.");
1432                         glTexSubImage2D(0, 0, 0, 0, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1433                         expectError(GL_INVALID_ENUM);
1434                         m_log << TestLog::EndSection;
1435
1436                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if format is not an accepted format constant.");
1437                         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 4, 4, GL_UNSIGNED_BYTE, 0);
1438                         expectError(GL_INVALID_ENUM);
1439                         m_log << TestLog::EndSection;
1440
1441                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if type is not a type constant.");
1442                         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGB, 0, 0);
1443                         expectError(GL_INVALID_ENUM);
1444                         m_log << TestLog::EndSection;
1445
1446                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the combination of internalFormat of the previously specified texture array, format and type is not valid.");
1447                         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGBA, GL_UNSIGNED_SHORT_5_6_5, 0);
1448                         expectError(GL_INVALID_OPERATION);
1449                         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, 0);
1450                         expectError(GL_INVALID_OPERATION);
1451                         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, 0);
1452                         expectError(GL_INVALID_OPERATION);
1453                         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, 0);
1454                         expectError(GL_INVALID_OPERATION);
1455                         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGBA_INTEGER, GL_UNSIGNED_INT, 0);
1456                         expectError(GL_INVALID_OPERATION);
1457                         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGB, GL_FLOAT, 0);
1458                         expectError(GL_INVALID_OPERATION);
1459                         m_log << tcu::TestLog::EndSection;
1460
1461                         glDeleteTextures        (1, &texture);
1462                 });
1463         ES3F_ADD_API_CASE(texsubimage2d_neg_level, "Invalid glTexSubImage2D() usage",
1464                 {
1465                         deUint32                        textures[2];
1466                         glGenTextures           (2, &textures[0]);
1467                         glBindTexture           (GL_TEXTURE_2D, textures[0]);
1468                         glTexImage2D            (GL_TEXTURE_2D, 0, GL_RGB, 32, 32, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1469                         glBindTexture           (GL_TEXTURE_2D, textures[1]);
1470                         FOR_CUBE_FACES(faceGL, glTexImage2D(faceGL, 0, GL_RGB, 32, 32, 0, GL_RGB, GL_UNSIGNED_BYTE, 0););
1471                         expectError                     (GL_NO_ERROR);
1472
1473                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
1474                         glTexSubImage2D(GL_TEXTURE_2D, -1, 0, 0, 0, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1475                         expectError(GL_INVALID_VALUE);
1476                         m_log << TestLog::EndSection;
1477
1478                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
1479                         FOR_CUBE_FACES(faceGL,
1480                         {
1481                                 glTexSubImage2D(faceGL, -1, 0, 0, 0, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1482                                 expectError(GL_INVALID_VALUE);
1483                         });
1484                         m_log << TestLog::EndSection;
1485
1486                         glDeleteTextures(2, &textures[0]);
1487                 });
1488         ES3F_ADD_API_CASE(texsubimage2d_max_level, "Invalid glTexSubImage2D() usage",
1489                 {
1490                         deUint32                        textures[2];
1491                         glGenTextures           (2, &textures[0]);
1492                         glBindTexture           (GL_TEXTURE_2D, textures[0]);
1493                         glTexImage2D            (GL_TEXTURE_2D, 0, GL_RGB, 32, 32, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1494                         glBindTexture           (GL_TEXTURE_CUBE_MAP, textures[1]);
1495                         FOR_CUBE_FACES(faceGL, glTexImage2D(faceGL, 0, GL_RGB, 32, 32, 0, GL_RGB, GL_UNSIGNED_BYTE, 0););
1496                         expectError                     (GL_NO_ERROR);
1497
1498                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
1499                         deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
1500                         glTexSubImage2D(GL_TEXTURE_2D, log2MaxTextureSize, 0, 0, 0, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1501                         expectError(GL_INVALID_VALUE);
1502                         m_log << TestLog::EndSection;
1503
1504                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_TEXTURE_SIZE).");
1505                         deUint32 log2MaxCubemapSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
1506                         FOR_CUBE_FACES(faceGL,
1507                         {
1508                                 glTexSubImage2D(faceGL, log2MaxCubemapSize, 0, 0, 0, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1509                                 expectError(GL_INVALID_VALUE);
1510                         });
1511                         m_log << TestLog::EndSection;
1512
1513                         glDeleteTextures(2, &textures[0]);
1514                 });
1515         ES3F_ADD_API_CASE(texsubimage2d_neg_offset, "Invalid glTexSubImage2D() usage",
1516                 {
1517                         deUint32 texture;
1518                         glGenTextures(1, &texture);
1519                         glBindTexture(GL_TEXTURE_2D, texture);
1520                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 32, 32, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1521                         expectError(GL_NO_ERROR);
1522
1523                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if xoffset or yoffset are negative.");
1524                         glTexSubImage2D(GL_TEXTURE_2D, 0, -1, 0, 0, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1525                         expectError(GL_INVALID_VALUE);
1526                         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, -1, 0, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1527                         expectError(GL_INVALID_VALUE);
1528                         glTexSubImage2D(GL_TEXTURE_2D, 0, -1, -1, 0, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1529                         expectError(GL_INVALID_VALUE);
1530                         m_log << TestLog::EndSection;
1531
1532                         glDeleteTextures(1, &texture);
1533                 });
1534         ES3F_ADD_API_CASE(texsubimage2d_invalid_offset, "Invalid glTexSubImage2D() usage",
1535                 {
1536                         deUint32                        texture;
1537                         glGenTextures           (1, &texture);
1538                         glBindTexture           (GL_TEXTURE_2D, texture);
1539                         glTexImage2D            (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1540                         expectError                     (GL_NO_ERROR);
1541
1542                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if xoffset + width > texture_width or yoffset + height > texture_height.");
1543                         glTexSubImage2D(GL_TEXTURE_2D, 0, 30, 0, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1544                         expectError(GL_INVALID_VALUE);
1545                         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 30, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1546                         expectError(GL_INVALID_VALUE);
1547                         glTexSubImage2D(GL_TEXTURE_2D, 0, 30, 30, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1548                         expectError(GL_INVALID_VALUE);
1549                         m_log << TestLog::EndSection;
1550
1551                         glDeleteTextures        (1, &texture);
1552                 });
1553         ES3F_ADD_API_CASE(texsubimage2d_neg_width_height, "Invalid glTexSubImage2D() usage",
1554                 {
1555                         deUint32                        texture;
1556                         glGenTextures           (1, &texture);
1557                         glBindTexture           (GL_TEXTURE_2D, texture);
1558                         glTexImage2D            (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1559                         expectError                     (GL_NO_ERROR);
1560
1561                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
1562                         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1563                         expectError(GL_INVALID_VALUE);
1564                         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, -1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1565                         expectError(GL_INVALID_VALUE);
1566                         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, -1, -1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1567                         expectError(GL_INVALID_VALUE);
1568                         m_log << TestLog::EndSection;
1569
1570                         glDeleteTextures        (1, &texture);
1571                 });
1572         ES3F_ADD_API_CASE(texsubimage2d_invalid_buffer_target, "Invalid glTexSubImage2D() usage",
1573                 {
1574                         deUint32                                buf;
1575                         deUint32                                texture;
1576                         std::vector<GLubyte>    data(64);
1577
1578                         glGenTextures                   (1, &texture);
1579                         glBindTexture                   (GL_TEXTURE_2D, texture);
1580                         glTexImage2D                    (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1581                         glGenBuffers                    (1, &buf);
1582                         glBindBuffer                    (GL_PIXEL_UNPACK_BUFFER, buf);
1583                         glBufferData                    (GL_PIXEL_UNPACK_BUFFER, 64, &data[0], GL_DYNAMIC_COPY);
1584                         expectError                             (GL_NO_ERROR);
1585
1586                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and...");
1587                         m_log << TestLog::Section("", "...the buffer object's data store is currently mapped.");
1588                         glMapBufferRange                (GL_PIXEL_UNPACK_BUFFER, 0, 32, GL_MAP_WRITE_BIT);
1589                         glTexSubImage2D                 (GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1590                         expectError                             (GL_INVALID_OPERATION);
1591                         glUnmapBuffer                   (GL_PIXEL_UNPACK_BUFFER);
1592                         m_log << TestLog::EndSection;
1593
1594                         m_log << TestLog::Section("", "...the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
1595                         glTexSubImage2D                 (GL_TEXTURE_2D, 0, 0, 0, 32, 32, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1596                         expectError                             (GL_INVALID_OPERATION);
1597                         m_log << TestLog::EndSection;
1598
1599                         m_log << TestLog::Section("", "...data is not evenly divisible into the number of bytes needed to store in memory a datum indicated by type.");
1600                         m_log << TestLog::Message << "// Set byte offset = 3" << TestLog::EndMessage;
1601                         glBindBuffer                    (GL_PIXEL_UNPACK_BUFFER, 0);
1602                         glTexImage2D                    (GL_TEXTURE_2D, 0, GL_RGBA4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, 0);
1603                         glBindBuffer                    (GL_PIXEL_UNPACK_BUFFER, buf);
1604                         expectError                             (GL_NO_ERROR);
1605                         glTexSubImage2D                 (GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, (const GLvoid*)3);
1606                         expectError                             (GL_INVALID_OPERATION);
1607                         m_log << TestLog::EndSection;
1608                         m_log << TestLog::EndSection;
1609
1610                         glDeleteBuffers                 (1, &buf);
1611                         glDeleteTextures                (1, &texture);
1612                 });
1613
1614         // glTexParameteri
1615
1616         ES3F_ADD_API_CASE(texparameteri, "Invalid glTexParameteri() usage",
1617                 {
1618                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1619                         glTexParameteri(0, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1620                         expectError(GL_INVALID_ENUM);
1621                         glTexParameteri(GL_TEXTURE_2D, 0, GL_LINEAR);
1622                         expectError(GL_INVALID_ENUM);
1623                         glTexParameteri(0, 0, GL_LINEAR);
1624                         expectError(GL_INVALID_ENUM);
1625                         m_log << TestLog::EndSection;
1626
1627                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined symbolic constant value (based on the value of pname) and does not.");
1628                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 0);
1629                         expectError(GL_INVALID_ENUM);
1630                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_REPEAT);
1631                         expectError(GL_INVALID_ENUM);
1632                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, 0);
1633                         expectError(GL_INVALID_ENUM);
1634                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_NEAREST);
1635                         expectError(GL_INVALID_ENUM);
1636                         m_log << TestLog::EndSection;
1637
1638                         GLuint texture;
1639                         glGenTextures(1, &texture);
1640                         glBindTexture(GL_TEXTURE_2D, texture);
1641
1642                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1643                         glTexParameteri(0, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1644                         expectError(GL_INVALID_ENUM);
1645                         glTexParameteri(GL_TEXTURE_2D, 0, GL_LINEAR);
1646                         expectError(GL_INVALID_ENUM);
1647                         glTexParameteri(0, 0, GL_LINEAR);
1648                         expectError(GL_INVALID_ENUM);
1649                         m_log << TestLog::EndSection;
1650
1651                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined symbolic constant value (based on the value of pname) and does not.");
1652                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 0);
1653                         expectError(GL_INVALID_ENUM);
1654                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_REPEAT);
1655                         expectError(GL_INVALID_ENUM);
1656                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, 0);
1657                         expectError(GL_INVALID_ENUM);
1658                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_NEAREST);
1659                         expectError(GL_INVALID_ENUM);
1660                         m_log << TestLog::EndSection;
1661
1662                         glDeleteTextures(1, &texture);
1663                 });
1664
1665         // glTexParameterf
1666
1667         ES3F_ADD_API_CASE(texparameterf, "Invalid glTexParameterf() usage",
1668                 {
1669                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1670                         glTexParameterf(0, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1671                         expectError(GL_INVALID_ENUM);
1672                         glTexParameterf(GL_TEXTURE_2D, 0, GL_LINEAR);
1673                         expectError(GL_INVALID_ENUM);
1674                         glTexParameterf(0, 0, GL_LINEAR);
1675                         expectError(GL_INVALID_ENUM);
1676                         m_log << TestLog::EndSection;
1677
1678                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined symbolic constant value (based on the value of pname) and does not.");
1679                         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 0);
1680                         expectError(GL_INVALID_ENUM);
1681                         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_REPEAT);
1682                         expectError(GL_INVALID_ENUM);
1683                         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, 0);
1684                         expectError(GL_INVALID_ENUM);
1685                         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_NEAREST);
1686                         expectError(GL_INVALID_ENUM);
1687                         m_log << TestLog::EndSection;
1688
1689                         GLuint texture;
1690                         glGenTextures(1, &texture);
1691                         glBindTexture(GL_TEXTURE_2D, texture);
1692
1693                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1694                         glTexParameterf(0, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1695                         expectError(GL_INVALID_ENUM);
1696                         glTexParameterf(GL_TEXTURE_2D, 0, GL_LINEAR);
1697                         expectError(GL_INVALID_ENUM);
1698                         glTexParameterf(0, 0, GL_LINEAR);
1699                         expectError(GL_INVALID_ENUM);
1700                         m_log << TestLog::EndSection;
1701
1702                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined symbolic constant value (based on the value of pname) and does not.");
1703                         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 0);
1704                         expectError(GL_INVALID_ENUM);
1705                         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_REPEAT);
1706                         expectError(GL_INVALID_ENUM);
1707                         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, 0);
1708                         expectError(GL_INVALID_ENUM);
1709                         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_NEAREST);
1710                         expectError(GL_INVALID_ENUM);
1711                         m_log << TestLog::EndSection;
1712
1713                         glDeleteTextures(1, &texture);
1714                 });
1715
1716         // glTexParameteriv
1717
1718         ES3F_ADD_API_CASE(texparameteriv, "Invalid glTexParameteriv() usage",
1719                 {
1720                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1721                         GLint params[1] = {GL_LINEAR};
1722                         glTexParameteriv(0, GL_TEXTURE_MIN_FILTER, &params[0]);
1723                         expectError(GL_INVALID_ENUM);
1724                         glTexParameteriv(GL_TEXTURE_2D, 0, &params[0]);
1725                         expectError(GL_INVALID_ENUM);
1726                         glTexParameteriv(0, 0, &params[0]);
1727                         expectError(GL_INVALID_ENUM);
1728                         m_log << TestLog::EndSection;
1729
1730                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined symbolic constant value (based on the value of pname) and does not.");
1731                         params[0] = 0;
1732                         glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &params[0]);
1733                         expectError(GL_INVALID_ENUM);
1734                         params[0] = GL_REPEAT;
1735                         glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &params[0]);
1736                         expectError(GL_INVALID_ENUM);
1737                         params[0] = 0;
1738                         glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, &params[0]);
1739                         expectError(GL_INVALID_ENUM);
1740                         params[0] = GL_NEAREST;
1741                         glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, &params[0]);
1742                         expectError(GL_INVALID_ENUM);
1743                         m_log << TestLog::EndSection;
1744
1745                         GLuint texture;
1746                         glGenTextures(1, &texture);
1747                         glBindTexture(GL_TEXTURE_2D, texture);
1748
1749                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1750                         params[0] = GL_LINEAR;
1751                         glTexParameteriv(0, GL_TEXTURE_MIN_FILTER, &params[0]);
1752                         expectError(GL_INVALID_ENUM);
1753                         glTexParameteriv(GL_TEXTURE_2D, 0, &params[0]);
1754                         expectError(GL_INVALID_ENUM);
1755                         glTexParameteriv(0, 0, &params[0]);
1756                         expectError(GL_INVALID_ENUM);
1757                         m_log << TestLog::EndSection;
1758
1759                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined symbolic constant value (based on the value of pname) and does not.");
1760                         params[0] = 0;
1761                         glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &params[0]);
1762                         expectError(GL_INVALID_ENUM);
1763                         params[0] = GL_REPEAT;
1764                         glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &params[0]);
1765                         expectError(GL_INVALID_ENUM);
1766                         params[0] = 0;
1767                         glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, &params[0]);
1768                         expectError(GL_INVALID_ENUM);
1769                         params[0] = GL_NEAREST;
1770                         glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, &params[0]);
1771                         expectError(GL_INVALID_ENUM);
1772                         m_log << TestLog::EndSection;
1773
1774                         glDeleteTextures(1, &texture);
1775                 });
1776
1777         // glTexParameterfv
1778
1779         ES3F_ADD_API_CASE(texparameterfv, "Invalid glTexParameterfv() usage",
1780                 {
1781                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1782                         GLfloat params[1] = {GL_LINEAR};
1783                         glTexParameterfv(0, GL_TEXTURE_MIN_FILTER, &params[0]);
1784                         expectError(GL_INVALID_ENUM);
1785                         glTexParameterfv(GL_TEXTURE_2D, 0, &params[0]);
1786                         expectError(GL_INVALID_ENUM);
1787                         glTexParameterfv(0, 0, &params[0]);
1788                         expectError(GL_INVALID_ENUM);
1789                         m_log << TestLog::EndSection;
1790
1791                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined symbolic constant value (based on the value of pname) and does not.");
1792                         params[0] = 0.0f;
1793                         glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &params[0]);
1794                         expectError(GL_INVALID_ENUM);
1795                         params[0] = GL_REPEAT;
1796                         glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &params[0]);
1797                         expectError(GL_INVALID_ENUM);
1798                         params[0] = 0.0f;
1799                         glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, &params[0]);
1800                         expectError(GL_INVALID_ENUM);
1801                         params[0] = GL_NEAREST;
1802                         glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, &params[0]);
1803                         expectError(GL_INVALID_ENUM);
1804                         m_log << TestLog::EndSection;
1805
1806                         GLuint texture;
1807                         glGenTextures(1, &texture);
1808                         glBindTexture(GL_TEXTURE_2D, texture);
1809
1810                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1811                         params[0] = GL_LINEAR;
1812                         glTexParameterfv(0, GL_TEXTURE_MIN_FILTER, &params[0]);
1813                         expectError(GL_INVALID_ENUM);
1814                         glTexParameterfv(GL_TEXTURE_2D, 0, &params[0]);
1815                         expectError(GL_INVALID_ENUM);
1816                         glTexParameterfv(0, 0, &params[0]);
1817                         expectError(GL_INVALID_ENUM);
1818                         m_log << TestLog::EndSection;
1819
1820                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined symbolic constant value (based on the value of pname) and does not.");
1821                         params[0] = 0.0f;
1822                         glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &params[0]);
1823                         expectError(GL_INVALID_ENUM);
1824                         params[0] = GL_REPEAT;
1825                         glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &params[0]);
1826                         expectError(GL_INVALID_ENUM);
1827                         params[0] = 0.0f;
1828                         glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, &params[0]);
1829                         expectError(GL_INVALID_ENUM);
1830                         params[0] = GL_NEAREST;
1831                         glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, &params[0]);
1832                         expectError(GL_INVALID_ENUM);
1833                         m_log << TestLog::EndSection;
1834
1835                         glDeleteTextures(1, &texture);
1836                 });
1837
1838         // glCompressedTexSubImage2D
1839
1840         ES3F_ADD_API_CASE(compressedtexsubimage2d, "Invalid glCompressedTexSubImage2D() usage",
1841                 {
1842                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is invalid.");
1843                         glCompressedTexSubImage2D(0, 0, 0, 0, 0, 0, GL_COMPRESSED_RGB8_ETC2, 0, 0);
1844                         expectError(GL_INVALID_ENUM);
1845                         m_log << TestLog::EndSection;
1846
1847                         deUint32                                texture;
1848                         glGenTextures                   (1, &texture);
1849                         glBindTexture                   (GL_TEXTURE_2D, texture);
1850                         glCompressedTexImage2D  (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 0, etc2EacDataSize(18, 18), 0);
1851                         expectError                             (GL_NO_ERROR);
1852
1853                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if format does not match the internal format of the texture image being modified.");
1854                         glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, GL_COMPRESSED_RGB8_ETC2, 0, 0);
1855                         expectError(GL_INVALID_OPERATION);
1856                         m_log << TestLog::EndSection;
1857
1858                         m_log << TestLog::Section("", "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.");
1859                         glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 4, 0, 10, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(10, 4), 0);
1860                         expectError(GL_INVALID_OPERATION);
1861                         m_log << TestLog::EndSection;
1862
1863                         m_log << TestLog::Section("", "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.");
1864                         glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 4, 4, 10, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 10), 0);
1865                         expectError(GL_INVALID_OPERATION);
1866                         m_log << TestLog::EndSection;
1867
1868                         m_log << TestLog::Section("", "For ETC2/EAC images GL_INVALID_OPERATION is generated if xoffset or yoffset is not a multiple of four.");
1869                         glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 1, 4, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
1870                         expectError(GL_INVALID_OPERATION);
1871                         glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 1, 0, 4, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
1872                         expectError(GL_INVALID_OPERATION);
1873                         glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 1, 1, 4, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
1874                         expectError(GL_INVALID_OPERATION);
1875                         m_log << TestLog::EndSection;
1876
1877                         glDeleteTextures                (1, &texture);
1878                 });
1879         ES3F_ADD_API_CASE(compressedtexsubimage2d_neg_level, "Invalid glCompressedTexSubImage2D() usage",
1880                 {
1881                         deUint32                                textures[2];
1882                         glGenTextures                   (2, &textures[0]);
1883                         glBindTexture                   (GL_TEXTURE_2D, textures[0]);
1884                         glCompressedTexImage2D  (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 0, etc2EacDataSize(18, 18), 0);
1885                         glBindTexture                   (GL_TEXTURE_CUBE_MAP, textures[1]);
1886                         FOR_CUBE_FACES(faceGL, glCompressedTexImage2D(faceGL, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 0, etc2EacDataSize(18, 18), 0););
1887                         expectError                             (GL_NO_ERROR);
1888
1889                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
1890                         glCompressedTexSubImage2D(GL_TEXTURE_2D, -1, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
1891                         expectError(GL_INVALID_VALUE);
1892                         m_log << TestLog::EndSection;
1893
1894                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
1895                         FOR_CUBE_FACES(faceGL,
1896                         {
1897                                 glCompressedTexSubImage2D(faceGL, -1, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
1898                                 expectError(GL_INVALID_VALUE);
1899                         });
1900                         m_log << TestLog::EndSection;
1901
1902                         glDeleteTextures(2, &textures[0]);
1903                 });
1904         ES3F_ADD_API_CASE(compressedtexsubimage2d_max_level, "Invalid glCompressedTexSubImage2D() usage",
1905                 {
1906                         deUint32                                textures[2];
1907                         glGenTextures                   (2, &textures[0]);
1908                         glBindTexture                   (GL_TEXTURE_2D, textures[0]);
1909                         glCompressedTexImage2D  (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 0, etc2EacDataSize(18, 18), 0);
1910                         glBindTexture                   (GL_TEXTURE_CUBE_MAP, textures[1]);
1911                         FOR_CUBE_FACES(faceGL, glCompressedTexImage2D(faceGL, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 0, etc2EacDataSize(18, 18), 0););
1912                         expectError                             (GL_NO_ERROR);
1913
1914                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
1915                         deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
1916                         glCompressedTexSubImage2D(GL_TEXTURE_2D, log2MaxTextureSize, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
1917                         expectError(GL_INVALID_VALUE);
1918                         m_log << TestLog::EndSection;
1919
1920                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_TEXTURE_SIZE).");
1921                         deUint32 log2MaxCubemapSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
1922                         FOR_CUBE_FACES(faceGL,
1923                         {
1924                                 glCompressedTexSubImage2D(faceGL, log2MaxCubemapSize, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
1925                                 expectError(GL_INVALID_VALUE);
1926                         });
1927                         m_log << TestLog::EndSection;
1928
1929                         glDeleteTextures(2, &textures[0]);
1930                 });
1931                 ES3F_ADD_API_CASE(compressedtexsubimage2d_neg_offset, "Invalid glCompressedTexSubImage2D() usage",
1932                 {
1933                         GLuint texture;
1934                         glGenTextures(1, &texture);
1935                         glBindTexture(GL_TEXTURE_2D, texture);
1936                         glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 8, 8, 0, etc2EacDataSize(8, 8), 0);
1937
1938                         // \note Both GL_INVALID_VALUE and GL_INVALID_OPERATION are valid here since implementation may
1939                         //               first check if offsets are valid for certain format and only after that check that they
1940                         //               are not negative.
1941                         m_log << TestLog::Section("", "GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if xoffset or yoffset are negative.");
1942
1943                         glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, -4, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
1944                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
1945                         glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, -4, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
1946                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
1947                         glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, -4, -4, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
1948                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
1949
1950                         m_log << TestLog::EndSection;
1951
1952                         glDeleteTextures(1, &texture);
1953                 });
1954         ES3F_ADD_API_CASE(compressedtexsubimage2d_invalid_offset, "Invalid glCompressedTexSubImage2D() usage",
1955                 {
1956                         deUint32                                texture;
1957                         glGenTextures                   (1, &texture);
1958                         glBindTexture                   (GL_TEXTURE_2D, texture);
1959                         glCompressedTexImage2D  (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
1960                         expectError                             (GL_NO_ERROR);
1961
1962                         m_log << TestLog::Section("", "GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if xoffset + width > texture_width or yoffset + height > texture_height.");
1963
1964                         glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 12, 0, 8, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(8, 4), 0);
1965                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
1966                         glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 12, 4, 8, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 8), 0);
1967                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
1968                         glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 12, 12, 8, 8, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(8, 8), 0);
1969                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
1970                         m_log << TestLog::EndSection;
1971
1972                         glDeleteTextures                (1, &texture);
1973                 });
1974         ES3F_ADD_API_CASE(compressedtexsubimage2d_neg_width_height, "Invalid glCompressedTexSubImage2D() usage",
1975                 {
1976                         deUint32                                texture;
1977                         glGenTextures                   (1, &texture);
1978                         glBindTexture                   (GL_TEXTURE_2D, texture);
1979                         glCompressedTexImage2D  (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
1980                         expectError                             (GL_NO_ERROR);
1981
1982                         m_log << TestLog::Section("", "GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if width or height is less than 0.");
1983                         glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, -4, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
1984                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
1985                         glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, -4, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
1986                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
1987                         glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, -4, -4, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
1988                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
1989                         m_log << TestLog::EndSection;
1990
1991                         glDeleteTextures(1,             &texture);
1992                 });
1993         ES3F_ADD_API_CASE(compressedtexsubimage2d_invalid_size, "Invalid glCompressedTexImage2D() usage",
1994                 {
1995                         deUint32                                texture;
1996                         glGenTextures                   (1, &texture);
1997                         glBindTexture                   (GL_TEXTURE_2D, texture);
1998                         glCompressedTexImage2D  (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
1999                         expectError                             (GL_NO_ERROR);
2000
2001                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if imageSize is not consistent with the format, dimensions, and contents of the specified compressed image data.");
2002                         glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0);
2003                         expectError(GL_INVALID_VALUE);
2004
2005                         glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 16, 16, GL_COMPRESSED_RGBA8_ETC2_EAC, 4*4*16-1, 0);
2006                         expectError(GL_INVALID_VALUE);
2007                         m_log << TestLog::EndSection;
2008
2009                         glDeleteTextures                (1, &texture);
2010                 });
2011         ES3F_ADD_API_CASE(compressedtexsubimage2d_invalid_buffer_target, "Invalid glCompressedTexSubImage2D() usage",
2012                 {
2013                         deUint32                                        buf;
2014                         deUint32                                        texture;
2015                         std::vector<GLubyte>            data(128);
2016
2017                         glGenTextures                           (1, &texture);
2018                         glBindTexture                           (GL_TEXTURE_2D, texture);
2019                         glCompressedTexImage2D          (GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 0, etc2EacDataSize(16, 16), 0);
2020                         glGenBuffers                            (1, &buf);
2021                         glBindBuffer                            (GL_PIXEL_UNPACK_BUFFER, buf);
2022                         glBufferData                            (GL_PIXEL_UNPACK_BUFFER, 128, &data[0], GL_DYNAMIC_COPY);
2023                         expectError                                     (GL_NO_ERROR);
2024
2025                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and...");
2026                         m_log << TestLog::Section("", "...the buffer object's data store is currently mapped.");
2027                         glMapBufferRange                        (GL_PIXEL_UNPACK_BUFFER, 0, 128, GL_MAP_WRITE_BIT);
2028                         glCompressedTexSubImage2D       (GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
2029                         expectError                                     (GL_INVALID_OPERATION);
2030                         glUnmapBuffer                           (GL_PIXEL_UNPACK_BUFFER);
2031                         m_log << TestLog::EndSection;
2032
2033                         m_log << TestLog::Section("", "...the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
2034                         glCompressedTexSubImage2D       (GL_TEXTURE_2D, 0, 0, 0, 16, 16, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(16, 16), 0);
2035                         expectError                                     (GL_INVALID_OPERATION);
2036                         m_log << TestLog::EndSection;
2037                         m_log << TestLog::EndSection;
2038
2039                         glDeleteBuffers                 (1, &buf);
2040                         glDeleteTextures                (1, &texture);
2041                 });
2042
2043         // glTexImage3D
2044
2045         ES3F_ADD_API_CASE(teximage3d, "Invalid glTexImage3D() usage",
2046                 {
2047                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is invalid.");
2048                         glTexImage3D(0, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2049                         expectError(GL_INVALID_ENUM);
2050                         glTexImage3D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2051                         expectError(GL_INVALID_ENUM);
2052                         m_log << TestLog::EndSection;
2053
2054                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if type is not a type constant.");
2055                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, 0, 0);
2056                         expectError(GL_INVALID_ENUM);
2057                         m_log << TestLog::EndSection;
2058
2059                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if format is not an accepted format constant.");
2060                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, 1, 0, 0, GL_UNSIGNED_BYTE, 0);
2061                         expectError(GL_INVALID_ENUM);
2062                         m_log << TestLog::EndSection;
2063
2064                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if internalFormat is not one of the accepted resolution and format symbolic constants "
2065                                                                                   "or GL_INVALID_OPERATION is generated if internalformat, format and type are not compatible.");
2066                         glTexImage3D(GL_TEXTURE_3D, 0, 0, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2067                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2068                         m_log << TestLog::EndSection;
2069
2070                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if target is GL_TEXTURE_3D and format is GL_DEPTH_COMPONENT, or GL_DEPTH_STENCIL.");
2071                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, 1, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_BYTE, 0);
2072                         expectError(GL_INVALID_OPERATION);
2073                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, 1, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0);
2074                         expectError(GL_INVALID_OPERATION);
2075                         m_log << TestLog::EndSection;
2076
2077                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the combination of internalFormat, format and type is invalid.");
2078                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2079                         expectError(GL_INVALID_OPERATION);
2080                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, 0);
2081                         expectError(GL_INVALID_OPERATION);
2082                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB5_A1, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, 0);
2083                         expectError(GL_INVALID_OPERATION);
2084                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB10_A2, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_INT_2_10_10_10_REV, 0);
2085                         expectError(GL_INVALID_OPERATION);
2086                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA32UI, 1, 1, 1, 0, GL_RGBA_INTEGER, GL_INT, 0);
2087                         expectError(GL_INVALID_OPERATION);
2088                         m_log << TestLog::EndSection;
2089                 });
2090         ES3F_ADD_API_CASE(teximage3d_neg_level, "Invalid glTexImage3D() usage",
2091                 {
2092                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
2093                         glTexImage3D(GL_TEXTURE_3D, -1, GL_RGB, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
2094                         expectError(GL_INVALID_VALUE);
2095                         glTexImage3D(GL_TEXTURE_2D_ARRAY, -1, GL_RGB, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
2096                         expectError(GL_INVALID_VALUE);
2097                         m_log << TestLog::EndSection;
2098                 });
2099         ES3F_ADD_API_CASE(teximage3d_max_level, "Invalid glTexImage3D() usage",
2100                 {
2101                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_3D_TEXTURE_SIZE).");
2102                         deUint32 log2Max3DTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_3D_TEXTURE_SIZE)) + 1;
2103                         glTexImage3D(GL_TEXTURE_3D, log2Max3DTextureSize, GL_RGB, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
2104                         expectError(GL_INVALID_VALUE);
2105                         m_log << TestLog::EndSection;
2106
2107                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
2108                         deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
2109                         glTexImage3D(GL_TEXTURE_2D_ARRAY, log2MaxTextureSize, GL_RGB, 1, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
2110                         expectError(GL_INVALID_VALUE);
2111                         m_log << TestLog::EndSection;
2112                 });
2113         ES3F_ADD_API_CASE(teximage3d_neg_width_height_depth, "Invalid glTexImage3D() usage",
2114                 {
2115                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
2116                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, -1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2117                         expectError(GL_INVALID_VALUE);
2118                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, -1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2119                         expectError(GL_INVALID_VALUE);
2120                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2121                         expectError(GL_INVALID_VALUE);
2122                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, -1, -1, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2123                         expectError(GL_INVALID_VALUE);
2124
2125                         glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, -1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2126                         expectError(GL_INVALID_VALUE);
2127                         glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 1, -1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2128                         expectError(GL_INVALID_VALUE);
2129                         glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 1, 1, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2130                         expectError(GL_INVALID_VALUE);
2131                         glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, -1, -1, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2132                         expectError(GL_INVALID_VALUE);
2133                         m_log << TestLog::EndSection;
2134                 });
2135         ES3F_ADD_API_CASE(teximage3d_max_width_height_depth, "Invalid glTexImage3D() usage",
2136                 {
2137                         int max3DTextureSize    = m_context.getContextInfo().getInt(GL_MAX_3D_TEXTURE_SIZE) + 1;
2138                         int maxTextureSize              = m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE) + 1;
2139
2140                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width, height or depth is greater than GL_MAX_3D_TEXTURE_SIZE.");
2141                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, max3DTextureSize, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2142                         expectError(GL_INVALID_VALUE);
2143                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, max3DTextureSize, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2144                         expectError(GL_INVALID_VALUE);
2145                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 1, 1, max3DTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2146                         expectError(GL_INVALID_VALUE);
2147                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, max3DTextureSize, max3DTextureSize, max3DTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2148                         expectError(GL_INVALID_VALUE);
2149                         m_log << TestLog::EndSection;
2150
2151                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width, height or depth is greater than GL_MAX_TEXTURE_SIZE.");
2152                         glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, maxTextureSize, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2153                         expectError(GL_INVALID_VALUE);
2154                         glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 1, maxTextureSize, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2155                         expectError(GL_INVALID_VALUE);
2156                         glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 1, 1, maxTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2157                         expectError(GL_INVALID_VALUE);
2158                         glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, maxTextureSize, maxTextureSize, maxTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2159                         expectError(GL_INVALID_VALUE);
2160                         m_log << TestLog::EndSection;
2161                 });
2162         ES3F_ADD_API_CASE(teximage3d_invalid_border, "Invalid glTexImage3D() usage",
2163                 {
2164                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0 or 1.");
2165                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, 1, 1, 1, -1, GL_RGB, GL_UNSIGNED_BYTE, 0);
2166                         expectError(GL_INVALID_VALUE);
2167                         glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, 1, 1, 1, 2, GL_RGB, GL_UNSIGNED_BYTE, 0);
2168                         expectError(GL_INVALID_VALUE);
2169                         glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGB, 1, 1, 1, -1, GL_RGB, GL_UNSIGNED_BYTE, 0);
2170                         expectError(GL_INVALID_VALUE);
2171                         glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGB, 1, 1, 1, 2, GL_RGB, GL_UNSIGNED_BYTE, 0);
2172                         expectError(GL_INVALID_VALUE);
2173                         m_log << TestLog::EndSection;
2174                 });
2175         ES3F_ADD_API_CASE(teximage3d_invalid_buffer_target, "Invalid glTexImage3D() usage",
2176                 {
2177                         deUint32                                buf;
2178                         deUint32                                texture;
2179                         std::vector<GLubyte>    data(512);
2180
2181                         glGenBuffers                    (1, &buf);
2182                         glBindBuffer                    (GL_PIXEL_UNPACK_BUFFER, buf);
2183                         glBufferData                    (GL_PIXEL_UNPACK_BUFFER, 512, &data[0], GL_DYNAMIC_COPY);
2184                         glGenTextures                   (1, &texture);
2185                         glBindTexture                   (GL_TEXTURE_3D, texture);
2186                         expectError                             (GL_NO_ERROR);
2187
2188                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and...");
2189
2190                         m_log << TestLog::Section("", "...the buffer object's data store is currently mapped.");
2191                         glMapBufferRange                (GL_PIXEL_UNPACK_BUFFER, 0, 128, GL_MAP_WRITE_BIT);
2192                         glTexImage3D                    (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2193                         expectError                             (GL_INVALID_OPERATION);
2194                         glUnmapBuffer                   (GL_PIXEL_UNPACK_BUFFER);
2195                         m_log << TestLog::EndSection;
2196
2197                         m_log << TestLog::Section("", "...the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
2198                         glTexImage3D                    (GL_TEXTURE_3D, 0, GL_RGBA, 64, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2199                         expectError                             (GL_INVALID_OPERATION);
2200                         m_log << TestLog::EndSection;
2201
2202                         m_log << TestLog::Section("", "...data is not evenly divisible into the number of bytes needed to store in memory a datum indicated by type.");
2203                         m_log << TestLog::Message << "// Set byte offset = 3" << TestLog::EndMessage;
2204                         glTexImage3D                    (GL_TEXTURE_3D, 0, GL_RGB5_A1, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, (const GLvoid*)3);
2205                         expectError                             (GL_INVALID_OPERATION);
2206                         m_log << TestLog::EndSection;
2207
2208                         m_log << TestLog::EndSection;
2209
2210                         glDeleteBuffers                 (1, &buf);
2211                         glDeleteTextures                (1, &texture);
2212                 });
2213
2214         // glTexSubImage3D
2215
2216         ES3F_ADD_API_CASE(texsubimage3d, "Invalid glTexSubImage3D() usage",
2217                 {
2218                         deUint32                        texture;
2219                         glGenTextures           (1, &texture);
2220                         glBindTexture           (GL_TEXTURE_3D, texture);
2221                         glTexImage3D            (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2222                         expectError                     (GL_NO_ERROR);
2223
2224                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is invalid.");
2225                         glTexSubImage3D(0, 0, 0, 0, 0, 4, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2226                         expectError(GL_INVALID_ENUM);
2227                         glTexSubImage3D(GL_TEXTURE_2D, 0, 0, 0, 0, 4, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2228                         expectError(GL_INVALID_ENUM);
2229                         m_log << TestLog::EndSection;
2230
2231                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if format is not an accepted format constant.");
2232                         glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 4, 4, 4, GL_UNSIGNED_BYTE, 0);
2233                         expectError(GL_INVALID_ENUM);
2234                         m_log << TestLog::EndSection;
2235
2236                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if type is not a type constant.");
2237                         glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGB, 0, 0);
2238                         expectError(GL_INVALID_ENUM);
2239                         m_log << TestLog::EndSection;
2240
2241                         m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if the combination of internalFormat of the previously specified texture array, format and type is not valid.");
2242                         glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, 0);
2243                         expectError(GL_INVALID_OPERATION);
2244                         glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, 0);
2245                         expectError(GL_INVALID_OPERATION);
2246                         glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, 0);
2247                         expectError(GL_INVALID_OPERATION);
2248                         glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGBA_INTEGER, GL_UNSIGNED_INT, 0);
2249                         expectError(GL_INVALID_OPERATION);
2250                         glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGB, GL_FLOAT, 0);
2251                         expectError(GL_INVALID_OPERATION);
2252                         m_log << tcu::TestLog::EndSection;
2253
2254                         glDeleteTextures        (1, &texture);
2255                 });
2256         ES3F_ADD_API_CASE(texsubimage3d_neg_level, "Invalid glTexSubImage3D() usage",
2257                 {
2258                         deUint32                        textures[2];
2259                         glGenTextures           (2, &textures[0]);
2260                         glBindTexture           (GL_TEXTURE_3D, textures[0]);
2261                         glTexImage3D            (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2262                         glBindTexture           (GL_TEXTURE_2D_ARRAY, textures[1]);
2263                         glTexImage3D            (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2264                         expectError                     (GL_NO_ERROR);
2265
2266                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
2267                         glTexSubImage3D(GL_TEXTURE_3D, -1, 0, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2268                         expectError(GL_INVALID_VALUE);
2269                         glTexSubImage3D(GL_TEXTURE_2D_ARRAY, -1, 0, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2270                         expectError(GL_INVALID_VALUE);
2271                         m_log << TestLog::EndSection;
2272
2273                         glDeleteTextures        (2, &textures[0]);
2274                 });
2275         ES3F_ADD_API_CASE(texsubimage3d_max_level, "Invalid glTexSubImage3D() usage",
2276                 {
2277                         deUint32                        textures[2];
2278                         glGenTextures           (2, &textures[0]);
2279                         glBindTexture           (GL_TEXTURE_3D, textures[0]);
2280                         glTexImage3D            (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2281                         glBindTexture           (GL_TEXTURE_2D_ARRAY, textures[1]);
2282                         glTexImage3D            (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2283                         expectError                     (GL_NO_ERROR);
2284
2285                         deUint32 log2Max3DTextureSize   = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_3D_TEXTURE_SIZE)) + 1;
2286                         deUint32 log2MaxTextureSize             = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
2287
2288                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_3D_TEXTURE_SIZE).");
2289                         glTexSubImage3D(GL_TEXTURE_3D, log2Max3DTextureSize, 0, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2290                         expectError(GL_INVALID_VALUE);
2291                         m_log << TestLog::EndSection;
2292
2293                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
2294                         glTexSubImage3D(GL_TEXTURE_2D_ARRAY, log2MaxTextureSize, 0, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2295                         expectError(GL_INVALID_VALUE);
2296                         m_log << TestLog::EndSection;
2297
2298                         glDeleteTextures        (2, &textures[0]);
2299                 });
2300         ES3F_ADD_API_CASE(texsubimage3d_neg_offset, "Invalid glTexSubImage3D() usage",
2301                 {
2302                         deUint32                        textures[2];
2303                         glGenTextures           (2, &textures[0]);
2304                         glBindTexture           (GL_TEXTURE_3D, textures[0]);
2305                         glTexImage3D            (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2306                         glBindTexture           (GL_TEXTURE_2D_ARRAY, textures[1]);
2307                         glTexImage3D            (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2308                         expectError                     (GL_NO_ERROR);
2309
2310                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if xoffset, yoffset or zoffset are negative.");
2311                         glTexSubImage3D(GL_TEXTURE_3D, 0, -1, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2312                         expectError(GL_INVALID_VALUE);
2313                         glTexSubImage3D(GL_TEXTURE_3D, 0, 0, -1, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2314                         expectError(GL_INVALID_VALUE);
2315                         glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, -1, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2316                         expectError(GL_INVALID_VALUE);
2317                         glTexSubImage3D(GL_TEXTURE_3D, 0, -1, -1, -1, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2318                         expectError(GL_INVALID_VALUE);
2319                         glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, -1, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2320                         expectError(GL_INVALID_VALUE);
2321                         glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, -1, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2322                         expectError(GL_INVALID_VALUE);
2323                         glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, -1, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2324                         expectError(GL_INVALID_VALUE);
2325                         glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, -1, -1, -1, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2326                         expectError(GL_INVALID_VALUE);
2327                         m_log << TestLog::EndSection;
2328
2329                         glDeleteTextures        (2, &textures[0]);
2330                 });
2331         ES3F_ADD_API_CASE(texsubimage3d_invalid_offset, "Invalid glTexSubImage3D() usage",
2332                 {
2333                         deUint32                        texture;
2334                         glGenTextures           (1, &texture);
2335                         glBindTexture           (GL_TEXTURE_3D, texture);
2336                         glTexImage3D            (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2337                         expectError                     (GL_NO_ERROR);
2338
2339                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if xoffset + width > texture_width.");
2340                         glTexSubImage3D(GL_TEXTURE_3D, 0, 2, 0, 0, 4, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2341                         expectError(GL_INVALID_VALUE);
2342                         m_log << TestLog::EndSection;
2343
2344                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if yoffset + height > texture_height.");
2345                         glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 2, 0, 4, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2346                         expectError(GL_INVALID_VALUE);
2347                         m_log << TestLog::EndSection;
2348
2349                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if zoffset + depth > texture_depth.");
2350                         glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 2, 4, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2351                         expectError(GL_INVALID_VALUE);
2352                         m_log << TestLog::EndSection;
2353
2354                         glDeleteTextures        (1, &texture);
2355                 });
2356         ES3F_ADD_API_CASE(texsubimage3d_neg_width_height, "Invalid glTexSubImage3D() usage",
2357                 {
2358                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width, height or depth is less than 0.");
2359                         glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, -1, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2360                         expectError(GL_INVALID_VALUE);
2361                         glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2362                         expectError(GL_INVALID_VALUE);
2363                         glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, -1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2364                         expectError(GL_INVALID_VALUE);
2365                         glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, -1, -1, -1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2366                         expectError(GL_INVALID_VALUE);
2367                         m_log << TestLog::EndSection;
2368                 });
2369         ES3F_ADD_API_CASE(texsubimage3d_invalid_buffer_target, "Invalid glTexSubImage3D() usage",
2370                 {
2371                         deUint32                                buf;
2372                         deUint32                                texture;
2373                         std::vector<GLubyte>    data(512);
2374
2375                         glGenTextures                   (1, &texture);
2376                         glBindTexture                   (GL_TEXTURE_3D, texture);
2377                         glTexImage3D                    (GL_TEXTURE_3D, 0, GL_RGBA, 16, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2378                         glGenBuffers                    (1, &buf);
2379                         glBindBuffer                    (GL_PIXEL_UNPACK_BUFFER, buf);
2380                         glBufferData                    (GL_PIXEL_UNPACK_BUFFER, 512, &data[0], GL_DYNAMIC_COPY);
2381                         expectError                             (GL_NO_ERROR);
2382
2383                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and...");
2384
2385                         m_log << TestLog::Section("", "...the buffer object's data store is currently mapped.");
2386                         glMapBufferRange                (GL_PIXEL_UNPACK_BUFFER, 0, 512, GL_MAP_WRITE_BIT);
2387                         glTexSubImage3D                 (GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2388                         expectError                             (GL_INVALID_OPERATION);
2389                         glUnmapBuffer                   (GL_PIXEL_UNPACK_BUFFER);
2390                         m_log << TestLog::EndSection;
2391
2392                         m_log << TestLog::Section("", "...the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
2393                         glTexSubImage3D                 (GL_TEXTURE_3D, 0, 0, 0, 0, 16, 16, 16, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2394                         expectError                             (GL_INVALID_OPERATION);
2395                         m_log << TestLog::EndSection;
2396
2397                         m_log << TestLog::Section("", "...data is not evenly divisible into the number of bytes needed to store in memory a datum indicated by type.");
2398                         m_log << TestLog::Message << "// Set byte offset = 3" << TestLog::EndMessage;
2399                         glBindBuffer                    (GL_PIXEL_UNPACK_BUFFER, 0);
2400                         glTexImage3D                    (GL_TEXTURE_3D, 0, GL_RGBA4, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, 0);
2401                         glBindBuffer                    (GL_PIXEL_UNPACK_BUFFER, buf);
2402                         expectError                             (GL_NO_ERROR);
2403                         glTexSubImage3D                 (GL_TEXTURE_3D, 0, 0, 0, 0, 4, 4, 4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, (const GLvoid*)3);
2404                         expectError                             (GL_INVALID_OPERATION);
2405                         m_log << TestLog::EndSection;
2406
2407                         m_log << TestLog::EndSection;
2408
2409                         glDeleteBuffers                 (1, &buf);
2410                         glDeleteTextures                (1, &texture);
2411                 });
2412
2413         // glCopyTexSubImage3D
2414
2415         ES3F_ADD_API_CASE(copytexsubimage3d, "Invalid glCopyTexSubImage3D() usage",
2416                 {
2417                         GLuint texture;
2418                         glGenTextures   (1, &texture);
2419                         glBindTexture   (GL_TEXTURE_3D, texture);
2420                         glTexImage3D    (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2421
2422                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is invalid.");
2423                         glCopyTexSubImage3D(0, 0, 0, 0, 0, 0, 0, 4, 4);
2424                         expectError(GL_INVALID_ENUM);
2425                         m_log << TestLog::EndSection;
2426
2427                         glDeleteTextures(1, &texture);
2428                 });
2429         ES3F_ADD_API_CASE(copytexsubimage3d_neg_level, "Invalid glCopyTexSubImage3D() usage",
2430                 {
2431                         deUint32                        textures[2];
2432                         glGenTextures           (2, &textures[0]);
2433                         glBindTexture           (GL_TEXTURE_3D, textures[0]);
2434                         glTexImage3D            (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2435                         glBindTexture           (GL_TEXTURE_2D_ARRAY, textures[1]);
2436                         glTexImage3D            (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2437                         expectError                     (GL_NO_ERROR);
2438
2439                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
2440                         glCopyTexSubImage3D(GL_TEXTURE_3D, -1, 0, 0, 0, 0, 0, 4, 4);
2441                         expectError(GL_INVALID_VALUE);
2442                         glCopyTexSubImage3D(GL_TEXTURE_2D_ARRAY, -1, 0, 0, 0, 0, 0, 4, 4);
2443                         expectError(GL_INVALID_VALUE);
2444                         m_log << TestLog::EndSection;
2445
2446                         glDeleteTextures(2, &textures[0]);
2447                 });
2448         ES3F_ADD_API_CASE(copytexsubimage3d_max_level, "Invalid glCopyTexSubImage3D() usage",
2449                 {
2450                         deUint32        log2Max3DTextureSize    = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_3D_TEXTURE_SIZE)) + 1;
2451                         deUint32        log2MaxTextureSize              = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
2452
2453                         deUint32                        textures[2];
2454                         glGenTextures           (2, &textures[0]);
2455                         glBindTexture           (GL_TEXTURE_3D, textures[0]);
2456                         glTexImage3D            (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2457                         glBindTexture           (GL_TEXTURE_2D_ARRAY, textures[1]);
2458                         glTexImage3D            (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2459                         expectError                     (GL_NO_ERROR);
2460
2461                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_3D_TEXTURE_SIZE).");
2462                         glCopyTexSubImage3D(GL_TEXTURE_3D, log2Max3DTextureSize, 0, 0, 0, 0, 0, 4, 4);
2463                         expectError(GL_INVALID_VALUE);
2464                         m_log << TestLog::EndSection;
2465
2466                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
2467                         glCopyTexSubImage3D(GL_TEXTURE_2D_ARRAY, log2MaxTextureSize, 0, 0, 0, 0, 0, 4, 4);
2468                         expectError(GL_INVALID_VALUE);
2469                         m_log << TestLog::EndSection;
2470
2471                         glDeleteTextures(2, &textures[0]);
2472                 });
2473         ES3F_ADD_API_CASE(copytexsubimage3d_neg_offset, "Invalid glCopyTexSubImage3D() usage",
2474                 {
2475                         GLuint texture;
2476                         glGenTextures   (1, &texture);
2477                         glBindTexture   (GL_TEXTURE_3D, texture);
2478                         glTexImage3D    (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2479
2480                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if xoffset, yoffset or zoffset is negative.");
2481                         glCopyTexSubImage3D(GL_TEXTURE_3D, 0, -1, 0,  0, 0, 0, 4, 4);
2482                         expectError(GL_INVALID_VALUE);
2483                         glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, -1, 0, 0, 0, 4, 4);
2484                         expectError(GL_INVALID_VALUE);
2485                         glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, -1, 0, 0, 4, 4);
2486                         expectError(GL_INVALID_VALUE);
2487                         glCopyTexSubImage3D(GL_TEXTURE_3D, 0, -1, -1, -1, 0, 0, 4, 4);
2488                         expectError(GL_INVALID_VALUE);
2489                         m_log << TestLog::EndSection;
2490
2491                         glDeleteTextures(1, &texture);
2492                 });
2493         ES3F_ADD_API_CASE(copytexsubimage3d_invalid_offset, "Invalid glCopyTexSubImage3D() usage",
2494                 {
2495                         GLuint texture;
2496                         glGenTextures   (1, &texture);
2497                         glBindTexture   (GL_TEXTURE_3D, texture);
2498                         glTexImage3D    (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2499
2500                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if xoffset + width > texture_width.");
2501                         glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 1, 0, 0, 0, 0, 4, 4);
2502                         expectError(GL_INVALID_VALUE);
2503                         m_log << TestLog::EndSection;
2504
2505                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if yoffset + height > texture_height.");
2506                         glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 1, 0, 0, 0, 4, 4);
2507                         expectError(GL_INVALID_VALUE);
2508                         m_log << TestLog::EndSection;
2509
2510                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if zoffset + 1 > texture_depth.");
2511                         glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 4, 0, 0, 4, 4);
2512                         expectError(GL_INVALID_VALUE);
2513                         m_log << TestLog::EndSection;
2514
2515                         glDeleteTextures(1, &texture);
2516                 });
2517         ES3F_ADD_API_CASE(copytexsubimage3d_neg_width_height, "Invalid glCopyTexSubImage3D() usage",
2518                 {
2519                         GLuint texture;
2520                         glGenTextures   (1, &texture);
2521                         glBindTexture   (GL_TEXTURE_3D, texture);
2522                         glTexImage3D    (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2523
2524                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width < 0.");
2525                         glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, -4, 4);
2526                         expectError(GL_INVALID_VALUE);
2527                         m_log << TestLog::EndSection;
2528
2529                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if height < 0.");
2530                         glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, 4, -4);
2531                         expectError(GL_INVALID_VALUE);
2532                         m_log << TestLog::EndSection;
2533
2534                         glDeleteTextures(1, &texture);
2535                 });
2536         ES3F_ADD_API_CASE(copytexsubimage3d_incomplete_framebuffer, "Invalid glCopyTexSubImage3D() usage",
2537                 {
2538                         GLuint fbo;
2539                         GLuint texture[2];
2540
2541                         glGenTextures                   (2, texture);
2542                         glBindTexture                   (GL_TEXTURE_3D, texture[0]);
2543                         glTexImage3D                    (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2544                         glBindTexture                   (GL_TEXTURE_2D_ARRAY, texture[1]);
2545                         glTexImage3D                    (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
2546                         glGenFramebuffers               (1, &fbo);
2547                         glBindFramebuffer               (GL_READ_FRAMEBUFFER, fbo);
2548                         glCheckFramebufferStatus(GL_READ_FRAMEBUFFER);
2549
2550                         m_log << tcu::TestLog::Section("", "GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
2551                         glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, 4, 4);
2552                         expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
2553                         glCopyTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 0, 0, 4, 4);
2554                         expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
2555                         m_log << tcu::TestLog::EndSection;
2556
2557                         glBindFramebuffer(GL_FRAMEBUFFER, 0);
2558                         glDeleteFramebuffers(1, &fbo);
2559                         glDeleteTextures(2, texture);
2560                 });
2561
2562         // glCompressedTexImage3D
2563
2564         ES3F_ADD_API_CASE(compressedteximage3d, "Invalid glCompressedTexImage3D() usage",
2565                 {
2566                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is invalid.");
2567                         glCompressedTexImage3D(0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0, 0);
2568                         expectError(GL_INVALID_ENUM);
2569                         glCompressedTexImage3D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0, 0);
2570                         expectError(GL_INVALID_ENUM);
2571                         m_log << TestLog::EndSection;
2572
2573                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if internalformat is not one of the specific compressed internal formats.");
2574                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 0, 0, 0, 0);
2575                         expectError(GL_INVALID_ENUM);
2576                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA8, 0, 0, 0, 0, 0, 0);
2577                         expectError(GL_INVALID_ENUM);
2578                         m_log << TestLog::EndSection;
2579                 });
2580         ES3F_ADD_API_CASE(compressedteximage3d_neg_level, "Invalid glCompressedTexImage3D() usage",
2581                 {
2582                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
2583                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, -1, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0, 0);
2584                         expectError(GL_INVALID_VALUE);
2585                         m_log << TestLog::EndSection;
2586                 });
2587         ES3F_ADD_API_CASE(compressedteximage3d_max_level, "Invalid glCompressedTexImage3D() usage",
2588                 {
2589                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
2590                         deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
2591                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, log2MaxTextureSize, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, 0, 0);
2592                         expectError(GL_INVALID_VALUE);
2593                         m_log << TestLog::EndSection;
2594                 });
2595         ES3F_ADD_API_CASE(compressedteximage3d_neg_width_height_depth, "Invalid glCompressedTexImage3D() usage",
2596                 {
2597                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width, height or depth is less than 0.");
2598                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0, 0, 0, 0, 0);
2599                         expectError(GL_INVALID_VALUE);
2600                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, -1, 0, 0, 0, 0);
2601                         expectError(GL_INVALID_VALUE);
2602                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, -1, 0, 0, 0);
2603                         expectError(GL_INVALID_VALUE);
2604                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, -1, -1, 0, 0, 0);
2605                         expectError(GL_INVALID_VALUE);
2606                         m_log << TestLog::EndSection;
2607                 });
2608         ES3F_ADD_API_CASE(compressedteximage3d_max_width_height_depth, "Invalid glCompressedTexImage3D() usage",
2609                 {
2610                         int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE) + 1;
2611
2612                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width, height or depth is greater than GL_MAX_TEXTURE_SIZE.");
2613                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxTextureSize, 0, 0, 0, 0, 0);
2614                         expectError(GL_INVALID_VALUE);
2615                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, maxTextureSize, 0, 0, 0, 0);
2616                         expectError(GL_INVALID_VALUE);
2617                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, maxTextureSize, 0, 0, 0);
2618                         expectError(GL_INVALID_VALUE);
2619                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, maxTextureSize, maxTextureSize, maxTextureSize, 0, 0, 0);
2620                         expectError(GL_INVALID_VALUE);
2621                         m_log << TestLog::EndSection;
2622                 });
2623         ES3F_ADD_API_CASE(compressedteximage3d_invalid_border, "Invalid glCompressedTexImage3D() usage",
2624                 {
2625                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
2626                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, -1, 0, 0);
2627                         expectError(GL_INVALID_VALUE);
2628                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 1, 0, 0);
2629                         expectError(GL_INVALID_VALUE);
2630                         m_log << TestLog::EndSection;
2631                 });
2632         ES3F_ADD_API_CASE(compressedteximage3d_invalid_size, "Invalid glCompressedTexImage3D() usage",
2633                 {
2634                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if imageSize is not consistent with the format, dimensions, and contents of the specified compressed image data.");
2635                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0, 0, 0, -1, 0);
2636                         expectError(GL_INVALID_VALUE);
2637                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, 4*4*8, 0);
2638                         expectError(GL_INVALID_VALUE);
2639                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGB8_ETC2, 16, 16, 1, 0, 4*4*16, 0);
2640                         expectError(GL_INVALID_VALUE);
2641                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_SIGNED_R11_EAC, 16, 16, 1, 0, 4*4*16, 0);
2642                         expectError(GL_INVALID_VALUE);
2643                         m_log << TestLog::EndSection;
2644                 });
2645         ES3F_ADD_API_CASE(compressedteximage3d_invalid_buffer_target, "Invalid glCompressedTexImage3D() usage",
2646                 {
2647                         deUint32                                buf;
2648                         std::vector<GLubyte>    data(512);
2649
2650                         glGenBuffers                    (1, &buf);
2651                         glBindBuffer                    (GL_PIXEL_UNPACK_BUFFER, buf);
2652                         glBufferData                    (GL_PIXEL_UNPACK_BUFFER, 64, &data[0], GL_DYNAMIC_COPY);
2653                         expectError                             (GL_NO_ERROR);
2654
2655                         m_log << TestLog::Section("", "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.");
2656                         glMapBufferRange                (GL_PIXEL_UNPACK_BUFFER, 0, 64, GL_MAP_WRITE_BIT);
2657                         glCompressedTexImage3D  (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGB8_ETC2, 4, 4, 1, 0, etc2DataSize(4, 4), 0);
2658                         expectError                             (GL_INVALID_OPERATION);
2659                         glUnmapBuffer                   (GL_PIXEL_UNPACK_BUFFER);
2660                         m_log << TestLog::EndSection;
2661
2662                         m_log << TestLog::Section("", "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.");
2663                         glCompressedTexImage3D  (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGB8_ETC2, 16, 16, 1, 0, etc2DataSize(16, 16), 0);
2664                         expectError                             (GL_INVALID_OPERATION);
2665                         m_log << TestLog::EndSection;
2666
2667                         glDeleteBuffers                 (1, &buf);
2668                 });
2669         ES3F_ADD_API_CASE(compressedteximage3d_invalid_astc_target, "Invalid glCompressedTexImage3D() ASTC 3D targets",
2670                 {
2671                         // GLES 3.0.4, Sec 3.8.6, p.147: For example, the
2672                         // compressed image format might be supported only for 2D
2673                         // textures ... result in an INVALID_OPERATION error.
2674                         // Also, if LDR is supported, formats cannot be invalid enums
2675                         // \todo [2015-05-14 kalle] The test is subject to change from Khronos bug 13921 and 13862
2676
2677                         if (m_context.getContextInfo().isExtensionSupported("GL_KHR_texture_compression_astc_hdr") ||
2678                                 m_context.getContextInfo().isExtensionSupported("GL_OES_texture_compression_astc"))
2679                         {
2680                                 m_log.writeMessage("Full ASTC supported. No negative API requirements.");
2681                         }
2682                         else
2683                         {
2684                                 const GLuint requiredError = m_context.getContextInfo().isExtensionSupported("GL_KHR_texture_compression_astc_ldr") ? GL_INVALID_OPERATION : GL_INVALID_ENUM;
2685
2686                                 if (requiredError == GL_INVALID_OPERATION)
2687                                         m_log.writeMessage("GL_INVALID_OPERATION should be  generated if any TexImage3D target works with LDR ASTC.");
2688                                 else
2689                                         m_log.writeMessage("GL_INVALID_ENUM should be generated if no ASTC extensions are present.");
2690
2691                                 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(s_astcFormats); formatNdx++)
2692                                 {
2693                                         const GLuint                            format          = s_astcFormats[formatNdx];
2694                                         const CompressedTexFormat       tcuFormat       = mapGLCompressedTexFormat(format);
2695                                         const IVec3                             blockPixels = getBlockPixelSize(tcuFormat);
2696                                         const size_t                            blockBytes      = getBlockSize(tcuFormat);
2697                                         const vector<deUint8>           dummyData       (blockBytes);
2698
2699                                         glCompressedTexImage3D(GL_TEXTURE_3D, 0, format, blockPixels.x(), blockPixels.y(), blockPixels.z(), 0, blockBytes, &dummyData[0]);
2700                                         expectError(requiredError);
2701
2702                                         glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, format, blockPixels.x(), blockPixels.y(), blockPixels.z(), 0, blockBytes, &dummyData[0]);
2703                                         expectError(requiredError);
2704                                 }
2705                         }
2706                 });
2707
2708         // glCompressedTexSubImage3D
2709
2710         ES3F_ADD_API_CASE(compressedtexsubimage3d, "Invalid glCompressedTexSubImage3D() usage",
2711                 {
2712                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is invalid.");
2713                         glCompressedTexSubImage3D(0, 0, 0, 0, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2714                         expectError(GL_INVALID_ENUM);
2715                         m_log << TestLog::EndSection;
2716
2717                         deUint32                                texture;
2718                         glGenTextures                   (1, &texture);
2719                         glBindTexture                   (GL_TEXTURE_2D_ARRAY, texture);
2720                         glCompressedTexImage3D  (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 18, 18, 1, 0, etc2EacDataSize(18, 18), 0);
2721                         expectError                             (GL_NO_ERROR);
2722
2723                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if format does not match the internal format of the texture image being modified.");
2724                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 0, 0, 0, GL_COMPRESSED_RGB8_ETC2, 0, 0);
2725                         expectError(GL_INVALID_OPERATION);
2726                         m_log << TestLog::EndSection;
2727
2728                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if internalformat is an ETC2/EAC format and target is not GL_TEXTURE_2D_ARRAY.");
2729                         glCompressedTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 18, 18, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(18, 18), 0);
2730                         expectError(GL_INVALID_OPERATION);
2731                         m_log << TestLog::EndSection;
2732
2733                         m_log << TestLog::Section("", "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.");
2734                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 4, 0, 0, 10, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(10, 4), 0);
2735                         expectError(GL_INVALID_OPERATION);
2736                         m_log << TestLog::EndSection;
2737
2738                         m_log << TestLog::Section("", "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.");
2739                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 4, 0, 4, 10, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 10), 0);
2740                         expectError(GL_INVALID_OPERATION);
2741                         m_log << TestLog::EndSection;
2742
2743                         m_log << TestLog::Section("", "For ETC2/EAC images GL_INVALID_OPERATION is generated if xoffset or yoffset is not a multiple of four.");
2744                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 1, 0, 0, 4, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
2745                         expectError(GL_INVALID_OPERATION);
2746                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 1, 0, 4, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
2747                         expectError(GL_INVALID_OPERATION);
2748                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 1, 1, 0, 4, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
2749                         expectError(GL_INVALID_OPERATION);
2750                         m_log << TestLog::EndSection;
2751
2752                         glDeleteTextures                (1, &texture);
2753                 });
2754         ES3F_ADD_API_CASE(compressedtexsubimage3d_neg_level, "Invalid glCompressedTexSubImage3D() usage",
2755                 {
2756                         deUint32                                texture;
2757                         glGenTextures                   (1, &texture);
2758                         glBindTexture                   (GL_TEXTURE_2D_ARRAY, texture);
2759                         glCompressedTexImage3D  (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, etc2EacDataSize(16, 16), 0);
2760                         expectError                             (GL_NO_ERROR);
2761
2762                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
2763                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, -1, 0, 0, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2764                         expectError(GL_INVALID_VALUE);
2765                         m_log << TestLog::EndSection;
2766
2767                         glDeleteTextures                (1, &texture);
2768                 });
2769         ES3F_ADD_API_CASE(compressedtexsubimage3d_max_level, "Invalid glCompressedTexSubImage3D() usage",
2770                 {
2771                         deUint32                                texture;
2772                         glGenTextures                   (1, &texture);
2773                         glBindTexture                   (GL_TEXTURE_2D_ARRAY, texture);
2774                         glCompressedTexImage3D  (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, etc2EacDataSize(16, 16), 0);
2775                         expectError                             (GL_NO_ERROR);
2776
2777                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
2778                         deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
2779                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, log2MaxTextureSize, 0, 0, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2780                         expectError(GL_INVALID_VALUE);
2781                         m_log << TestLog::EndSection;
2782
2783                         glDeleteTextures                (1, &texture);
2784                 });
2785         ES3F_ADD_API_CASE(compressedtexsubimage3d_neg_offset, "Invalid glCompressedTexSubImage3D() usage",
2786                 {
2787                         deUint32                                texture;
2788                         glGenTextures                   (1, &texture);
2789                         glBindTexture                   (GL_TEXTURE_2D_ARRAY, texture);
2790                         glCompressedTexImage3D  (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, etc2EacDataSize(16, 16), 0);
2791                         expectError                             (GL_NO_ERROR);
2792
2793                         m_log << TestLog::Section("", "GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if xoffset, yoffset or zoffset are negative.");
2794                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, -4, 0, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2795                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2796                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, -4, 0, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2797                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2798                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, -4, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2799                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2800                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, -4, -4, -4, 0, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2801                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2802                         m_log << TestLog::EndSection;
2803
2804                         glDeleteTextures                (1, &texture);
2805                 });
2806         ES3F_ADD_API_CASE(compressedtexsubimage3d_invalid_offset, "Invalid glCompressedTexSubImage3D() usage",
2807                 {
2808                         deUint32                                texture;
2809                         glGenTextures                   (1, &texture);
2810                         glBindTexture                   (GL_TEXTURE_2D_ARRAY, texture);
2811                         glCompressedTexImage3D  (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 4, 4, 1, 0, etc2EacDataSize(4, 4), 0);
2812                         expectError                             (GL_NO_ERROR);
2813
2814                         m_log << TestLog::Section("", "GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if xoffset + width > texture_width or yoffset + height > texture_height.");
2815
2816                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 12, 0, 0, 8, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(8, 4), 0);
2817                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2818                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 12, 0, 4, 8, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 8), 0);
2819                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2820                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 12, 4, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
2821                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2822                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 12, 12, 12, 8, 8, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(8, 8), 0);
2823                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2824                         m_log << TestLog::EndSection;
2825
2826                         glDeleteTextures                (1, &texture);
2827                 });
2828         ES3F_ADD_API_CASE(compressedtexsubimage3d_neg_width_height_depth, "Invalid glCompressedTexSubImage3D() usage",
2829                 {
2830                         deUint32                                texture;
2831                         glGenTextures                   (1, &texture);
2832                         glBindTexture                   (GL_TEXTURE_2D_ARRAY, texture);
2833                         glCompressedTexImage3D  (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, etc2EacDataSize(16, 16), 0);
2834                         expectError                             (GL_NO_ERROR);
2835
2836                         m_log << TestLog::Section("", "GL_INVALID_VALUE or GL_INVALID_OPERATION is generated if width, height or depth are negative.");
2837                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, -4, 0, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2838                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2839                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 0, -4, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2840                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2841                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 0, 0, -4, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2842                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2843                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, -4, -4, -4, GL_COMPRESSED_RGBA8_ETC2_EAC, 0, 0);
2844                         expectError(GL_INVALID_VALUE, GL_INVALID_OPERATION);
2845                         m_log << TestLog::EndSection;
2846
2847                         glDeleteTextures                (1, &texture);
2848                 });
2849         ES3F_ADD_API_CASE(compressedtexsubimage3d_invalid_size, "Invalid glCompressedTexSubImage3D() usage",
2850                 {
2851                         deUint32                                texture;
2852                         glGenTextures                   (1, &texture);
2853                         glBindTexture                   (GL_TEXTURE_2D_ARRAY, texture);
2854                         glCompressedTexImage3D  (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, 4*4*16, 0);
2855                         expectError                             (GL_NO_ERROR);
2856
2857                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if imageSize is not consistent with the format, dimensions, and contents of the specified compressed image data.");
2858                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 16, 16, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, -1, 0);
2859                         expectError(GL_INVALID_VALUE);
2860
2861                         glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 16, 16, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, 4*4*16-1, 0);
2862                         expectError(GL_INVALID_VALUE);
2863                         m_log << TestLog::EndSection;
2864
2865                         glDeleteTextures                (1, &texture);
2866                 });
2867         ES3F_ADD_API_CASE(compressedtexsubimage3d_invalid_buffer_target, "Invalid glCompressedTexSubImage3D() usage",
2868                 {
2869                         deUint32                                        buf;
2870                         deUint32                                        texture;
2871                         GLsizei                                         bufferSize = etc2EacDataSize(4, 4);
2872                         std::vector<GLubyte>            data(bufferSize);
2873
2874                         glGenTextures                           (1, &texture);
2875                         glBindTexture                           (GL_TEXTURE_2D_ARRAY, texture);
2876                         glCompressedTexImage3D          (GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA8_ETC2_EAC, 16, 16, 1, 0, etc2EacDataSize(16, 16), 0);
2877                         glGenBuffers                            (1, &buf);
2878                         glBindBuffer                            (GL_PIXEL_UNPACK_BUFFER, buf);
2879                         glBufferData                            (GL_PIXEL_UNPACK_BUFFER, bufferSize, &data[0], GL_DYNAMIC_COPY);
2880                         expectError                                     (GL_NO_ERROR);
2881
2882                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER target and...");
2883                         m_log << TestLog::Section("", "...the buffer object's data store is currently mapped.");
2884                         glMapBufferRange                        (GL_PIXEL_UNPACK_BUFFER, 0, bufferSize, GL_MAP_WRITE_BIT);
2885                         glCompressedTexSubImage3D       (GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 4, 4, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(4, 4), 0);
2886                         expectError                                     (GL_INVALID_OPERATION);
2887                         glUnmapBuffer                           (GL_PIXEL_UNPACK_BUFFER);
2888                         m_log << TestLog::EndSection;
2889
2890                         m_log << TestLog::Section("", "...the data would be unpacked from the buffer object such that the memory reads required would exceed the data store size.");
2891                         glCompressedTexSubImage3D       (GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 16, 16, 1, GL_COMPRESSED_RGBA8_ETC2_EAC, etc2EacDataSize(16, 16), 0);
2892                         expectError                                     (GL_INVALID_OPERATION);
2893                         m_log << TestLog::EndSection;
2894                         m_log << TestLog::EndSection;
2895
2896                         glDeleteBuffers                 (1, &buf);
2897                         glDeleteTextures                (1, &texture);
2898                 });
2899
2900         // glTexStorage2D
2901
2902         ES3F_ADD_API_CASE(texstorage2d, "Invalid glTexStorage2D() usage",
2903                 {
2904                         deUint32                texture;
2905                         glGenTextures   (1, &texture);
2906                         glBindTexture   (GL_TEXTURE_2D, texture);
2907
2908                         m_log << TestLog::Section("", "GL_INVALID_ENUM or GL_INVALID_VALUE is generated if internalformat is not a valid sized internal format.");
2909                         glTexStorage2D  (GL_TEXTURE_2D, 1, 0, 16, 16);
2910                         expectError             (GL_INVALID_ENUM, GL_INVALID_VALUE);
2911                         glTexStorage2D  (GL_TEXTURE_2D, 1, GL_RGBA_INTEGER, 16, 16);
2912                         expectError             (GL_INVALID_ENUM, GL_INVALID_VALUE);
2913                         m_log << TestLog::EndSection;
2914
2915                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not one of the accepted target enumerants.");
2916                         glTexStorage2D  (0, 1, GL_RGBA8, 16, 16);
2917                         expectError             (GL_INVALID_ENUM);
2918                         glTexStorage2D  (GL_TEXTURE_3D, 1, GL_RGBA8, 16, 16);
2919                         expectError             (GL_INVALID_ENUM);
2920                         glTexStorage2D  (GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 16, 16);
2921                         expectError             (GL_INVALID_ENUM);
2922                         m_log << TestLog::EndSection;
2923
2924                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height are less than 1.");
2925                         glTexStorage2D  (GL_TEXTURE_2D, 1, GL_RGBA8, 0, 16);
2926                         expectError             (GL_INVALID_VALUE);
2927                         glTexStorage2D  (GL_TEXTURE_2D, 1, GL_RGBA8, 16, 0);
2928                         expectError             (GL_INVALID_VALUE);
2929                         glTexStorage2D  (GL_TEXTURE_2D, 1, GL_RGBA8, 0, 0);
2930                         expectError             (GL_INVALID_VALUE);
2931                         m_log << TestLog::EndSection;
2932
2933                         glDeleteTextures(1, &texture);
2934                 });
2935
2936         ES3F_ADD_API_CASE(texstorage2d_invalid_binding, "Invalid glTexStorage2D() usage",
2937                 {
2938                         glBindTexture   (GL_TEXTURE_2D, 0);
2939
2940                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the default texture object is curently bound to target.");
2941                         glTexStorage2D  (GL_TEXTURE_2D, 1, GL_RGBA8, 16, 16);
2942                         expectError             (GL_INVALID_OPERATION);
2943                         m_log << TestLog::EndSection;
2944
2945                         deUint32                texture;
2946                         glGenTextures   (1, &texture);
2947                         glBindTexture   (GL_TEXTURE_2D, texture);
2948
2949                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the texture object currently bound to target already has GL_TEXTURE_IMMUTABLE_FORMAT set to GL_TRUE.");
2950                         deInt32                 immutable       = -1;
2951                         glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
2952                         m_log << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
2953                         glTexStorage2D  (GL_TEXTURE_2D, 1, GL_RGBA8, 16, 16);
2954                         expectError             (GL_NO_ERROR);
2955                         glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
2956                         m_log << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
2957                         glTexStorage2D  (GL_TEXTURE_2D, 1, GL_RGBA8, 16, 16);
2958                         expectError             (GL_INVALID_OPERATION);
2959                         m_log << TestLog::EndSection;
2960
2961                         glDeleteTextures(1, &texture);
2962                 });
2963         ES3F_ADD_API_CASE(texstorage2d_invalid_levels, "Invalid glTexStorage2D() usage",
2964                 {
2965                         deUint32                texture;
2966                         glGenTextures   (1, &texture);
2967                         glBindTexture   (GL_TEXTURE_2D, texture);
2968
2969                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if levels is less than 1.");
2970                         glTexStorage2D  (GL_TEXTURE_2D, 0, GL_RGBA8, 16, 16);
2971                         expectError             (GL_INVALID_VALUE);
2972                         glTexStorage2D  (GL_TEXTURE_2D, 0, GL_RGBA8, 0, 0);
2973                         expectError             (GL_INVALID_VALUE);
2974                         m_log << TestLog::EndSection;
2975
2976                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if levels is greater than floor(log_2(max(width, height))) + 1");
2977                         deUint32 log2MaxSize = deLog2Floor32(deMax32(16, 4)) + 1 + 1;
2978                         glTexStorage2D  (GL_TEXTURE_2D, log2MaxSize, GL_RGBA8, 16, 4);
2979                         expectError             (GL_INVALID_OPERATION);
2980                         glTexStorage2D  (GL_TEXTURE_2D, log2MaxSize, GL_RGBA8, 4, 16);
2981                         expectError             (GL_INVALID_OPERATION);
2982                         glTexStorage2D  (GL_TEXTURE_2D, log2MaxSize, GL_RGBA8, 16, 16);
2983                         expectError             (GL_INVALID_OPERATION);
2984                         m_log << TestLog::EndSection;
2985
2986                         glDeleteTextures(1, &texture);
2987                 });
2988         ES3F_ADD_API_CASE(texstorage2d_invalid_astc_target, "Invalid glTexStorage2D() ASTC 2D targets",
2989                 {
2990                         // GLES 3.0.4, Sec 3.8.4, p.136: If there is no imageSize
2991                         // for which this command would have been valid, an
2992                         // INVALID_OPERATION error is generated. Also: If
2993                         // executing the pseudo-code would result in any other
2994                         // error, the error is generated and the command will have
2995                         // no effect.
2996                         // In conclusion: Expect same errors as with TexImage?D
2997
2998                         if (m_context.getContextInfo().isExtensionSupported("GL_KHR_texture_compression_astc_hdr") ||
2999                                 m_context.getContextInfo().isExtensionSupported("GL_OES_texture_compression_astc"))
3000                         {
3001                                 m_log.writeMessage("Full ASTC supported. No negative API requirements.");
3002                         }
3003                         else
3004                         {
3005                                 const GLuint requiredError = m_context.getContextInfo().isExtensionSupported("GL_KHR_texture_compression_astc_ldr") ? GL_INVALID_OPERATION : GL_INVALID_ENUM;
3006
3007                                 if (requiredError == GL_INVALID_OPERATION)
3008                                         m_log.writeMessage("GL_INVALID_OPERATION should be generated if the cube map targets work with LDR ASTC.");
3009                                 else
3010                                         m_log.writeMessage("GL_INVALID_ENUM should be generated if no ASTC extensions are present.");
3011
3012                                 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(s_astcFormats); formatNdx++)
3013                                 {
3014                                         const GLuint                            format          = s_astcFormats[formatNdx];
3015                                         const CompressedTexFormat       tcuFormat       = mapGLCompressedTexFormat(format);
3016                                         const IVec3                             blockPixels = getBlockPixelSize(tcuFormat);
3017
3018                                         glTexStorage2D(GL_TEXTURE_CUBE_MAP, 1, format, blockPixels.x(), blockPixels.y());
3019                                         expectError(requiredError);
3020                                 }
3021                         }
3022                 });
3023
3024         // glTexStorage3D
3025
3026         ES3F_ADD_API_CASE(texstorage3d, "Invalid glTexStorage3D() usage",
3027                 {
3028                         deUint32                texture;
3029                         glGenTextures   (1, &texture);
3030                         glBindTexture   (GL_TEXTURE_3D, texture);
3031
3032                         m_log << TestLog::Section("", "GL_INVALID_ENUM or GL_INVALID_VALUE is generated if internalformat is not a valid sized internal format.");
3033                         glTexStorage3D  (GL_TEXTURE_3D, 1, 0, 4, 4, 4);
3034                         expectError             (GL_INVALID_ENUM, GL_INVALID_VALUE);
3035                         glTexStorage3D  (GL_TEXTURE_3D, 1, GL_RGBA_INTEGER, 4, 4, 4);
3036                         expectError             (GL_INVALID_ENUM, GL_INVALID_VALUE);
3037                         m_log << TestLog::EndSection;
3038
3039                         m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not one of the accepted target enumerants.");
3040                         glTexStorage3D  (0, 1, GL_RGBA8, 4, 4, 4);
3041                         expectError             (GL_INVALID_ENUM);
3042                         glTexStorage3D  (GL_TEXTURE_CUBE_MAP, 1, GL_RGBA8, 4, 4, 4);
3043                         expectError             (GL_INVALID_ENUM);
3044                         glTexStorage3D  (GL_TEXTURE_2D, 1, GL_RGBA8, 4, 4, 4);
3045                         expectError             (GL_INVALID_ENUM);
3046                         m_log << TestLog::EndSection;
3047
3048                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width, height or depth are less than 1.");
3049                         glTexStorage3D  (GL_TEXTURE_3D, 1, GL_RGBA8, 0, 4, 4);
3050                         expectError             (GL_INVALID_VALUE);
3051                         glTexStorage3D  (GL_TEXTURE_3D, 1, GL_RGBA8, 4, 0, 4);
3052                         expectError             (GL_INVALID_VALUE);
3053                         glTexStorage3D  (GL_TEXTURE_3D, 1, GL_RGBA8, 4, 4, 0);
3054                         expectError             (GL_INVALID_VALUE);
3055                         glTexStorage3D  (GL_TEXTURE_3D, 1, GL_RGBA8, 0, 0, 0);
3056                         expectError             (GL_INVALID_VALUE);
3057                         m_log << TestLog::EndSection;
3058
3059                         glDeleteTextures(1, &texture);
3060                 });
3061         ES3F_ADD_API_CASE(texstorage3d_invalid_binding, "Invalid glTexStorage3D() usage",
3062                 {
3063                         glBindTexture   (GL_TEXTURE_3D, 0);
3064
3065                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the default texture object is curently bound to target.");
3066                         glTexStorage3D  (GL_TEXTURE_3D, 1, GL_RGBA8, 4, 4, 4);
3067                         expectError             (GL_INVALID_OPERATION);
3068                         m_log << TestLog::EndSection;
3069
3070                         deUint32                texture;
3071                         glGenTextures   (1, &texture);
3072                         glBindTexture   (GL_TEXTURE_3D, texture);
3073
3074                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the texture object currently bound to target already has GL_TEXTURE_IMMUTABLE_FORMAT set to GL_TRUE.");
3075                         deInt32                 immutable       = -1;
3076                         glGetTexParameteriv(GL_TEXTURE_3D, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3077                         m_log << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3078                         glTexStorage3D  (GL_TEXTURE_3D, 1, GL_RGBA8, 4, 4, 4);
3079                         expectError             (GL_NO_ERROR);
3080                         glGetTexParameteriv(GL_TEXTURE_3D, GL_TEXTURE_IMMUTABLE_FORMAT, &immutable);
3081                         m_log << TestLog::Message << "// GL_TEXTURE_IMMUTABLE_FORMAT = " << ((immutable != 0) ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
3082                         glTexStorage3D  (GL_TEXTURE_3D, 1, GL_RGBA8, 4, 4, 4);
3083                         expectError             (GL_INVALID_OPERATION);
3084                         m_log << TestLog::EndSection;
3085
3086                         glDeleteTextures(1, &texture);
3087                 });
3088         ES3F_ADD_API_CASE(texstorage3d_invalid_levels, "Invalid glTexStorage3D() usage",
3089                 {
3090                         deUint32                texture;
3091                         glGenTextures   (1, &texture);
3092                         glBindTexture   (GL_TEXTURE_3D, texture);
3093
3094                         m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if levels is less than 1.");
3095                         glTexStorage3D  (GL_TEXTURE_3D, 0, GL_RGBA8, 4, 4, 4);
3096                         expectError             (GL_INVALID_VALUE);
3097                         glTexStorage3D  (GL_TEXTURE_3D, 0, GL_RGBA8, 0, 0, 0);
3098                         expectError             (GL_INVALID_VALUE);
3099                         m_log << TestLog::EndSection;
3100
3101                         m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if levels is greater than floor(log_2(max(width, height, depth))) + 1");
3102                         deUint32 log2MaxSize = deLog2Floor32(8) + 1 + 1;
3103                         glTexStorage3D  (GL_TEXTURE_3D, log2MaxSize, GL_RGBA8, 8, 2, 2);
3104                         expectError             (GL_INVALID_OPERATION);
3105                         glTexStorage3D  (GL_TEXTURE_3D, log2MaxSize, GL_RGBA8, 2, 8, 2);
3106                         expectError             (GL_INVALID_OPERATION);
3107                         glTexStorage3D  (GL_TEXTURE_3D, log2MaxSize, GL_RGBA8, 2, 2, 8);
3108                         expectError             (GL_INVALID_OPERATION);
3109                         glTexStorage3D  (GL_TEXTURE_3D, log2MaxSize, GL_RGBA8, 8, 8, 8);
3110                         expectError             (GL_INVALID_OPERATION);
3111                         m_log << TestLog::EndSection;
3112
3113                         glDeleteTextures(1, &texture);
3114                 });
3115
3116         ES3F_ADD_API_CASE(texstorage3d_invalid_astc_target, "Invalid glTexStorage3D() ASTC 3D targets",
3117                 {
3118                         // GLES 3.0.4, Sec 3.8.4, p.136: If there is no imageSize
3119                         // for which this command would have been valid, an
3120                         // INVALID_OPERATION error is generated. Also: If
3121                         // executing the pseudo-code would result in any other
3122                         // error, the error is generated and the command will have
3123                         // no effect.
3124                         // In conclusion: Expect same errors as with TexImage?D
3125
3126                         if (m_context.getContextInfo().isExtensionSupported("GL_KHR_texture_compression_astc_hdr") ||
3127                                 m_context.getContextInfo().isExtensionSupported("GL_OES_texture_compression_astc"))
3128                         {
3129                                 m_log.writeMessage("Full ASTC supported. No negative API requirements.");
3130                         }
3131                         else
3132                         {
3133                                 const GLuint requiredError = m_context.getContextInfo().isExtensionSupported("GL_KHR_texture_compression_astc_ldr") ? GL_INVALID_OPERATION : GL_INVALID_ENUM;
3134
3135                                 if (requiredError == GL_INVALID_OPERATION)
3136                                         m_log.writeMessage("GL_INVALID_OPERATION should be generated if any TexStorage3D target works with LDR.");
3137                                 else
3138                                         m_log.writeMessage("GL_INVALID_ENUM should be generated if no ASTC extensions are present.");
3139
3140                                 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(s_astcFormats); formatNdx++)
3141                                 {
3142                                         const GLuint                            format          = s_astcFormats[formatNdx];
3143                                         const CompressedTexFormat       tcuFormat       = mapGLCompressedTexFormat(format);
3144                                         const IVec3                             blockPixels = getBlockPixelSize(tcuFormat);
3145
3146                                         glTexStorage3D(GL_TEXTURE_3D, 1, format, blockPixels.x(), blockPixels.y(), blockPixels.z());
3147                                         expectError(requiredError);
3148
3149                                         glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, format, blockPixels.x(), blockPixels.y(), blockPixels.z());
3150                                         expectError(requiredError);
3151                                 }
3152                         }
3153                 });
3154 }
3155
3156 } // Functional
3157 } // gles3
3158 } // deqp