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