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