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