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