1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 2.0 Module
3 * -------------------------------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Negative Texture API tests.
22 *//*--------------------------------------------------------------------*/
23
24 #include "es2fNegativeTextureApiTests.hpp"
25 #include "es2fApiCase.hpp"
26 #include "tcuFormatUtil.hpp"
27 #include "tcuCompressedTexture.hpp"
28 #include "gluTextureUtil.hpp"
29 #include "gluContextInfo.hpp"
30
31 #include <vector>
32 #include <algorithm>
33
34 #include "glwEnums.hpp"
35 #include "glwDefs.hpp"
36
37 using namespace glw; // GL types
38
39 namespace deqp
40 {
41 namespace gles2
42 {
43 namespace Functional
44 {
45
46 using tcu::TestLog;
47 using std::vector;
48
cubeFaceToGLFace(tcu::CubeFace face)49 static deUint32 cubeFaceToGLFace (tcu::CubeFace face)
50 {
51 switch (face)
52 {
53 case tcu::CUBEFACE_NEGATIVE_X: return GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
54 case tcu::CUBEFACE_POSITIVE_X: return GL_TEXTURE_CUBE_MAP_POSITIVE_X;
55 case tcu::CUBEFACE_NEGATIVE_Y: return GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
56 case tcu::CUBEFACE_POSITIVE_Y: return GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
57 case tcu::CUBEFACE_NEGATIVE_Z: return GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
58 case tcu::CUBEFACE_POSITIVE_Z: return GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
59 default:
60 DE_ASSERT(DE_FALSE);
61 return GL_NONE;
62 }
63 }
64
65 #define FOR_CUBE_FACES(FACE_GL_VAR, BODY) \
66 do \
67 { \
68 for (int faceIterTcu = 0; faceIterTcu < tcu::CUBEFACE_LAST; faceIterTcu++) \
69 { \
70 const GLenum FACE_GL_VAR = cubeFaceToGLFace((tcu::CubeFace)faceIterTcu); \
71 BODY \
72 } \
73 } while (false)
74
getCompressedTexSubImage2DFormat(const vector<deInt32> & supported,vector<deInt32> & accepted)75 static void getCompressedTexSubImage2DFormat(const vector<deInt32>& supported, vector<deInt32>& accepted)
76 {
77 // Find a supported compressed texture format that is accepted by compressedTexSubImage2D()
78
79 static const GLuint compressedTexSubImage2DFormats[] =
80 {
81 0x83F0, // GL_COMPRESSED_RGB_S3TC_DXT1_EXT
82 0x83F1, // GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
83 0x8C00, // GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG
84 0x8C01, // GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG
85 0x8C02, // GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
86 0x8C03 // GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG
87 };
88
89 for (int i = 0; i < (int)supported.size(); i++)
90 {
91 vector<deInt32>::const_iterator fmt = std::find(supported.begin(), supported.end(), compressedTexSubImage2DFormats[i]);
92 if (fmt != supported.end())
93 accepted.push_back(*fmt);
94 }
95 }
96
NegativeTextureApiTests(Context & context)97 NegativeTextureApiTests::NegativeTextureApiTests (Context& context)
98 : TestCaseGroup(context, "texture", "Negative Texture API Cases")
99 {
100 }
101
~NegativeTextureApiTests(void)102 NegativeTextureApiTests::~NegativeTextureApiTests (void)
103 {
104 }
105
init(void)106 void NegativeTextureApiTests::init (void)
107 {
108 // glActiveTexture
109
110 ES2F_ADD_API_CASE(activetexture_invalid_texture, "Invalid glActiveTexture() usage",
111 {
112 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if texture is not one of GL_TEXTUREi, where i ranges from 0 to (GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1).");
113 glActiveTexture(-1);
114 expectError(GL_INVALID_ENUM);
115 int numMaxTextureUnits = m_context.getContextInfo().getInt(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS);
116 glActiveTexture(GL_TEXTURE0 + numMaxTextureUnits);
117 expectError(GL_INVALID_ENUM);
118 m_log << TestLog::EndSection;
119 });
120
121 // glBindTexture
122
123 ES2F_ADD_API_CASE(bindtexture_invalid_target, "Invalid glBindTexture() usage",
124 {
125 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not one of the allowable values.");
126 glBindTexture(0, 1);
127 expectError(GL_INVALID_ENUM);
128 m_log << TestLog::EndSection;
129 });
130 ES2F_ADD_API_CASE(bindtexture_type_mismatch, "Invalid glBindTexture() usage",
131 {
132 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if texture was previously created with a target that doesn't match that of target.");
133 GLuint texture;
134 glGenTextures(1, &texture);
135 glBindTexture(GL_TEXTURE_2D, texture);
136 glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
137 expectError(GL_INVALID_OPERATION);
138 glDeleteTextures(1, &texture);
139 m_log << TestLog::EndSection;
140 });
141
142 // glCompressedTexImage2D
143
144 ES2F_ADD_API_CASE(compressedteximage_2d_invalid_target, "Invalid glCompressedTexImage2D() usage",
145 {
146 vector<deInt32> compressedFormats;
147 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
148 if (!compressedFormats.empty())
149 {
150 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is invalid.");
151 glCompressedTexImage2D(0, 0, compressedFormats[0], 0, 0, 0, 0, 0);
152 expectError(GL_INVALID_ENUM);
153 m_log << TestLog::EndSection;
154 }
155 });
156 ES2F_ADD_API_CASE(compressedteximage_2d_invalid_format_tex2d, "Invalid glCompressedTexImage2D() usage",
157 {
158 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if internalformat is not a supported format returned in GL_COMPRESSED_TEXTURE_FORMATS.");
159 glCompressedTexImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 0);
160 expectError(GL_INVALID_ENUM);
161 m_log << TestLog::EndSection;
162 });
163 ES2F_ADD_API_CASE(compressedteximage_2d_invalid_format_cube, "Invalid glCompressedTexImage2D() usage",
164 {
165 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if internalformat is not a supported format returned in GL_COMPRESSED_TEXTURE_FORMATS.");
166 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, 0, 0, 0, 0, 0, 0);
167 expectError(GL_INVALID_ENUM);
168 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, 0, 0, 0, 0, 0, 0);
169 expectError(GL_INVALID_ENUM);
170 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, 0, 0, 0, 0, 0, 0);
171 expectError(GL_INVALID_ENUM);
172 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, 0, 0, 0, 0, 0, 0);
173 expectError(GL_INVALID_ENUM);
174 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, 0, 0, 0, 0, 0, 0);
175 expectError(GL_INVALID_ENUM);
176 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, 0, 0, 0, 0, 0, 0);
177 expectError(GL_INVALID_ENUM);
178 m_log << TestLog::EndSection;
179 });
180 ES2F_ADD_API_CASE(compressedteximage2d_neg_level_tex2d, "Invalid glCompressedTexImage2D() usage",
181 {
182 vector<deInt32> compressedFormats;
183 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
184 if (!compressedFormats.empty())
185 {
186 size_t firstNonPalettedFormatNdx = 0;
187 // Negtive values are valid for palette formats
188 if (m_context.getContextInfo().isExtensionSupported("GL_OES_compressed_paletted_texture"))
189 {
190 while (GL_PALETTE4_RGB8_OES <= compressedFormats[firstNonPalettedFormatNdx] &&
191 GL_PALETTE8_RGB5_A1_OES >= compressedFormats[firstNonPalettedFormatNdx])
192 {
193 ++firstNonPalettedFormatNdx;
194 }
195 }
196 if (firstNonPalettedFormatNdx < compressedFormats.size())
197 {
198 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
199 glCompressedTexImage2D(GL_TEXTURE_2D, -1, compressedFormats[firstNonPalettedFormatNdx], 0, 0, 0, 0, 0);
200 expectError(GL_INVALID_VALUE);
201 m_log << TestLog::EndSection;
202 }
203 }
204 });
205 ES2F_ADD_API_CASE(compressedteximage2d_neg_level_cube, "Invalid glCompressedTexImage2D() usage",
206 {
207 vector<deInt32> compressedFormats;
208 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
209 if (!compressedFormats.empty())
210 {
211 size_t firstNonPalettedFormatNdx = 0;
212 // Negtive values are valid for palette formats
213 if (m_context.getContextInfo().isExtensionSupported("GL_OES_compressed_paletted_texture"))
214 {
215 while (GL_PALETTE4_RGB8_OES <= compressedFormats[firstNonPalettedFormatNdx] &&
216 GL_PALETTE8_RGB5_A1_OES >= compressedFormats[firstNonPalettedFormatNdx])
217 {
218 ++firstNonPalettedFormatNdx;
219 }
220 }
221 if (firstNonPalettedFormatNdx < compressedFormats.size())
222 {
223 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
224 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, -1, compressedFormats[firstNonPalettedFormatNdx], 0, 0, 0, 0, 0);
225 expectError(GL_INVALID_VALUE);
226 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, -1, compressedFormats[firstNonPalettedFormatNdx], 0, 0, 0, 0, 0);
227 expectError(GL_INVALID_VALUE);
228 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, -1, compressedFormats[firstNonPalettedFormatNdx], 0, 0, 0, 0, 0);
229 expectError(GL_INVALID_VALUE);
230 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, -1, compressedFormats[firstNonPalettedFormatNdx], 0, 0, 0, 0, 0);
231 expectError(GL_INVALID_VALUE);
232 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, -1, compressedFormats[firstNonPalettedFormatNdx], 0, 0, 0, 0, 0);
233 expectError(GL_INVALID_VALUE);
234 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, -1, compressedFormats[firstNonPalettedFormatNdx], 0, 0, 0, 0, 0);
235 expectError(GL_INVALID_VALUE);
236 m_log << TestLog::EndSection;
237 }
238 }
239 });
240 ES2F_ADD_API_CASE(compressedteximage2d_level_max_tex2d, "Invalid glCompressedTexImage2D() usage",
241 {
242 vector<deInt32> compressedFormats;
243 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
244 if (!compressedFormats.empty())
245 {
246 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
247 deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
248 glCompressedTexImage2D(GL_TEXTURE_2D, log2MaxTextureSize, compressedFormats[0], 0, 0, 0, 0, 0);
249 expectError(GL_INVALID_VALUE);
250 m_log << TestLog::EndSection;
251 }
252 });
253 ES2F_ADD_API_CASE(compressedteximage2d_level_max_cube_pos, "Invalid glCompressedTexImage2D() usage",
254 {
255 vector<deInt32> compressedFormats;
256 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
257 if (!compressedFormats.empty())
258 {
259 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
260 deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
261 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, log2MaxTextureSize, compressedFormats[0], 0, 0, 0, 0, 0);
262 expectError(GL_INVALID_VALUE);
263 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, log2MaxTextureSize, compressedFormats[0], 0, 0, 0, 0, 0);
264 expectError(GL_INVALID_VALUE);
265 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, log2MaxTextureSize, compressedFormats[0], 0, 0, 0, 0, 0);
266 expectError(GL_INVALID_VALUE);
267 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, log2MaxTextureSize, compressedFormats[0], 0, 0, 0, 0, 0);
268 expectError(GL_INVALID_VALUE);
269 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, log2MaxTextureSize, compressedFormats[0], 0, 0, 0, 0, 0);
270 expectError(GL_INVALID_VALUE);
271 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, log2MaxTextureSize, compressedFormats[0], 0, 0, 0, 0, 0);
272 expectError(GL_INVALID_VALUE);
273 m_log << TestLog::EndSection;
274 }
275 });
276 ES2F_ADD_API_CASE(compressedteximage2d_neg_width_height_tex2d, "Invalid glCompressedTexImage2D() usage",
277 {
278 vector<deInt32> compressedFormats;
279 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
280 if (!compressedFormats.empty())
281 {
282 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
283 glCompressedTexImage2D(GL_TEXTURE_2D, 0, compressedFormats[0], -1, 0, 0, 0, 0);
284 expectError(GL_INVALID_VALUE);
285 glCompressedTexImage2D(GL_TEXTURE_2D, 0, compressedFormats[0], 0, -1, 0, 0, 0);
286 expectError(GL_INVALID_VALUE);
287 glCompressedTexImage2D(GL_TEXTURE_2D, 0, compressedFormats[0], -1, -1, 0, 0, 0);
288 expectError(GL_INVALID_VALUE);
289 m_log << TestLog::EndSection;
290 }
291 });
292 ES2F_ADD_API_CASE(compressedteximage2d_neg_width_height_cube_pos_x, "Invalid glCompressedTexImage2D() usage",
293 {
294 vector<deInt32> compressedFormats;
295 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
296 if (!compressedFormats.empty())
297 {
298 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
299 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, compressedFormats[0], -1, 0, 0, 0, 0);
300 expectError(GL_INVALID_VALUE);
301 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, compressedFormats[0], 0, -1, 0, 0, 0);
302 expectError(GL_INVALID_VALUE);
303 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, compressedFormats[0], -1, -1, 0, 0, 0);
304 expectError(GL_INVALID_VALUE);
305 m_log << TestLog::EndSection;
306 }
307 });
308 ES2F_ADD_API_CASE(compressedteximage2d_neg_width_height_cube_pos_y, "Invalid glCompressedTexImage2D() usage",
309 {
310 vector<deInt32> compressedFormats;
311 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
312 if (!compressedFormats.empty())
313 {
314 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
315 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, compressedFormats[0], -1, 0, 0, 0, 0);
316 expectError(GL_INVALID_VALUE);
317 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, compressedFormats[0], 0, -1, 0, 0, 0);
318 expectError(GL_INVALID_VALUE);
319 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, compressedFormats[0], -1, -1, 0, 0, 0);
320 expectError(GL_INVALID_VALUE);
321 m_log << TestLog::EndSection;
322 }
323 });
324 ES2F_ADD_API_CASE(compressedteximage2d_neg_width_height_cube_pos_z, "Invalid glCompressedTexImage2D() usage",
325 {
326 vector<deInt32> compressedFormats;
327 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
328 if (!compressedFormats.empty())
329 {
330 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
331 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, compressedFormats[0], -1, 0, 0, 0, 0);
332 expectError(GL_INVALID_VALUE);
333 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, compressedFormats[0], 0, -1, 0, 0, 0);
334 expectError(GL_INVALID_VALUE);
335 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, compressedFormats[0], -1, -1, 0, 0, 0);
336 expectError(GL_INVALID_VALUE);
337 m_log << TestLog::EndSection;
338 }
339 });
340 ES2F_ADD_API_CASE(compressedteximage2d_neg_width_height_cube_neg_x, "Invalid glCompressedTexImage2D() usage",
341 {
342 vector<deInt32> compressedFormats;
343 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
344 if (!compressedFormats.empty())
345 {
346 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
347 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, compressedFormats[0], -1, 0, 0, 0, 0);
348 expectError(GL_INVALID_VALUE);
349 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, compressedFormats[0], 0, -1, 0, 0, 0);
350 expectError(GL_INVALID_VALUE);
351 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, compressedFormats[0], -1, -1, 0, 0, 0);
352 expectError(GL_INVALID_VALUE);
353 m_log << TestLog::EndSection;
354 }
355 });
356 ES2F_ADD_API_CASE(compressedteximage2d_neg_width_height_cube_neg_y, "Invalid glCompressedTexImage2D() usage",
357 {
358 vector<deInt32> compressedFormats;
359 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
360 if (!compressedFormats.empty())
361 {
362 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
363 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, compressedFormats[0], -1, 0, 0, 0, 0);
364 expectError(GL_INVALID_VALUE);
365 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, compressedFormats[0], 0, -1, 0, 0, 0);
366 expectError(GL_INVALID_VALUE);
367 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, compressedFormats[0], -1, -1, 0, 0, 0);
368 expectError(GL_INVALID_VALUE);
369 m_log << TestLog::EndSection;
370 }
371 });
372 ES2F_ADD_API_CASE(compressedteximage2d_neg_width_height_cube_neg_z, "Invalid glCompressedTexImage2D() usage",
373 {
374 vector<deInt32> compressedFormats;
375 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
376 if (!compressedFormats.empty())
377 {
378 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
379 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, compressedFormats[0], -1, 0, 0, 0, 0);
380 expectError(GL_INVALID_VALUE);
381 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, compressedFormats[0], 0, -1, 0, 0, 0);
382 expectError(GL_INVALID_VALUE);
383 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, compressedFormats[0], -1, -1, 0, 0, 0);
384 expectError(GL_INVALID_VALUE);
385 m_log << TestLog::EndSection;
386 }
387 });
388 ES2F_ADD_API_CASE(compressedteximage2d_width_height_max_tex2d, "Invalid glCompressedTexImage2D() usage",
389 {
390 vector<deInt32> compressedFormats;
391 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
392 if (!compressedFormats.empty())
393 {
394 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_TEXTURE_SIZE.");
395 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE) + 1;
396 glCompressedTexImage2D(GL_TEXTURE_2D, 0, compressedFormats[0], maxTextureSize, 0, 0, 0, 0);
397 expectError(GL_INVALID_VALUE);
398 glCompressedTexImage2D(GL_TEXTURE_2D, 0, compressedFormats[0], 0, maxTextureSize, 0, 0, 0);
399 expectError(GL_INVALID_VALUE);
400 glCompressedTexImage2D(GL_TEXTURE_2D, 0, compressedFormats[0], maxTextureSize, maxTextureSize, 0, 0, 0);
401 expectError(GL_INVALID_VALUE);
402 m_log << TestLog::EndSection;
403 }
404 });
405 ES2F_ADD_API_CASE(compressedteximage2d_width_height_max_cube_pos_x, "Invalid glCompressedTexImage2D() usage",
406 {
407 vector<deInt32> compressedFormats;
408 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
409 if (!compressedFormats.empty())
410 {
411 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
412 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
413 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, compressedFormats[0], maxTextureSize, 0, 0, 0, 0);
414 expectError(GL_INVALID_VALUE);
415 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, compressedFormats[0], 0, maxTextureSize, 0, 0, 0);
416 expectError(GL_INVALID_VALUE);
417 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, compressedFormats[0], maxTextureSize, maxTextureSize, 0, 0, 0);
418 expectError(GL_INVALID_VALUE);
419 m_log << TestLog::EndSection;
420 }
421 });
422 ES2F_ADD_API_CASE(compressedteximage2d_width_height_max_cube_pos_y, "Invalid glCompressedTexImage2D() usage",
423 {
424 vector<deInt32> compressedFormats;
425 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
426 if (!compressedFormats.empty())
427 {
428 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
429 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
430 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, compressedFormats[0], maxTextureSize, 0, 0, 0, 0);
431 expectError(GL_INVALID_VALUE);
432 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, compressedFormats[0], 0, maxTextureSize, 0, 0, 0);
433 expectError(GL_INVALID_VALUE);
434 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, compressedFormats[0], maxTextureSize, maxTextureSize, 0, 0, 0);
435 expectError(GL_INVALID_VALUE);
436 m_log << TestLog::EndSection;
437 }
438 });
439 ES2F_ADD_API_CASE(compressedteximage2d_width_height_max_cube_pos_z, "Invalid glCompressedTexImage2D() usage",
440 {
441 vector<deInt32> compressedFormats;
442 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
443 if (!compressedFormats.empty())
444 {
445 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
446 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
447 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, compressedFormats[0], maxTextureSize, 0, 0, 0, 0);
448 expectError(GL_INVALID_VALUE);
449 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, compressedFormats[0], 0, maxTextureSize, 0, 0, 0);
450 expectError(GL_INVALID_VALUE);
451 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, compressedFormats[0], maxTextureSize, maxTextureSize, 0, 0, 0);
452 expectError(GL_INVALID_VALUE);
453 m_log << TestLog::EndSection;
454 }
455 });
456 ES2F_ADD_API_CASE(compressedteximage2d_width_height_max_cube_neg_x, "Invalid glCompressedTexImage2D() usage",
457 {
458 vector<deInt32> compressedFormats;
459 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
460 if (!compressedFormats.empty())
461 {
462 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
463 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
464 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, compressedFormats[0], maxTextureSize, 0, 0, 0, 0);
465 expectError(GL_INVALID_VALUE);
466 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, compressedFormats[0], 0, maxTextureSize, 0, 0, 0);
467 expectError(GL_INVALID_VALUE);
468 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, compressedFormats[0], maxTextureSize, maxTextureSize, 0, 0, 0);
469 expectError(GL_INVALID_VALUE);
470 m_log << TestLog::EndSection;
471 }
472 });
473 ES2F_ADD_API_CASE(compressedteximage2d_width_height_max_cube_neg_y, "Invalid glCompressedTexImage2D() usage",
474 {
475 vector<deInt32> compressedFormats;
476 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
477 if (!compressedFormats.empty())
478 {
479 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
480 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
481 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, compressedFormats[0], maxTextureSize, 0, 0, 0, 0);
482 expectError(GL_INVALID_VALUE);
483 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, compressedFormats[0], 0, maxTextureSize, 0, 0, 0);
484 expectError(GL_INVALID_VALUE);
485 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, compressedFormats[0], maxTextureSize, maxTextureSize, 0, 0, 0);
486 expectError(GL_INVALID_VALUE);
487 m_log << TestLog::EndSection;
488 }
489 });
490 ES2F_ADD_API_CASE(compressedteximage2d_width_height_max_cube_neg_z, "Invalid glCompressedTexImage2D() usage",
491 {
492 vector<deInt32> compressedFormats;
493 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
494 if (!compressedFormats.empty())
495 {
496 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
497 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
498 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, compressedFormats[0], maxTextureSize, 0, 0, 0, 0);
499 expectError(GL_INVALID_VALUE);
500 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, compressedFormats[0], 0, maxTextureSize, 0, 0, 0);
501 expectError(GL_INVALID_VALUE);
502 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, compressedFormats[0], maxTextureSize, maxTextureSize, 0, 0, 0);
503 expectError(GL_INVALID_VALUE);
504 m_log << TestLog::EndSection;
505 }
506 });
507 ES2F_ADD_API_CASE(compressedteximage2d_invalid_border, "Invalid glCompressedTexImage2D() usage",
508 {
509 vector<deInt32> compressedFormats;
510 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
511 if (!compressedFormats.empty())
512 {
513 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
514 glCompressedTexImage2D(GL_TEXTURE_2D, 0, compressedFormats[0], 0, 0, 1, 0, 0);
515 expectError(GL_INVALID_VALUE);
516 glCompressedTexImage2D(GL_TEXTURE_2D, 0, compressedFormats[0], 0, 0, -1, 0, 0);
517 expectError(GL_INVALID_VALUE);
518 m_log << TestLog::EndSection;
519 }
520 });
521
522 ES2F_ADD_API_CASE(compressedteximage2d_invalid_border_cube_pos_x, "Invalid glCompressedTexImage2D() usage",
523 {
524 vector<deInt32> compressedFormats;
525 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
526 if (!compressedFormats.empty())
527 {
528 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
529 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, compressedFormats[0], 0, 0, 1, 0, 0);
530 expectError(GL_INVALID_VALUE);
531 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, compressedFormats[0], 0, 0, -1, 0, 0);
532 expectError(GL_INVALID_VALUE);
533 m_log << TestLog::EndSection;
534 }
535 });
536 ES2F_ADD_API_CASE(compressedteximage2d_invalid_border_cube_pos_y, "Invalid glCompressedTexImage2D() usage",
537 {
538 vector<deInt32> compressedFormats;
539 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
540 if (!compressedFormats.empty())
541 {
542 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
543 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, compressedFormats[0], 0, 0, 1, 0, 0);
544 expectError(GL_INVALID_VALUE);
545 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, compressedFormats[0], 0, 0, -1, 0, 0);
546 expectError(GL_INVALID_VALUE);
547 m_log << TestLog::EndSection;
548 }
549 });
550 ES2F_ADD_API_CASE(compressedteximage2d_invalid_border_cube_pos_z, "Invalid glCompressedTexImage2D() usage",
551 {
552 vector<deInt32> compressedFormats;
553 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
554 if (!compressedFormats.empty())
555 {
556 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
557 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, compressedFormats[0], 0, 0, 1, 0, 0);
558 expectError(GL_INVALID_VALUE);
559 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, compressedFormats[0], 0, 0, -1, 0, 0);
560 expectError(GL_INVALID_VALUE);
561 m_log << TestLog::EndSection;
562 }
563 });
564 ES2F_ADD_API_CASE(compressedteximage2d_invalid_border_cube_neg_x, "Invalid glCompressedTexImage2D() usage",
565 {
566 vector<deInt32> compressedFormats;
567 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
568 if (!compressedFormats.empty())
569 {
570 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
571 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, compressedFormats[0], 0, 0, 1, 0, 0);
572 expectError(GL_INVALID_VALUE);
573 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, compressedFormats[0], 0, 0, -1, 0, 0);
574 expectError(GL_INVALID_VALUE);
575 m_log << TestLog::EndSection;
576 }
577 });
578 ES2F_ADD_API_CASE(compressedteximage2d_invalid_border_cube_neg_y, "Invalid glCompressedTexImage2D() usage",
579 {
580 vector<deInt32> compressedFormats;
581 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
582 if (!compressedFormats.empty())
583 {
584 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
585 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, compressedFormats[0], 0, 0, 1, 0, 0);
586 expectError(GL_INVALID_VALUE);
587 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, compressedFormats[0], 0, 0, -1, 0, 0);
588 expectError(GL_INVALID_VALUE);
589 m_log << TestLog::EndSection;
590 }
591 });
592 ES2F_ADD_API_CASE(compressedteximage2d_invalid_border_cube_neg_z, "Invalid glCompressedTexImage2D() usage",
593 {
594 vector<deInt32> compressedFormats;
595 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
596 if (!compressedFormats.empty())
597 {
598 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
599 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, compressedFormats[0], 0, 0, 1, 0, 0);
600 expectError(GL_INVALID_VALUE);
601 glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, compressedFormats[0], 0, 0, -1, 0, 0);
602 expectError(GL_INVALID_VALUE);
603 m_log << TestLog::EndSection;
604 }
605 });
606 ES2F_ADD_API_CASE(compressedteximage2d_invalid_size, "Invalid glCompressedTexImage2D() usage",
607 {
608 vector<deInt32> compressedFormats;
609 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
610 if (!compressedFormats.empty())
611 {
612 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if imageSize is not consistent with the format, dimensions, and contents of the specified compressed image data.");
613 glCompressedTexImage2D(GL_TEXTURE_2D, 0, compressedFormats[0], 0, 0, 0, -1, 0);
614 expectError(GL_INVALID_VALUE);
615 m_log << TestLog::EndSection;
616 }
617 });
618
619 // glCopyTexImage2D
620
621 ES2F_ADD_API_CASE(copyteximage2d_invalid_target, "Invalid glCopyTexImage2D() usage",
622 {
623 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is invalid.");
624 glCopyTexImage2D(0, 0, GL_RGB, 0, 0, 64, 64, 0);
625 expectError(GL_INVALID_ENUM);
626 m_log << TestLog::EndSection;
627 });
628 ES2F_ADD_API_CASE(copyteximage2d_invalid_format_tex2d, "Invalid glCopyTexImage2D() usage",
629 {
630 m_log << TestLog::Section("", "GL_INVALID_ENUM or GL_INVALID_VALUE is generated if internalformat is not an accepted format.");
631 glCopyTexImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 64, 64, 0);
632 expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
633 m_log << TestLog::EndSection;
634 });
635 ES2F_ADD_API_CASE(copyteximage2d_invalid_format_cube, "Invalid glCopyTexImage2D() usage",
636 {
637 m_log << TestLog::Section("", "GL_INVALID_ENUM or GL_INVALID_VALUE is generated if internalformat is not an accepted format.");
638 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, 0, 0, 0, 16, 16, 0);
639 expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
640 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, 0, 0, 0, 16, 16, 0);
641 expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
642 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, 0, 0, 0, 16, 16, 0);
643 expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
644 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, 0, 0, 0, 16, 16, 0);
645 expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
646 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, 0, 0, 0, 16, 16, 0);
647 expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
648 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, 0, 0, 0, 16, 16, 0);
649 expectError(GL_INVALID_ENUM, GL_INVALID_VALUE);
650 m_log << TestLog::EndSection;
651 });
652 ES2F_ADD_API_CASE(copyteximage2d_inequal_width_height_cube, "Invalid glCopyTexImage2D() usage",
653 {
654 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if target is one of the six cube map 2D image targets and the width and height parameters are not equal.");
655 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 16, 17, 0);
656 expectError(GL_INVALID_VALUE);
657 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, 16, 17, 0);
658 expectError(GL_INVALID_VALUE);
659 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, 16, 17, 0);
660 expectError(GL_INVALID_VALUE);
661 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, 16, 17, 0);
662 expectError(GL_INVALID_VALUE);
663 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, 16, 17, 0);
664 expectError(GL_INVALID_VALUE);
665 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, 16, 17, 0);
666 expectError(GL_INVALID_VALUE);
667 m_log << TestLog::EndSection;
668 });
669 ES2F_ADD_API_CASE(copyteximage2d_neg_level_tex2d, "Invalid glCopyTexImage2D() usage",
670 {
671 m_log << TestLog::Section("", "");
672 glCopyTexImage2D(GL_TEXTURE_2D, -1, GL_RGB, 0, 0, 64, 64, 0);
673 expectError(GL_INVALID_VALUE);
674 m_log << TestLog::EndSection;
675 });
676 ES2F_ADD_API_CASE(copyteximage2d_neg_level_cube, "Invalid glCopyTexImage2D() usage",
677 {
678 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
679 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, -1, GL_RGB, 0, 0, 16, 16, 0);
680 expectError(GL_INVALID_VALUE);
681 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, -1, GL_RGB, 0, 0, 16, 16, 0);
682 expectError(GL_INVALID_VALUE);
683 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, -1, GL_RGB, 0, 0, 16, 16, 0);
684 expectError(GL_INVALID_VALUE);
685 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, -1, GL_RGB, 0, 0, 16, 16, 0);
686 expectError(GL_INVALID_VALUE);
687 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, -1, GL_RGB, 0, 0, 16, 16, 0);
688 expectError(GL_INVALID_VALUE);
689 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, -1, GL_RGB, 0, 0, 16, 16, 0);
690 expectError(GL_INVALID_VALUE);
691 m_log << TestLog::EndSection;
692 });
693 ES2F_ADD_API_CASE(copyteximage2d_level_max_tex2d, "Invalid glCopyTexImage2D() usage",
694 {
695 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
696 deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
697 glCopyTexImage2D(GL_TEXTURE_2D, log2MaxTextureSize, GL_RGB, 0, 0, 64, 64, 0);
698 expectError(GL_INVALID_VALUE);
699 m_log << TestLog::EndSection;
700 });
701 ES2F_ADD_API_CASE(copyteximage2d_level_max_cube, "Invalid glCopyTexImage2D() usage",
702 {
703 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_TEXTURE_SIZE).");
704 deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
705 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, log2MaxTextureSize, GL_RGB, 0, 0, 16, 16, 0);
706 expectError(GL_INVALID_VALUE);
707 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, log2MaxTextureSize, GL_RGB, 0, 0, 16, 16, 0);
708 expectError(GL_INVALID_VALUE);
709 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, log2MaxTextureSize, GL_RGB, 0, 0, 16, 16, 0);
710 expectError(GL_INVALID_VALUE);
711 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, log2MaxTextureSize, GL_RGB, 0, 0, 16, 16, 0);
712 expectError(GL_INVALID_VALUE);
713 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, log2MaxTextureSize, GL_RGB, 0, 0, 16, 16, 0);
714 expectError(GL_INVALID_VALUE);
715 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, log2MaxTextureSize, GL_RGB, 0, 0, 16, 16, 0);
716 expectError(GL_INVALID_VALUE);
717 m_log << TestLog::EndSection;
718 });
719 ES2F_ADD_API_CASE(copyteximage2d_invalid_width_height_tex2d, "Invalid glCopyTexImage2D() usage",
720 {
721 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
722 glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, -1, 1, 0);
723 expectError(GL_INVALID_VALUE);
724 glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 1, -1, 0);
725 expectError(GL_INVALID_VALUE);
726 glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, -1, -1, 0);
727 expectError(GL_INVALID_VALUE);
728 m_log << TestLog::EndSection;
729 });
730 ES2F_ADD_API_CASE(copyteximage2d_invalid_width_height_cube_pos_x, "Invalid glCopyTexImage2D() usage",
731 {
732 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
733 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, -1, 1, 0);
734 expectError(GL_INVALID_VALUE);
735 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 1, -1, 0);
736 expectError(GL_INVALID_VALUE);
737 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, -1, -1, 0);
738 expectError(GL_INVALID_VALUE);
739 m_log << TestLog::EndSection;
740 });
741 ES2F_ADD_API_CASE(copyteximage2d_invalid_width_height_cube_pos_y, "Invalid glCopyTexImage2D() usage",
742 {
743 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
744 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, -1, 1, 0);
745 expectError(GL_INVALID_VALUE);
746 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, 1, -1, 0);
747 expectError(GL_INVALID_VALUE);
748 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, -1, -1, 0);
749 expectError(GL_INVALID_VALUE);
750 m_log << TestLog::EndSection;
751 });
752 ES2F_ADD_API_CASE(copyteximage2d_invalid_width_height_cube_pos_z, "Invalid glCopyTexImage2D() usage",
753 {
754 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
755 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, -1, 1, 0);
756 expectError(GL_INVALID_VALUE);
757 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, 1, -1, 0);
758 expectError(GL_INVALID_VALUE);
759 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, -1, -1, 0);
760 expectError(GL_INVALID_VALUE);
761 m_log << TestLog::EndSection;
762 });
763 ES2F_ADD_API_CASE(copyteximage2d_invalid_width_height_cube_neg_x, "Invalid glCopyTexImage2D() usage",
764 {
765 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
766 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, -1, 1, 0);
767 expectError(GL_INVALID_VALUE);
768 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, 1, -1, 0);
769 expectError(GL_INVALID_VALUE);
770 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, -1, -1, 0);
771 expectError(GL_INVALID_VALUE);
772 m_log << TestLog::EndSection;
773 });
774 ES2F_ADD_API_CASE(copyteximage2d_invalid_width_height_cube_neg_y, "Invalid glCopyTexImage2D() usage",
775 {
776 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
777 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, -1, 1, 0);
778 expectError(GL_INVALID_VALUE);
779 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, 1, -1, 0);
780 expectError(GL_INVALID_VALUE);
781 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, -1, -1, 0);
782 expectError(GL_INVALID_VALUE);
783 m_log << TestLog::EndSection;
784 });
785 ES2F_ADD_API_CASE(copyteximage2d_invalid_width_height_cube_neg_z, "Invalid glCopyTexImage2D() usage",
786 {
787 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
788 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, -1, 1, 0);
789 expectError(GL_INVALID_VALUE);
790 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, 1, -1, 0);
791 expectError(GL_INVALID_VALUE);
792 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, -1, -1, 0);
793 expectError(GL_INVALID_VALUE);
794 m_log << TestLog::EndSection;
795 });
796 ES2F_ADD_API_CASE(copyteximage2d_width_height_max_tex2d, "Invalid glCopyTexImage2D() usage",
797 {
798 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_TEXTURE_SIZE.");
799 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE) + 1;
800 glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, maxTextureSize, 1, 0);
801 expectError(GL_INVALID_VALUE);
802 glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 1, maxTextureSize, 0);
803 expectError(GL_INVALID_VALUE);
804 glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, maxTextureSize, maxTextureSize, 0);
805 expectError(GL_INVALID_VALUE);
806 m_log << TestLog::EndSection;
807 });
808 ES2F_ADD_API_CASE(copyteximage2d_width_height_max_cube_pos_x, "Invalid glCopyTexImage2D() usage",
809 {
810 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
811 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
812 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 1, maxTextureSize, 0);
813 expectError(GL_INVALID_VALUE);
814 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, maxTextureSize, 1, 0);
815 expectError(GL_INVALID_VALUE);
816 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, maxTextureSize, maxTextureSize, 0);
817 expectError(GL_INVALID_VALUE);
818 m_log << TestLog::EndSection;
819 });
820 ES2F_ADD_API_CASE(copyteximage2d_width_height_max_cube_pos_y, "Invalid glCopyTexImage2D() usage",
821 {
822 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
823 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
824 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, 1, maxTextureSize, 0);
825 expectError(GL_INVALID_VALUE);
826 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, maxTextureSize, 1, 0);
827 expectError(GL_INVALID_VALUE);
828 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, maxTextureSize, maxTextureSize, 0);
829 expectError(GL_INVALID_VALUE);
830 m_log << TestLog::EndSection;
831 });
832 ES2F_ADD_API_CASE(copyteximage2d_width_height_max_cube_pos_z, "Invalid glCopyTexImage2D() usage",
833 {
834 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
835 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
836 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, 1, maxTextureSize, 0);
837 expectError(GL_INVALID_VALUE);
838 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, maxTextureSize, 1, 0);
839 expectError(GL_INVALID_VALUE);
840 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, maxTextureSize, maxTextureSize, 0);
841 expectError(GL_INVALID_VALUE);
842 m_log << TestLog::EndSection;
843 });
844 ES2F_ADD_API_CASE(copyteximage2d_width_height_max_cube_neg_x, "Invalid glCopyTexImage2D() usage",
845 {
846 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
847 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
848 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, 1, maxTextureSize, 0);
849 expectError(GL_INVALID_VALUE);
850 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, maxTextureSize, 1, 0);
851 expectError(GL_INVALID_VALUE);
852 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, maxTextureSize, maxTextureSize, 0);
853 expectError(GL_INVALID_VALUE);
854 m_log << TestLog::EndSection;
855 });
856 ES2F_ADD_API_CASE(copyteximage2d_width_height_max_cube_neg_y, "Invalid glCopyTexImage2D() usage",
857 {
858 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
859 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
860 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, 1, maxTextureSize, 0);
861 expectError(GL_INVALID_VALUE);
862 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, maxTextureSize, 1, 0);
863 expectError(GL_INVALID_VALUE);
864 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, maxTextureSize, maxTextureSize, 0);
865 expectError(GL_INVALID_VALUE);
866 m_log << TestLog::EndSection;
867 });
868 ES2F_ADD_API_CASE(copyteximage2d_width_height_max_cube_neg_z, "Invalid glCopyTexImage2D() usage",
869 {
870 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
871 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
872 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, 1, maxTextureSize, 0);
873 expectError(GL_INVALID_VALUE);
874 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, maxTextureSize, 1, 0);
875 expectError(GL_INVALID_VALUE);
876 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, maxTextureSize, maxTextureSize, 0);
877 expectError(GL_INVALID_VALUE);
878 m_log << TestLog::EndSection;
879 });
880 ES2F_ADD_API_CASE(copyteximage2d_invalid_border_tex2d, "Invalid glCopyTexImage2D() usage",
881 {
882 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
883 glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 64, 64, -1);
884 expectError(GL_INVALID_VALUE);
885 glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 64, 64, 1);
886 expectError(GL_INVALID_VALUE);
887 m_log << TestLog::EndSection;
888 });
889 ES2F_ADD_API_CASE(copyteximage2d_invalid_border_cube_pos_x, "Invalid glCopyTexImage2D() usage",
890 {
891 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
892 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 16, 16, -1);
893 expectError(GL_INVALID_VALUE);
894 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 16, 16, 1);
895 expectError(GL_INVALID_VALUE);
896 m_log << TestLog::EndSection;
897 });
898 ES2F_ADD_API_CASE(copyteximage2d_invalid_border_cube_pos_y, "Invalid glCopyTexImage2D() usage",
899 {
900 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
901 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, 16, 16, -1);
902 expectError(GL_INVALID_VALUE);
903 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, 16, 16, 1);
904 expectError(GL_INVALID_VALUE);
905 m_log << TestLog::EndSection;
906 });
907 ES2F_ADD_API_CASE(copyteximage2d_invalid_border_cube_pos_z, "Invalid glCopyTexImage2D() usage",
908 {
909 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
910 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, 16, 16, -1);
911 expectError(GL_INVALID_VALUE);
912 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, 16, 16, 1);
913 expectError(GL_INVALID_VALUE);
914 m_log << TestLog::EndSection;
915 });
916 ES2F_ADD_API_CASE(copyteximage2d_invalid_border_cube_neg_x, "Invalid glCopyTexImage2D() usage",
917 {
918 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
919 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, 16, 16, -1);
920 expectError(GL_INVALID_VALUE);
921 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, 16, 16, 1);
922 expectError(GL_INVALID_VALUE);
923 m_log << TestLog::EndSection;
924 });
925 ES2F_ADD_API_CASE(copyteximage2d_invalid_border_cube_neg_y, "Invalid glCopyTexImage2D() usage",
926 {
927 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
928 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, 16, 16, -1);
929 expectError(GL_INVALID_VALUE);
930 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, 16, 16, 1);
931 expectError(GL_INVALID_VALUE);
932 m_log << TestLog::EndSection;
933 });
934 ES2F_ADD_API_CASE(copyteximage2d_invalid_border_cube_neg_z, "Invalid glCopyTexImage2D() usage",
935 {
936 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
937 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, 16, 16, -1);
938 expectError(GL_INVALID_VALUE);
939 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, 16, 16, 1);
940 expectError(GL_INVALID_VALUE);
941 m_log << TestLog::EndSection;
942 });
943
944 ES2F_ADD_API_CASE(copyteximage2d_incomplete_framebuffer, "Invalid glCopyTexImage2D() usage",
945 {
946 m_log << tcu::TestLog::Section("", "GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
947 GLuint fbo;
948 glGenFramebuffers(1, &fbo);
949 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
950 glCheckFramebufferStatus(GL_FRAMEBUFFER);
951
952 glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 64, 64, 0);
953 expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
954 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 0, 0, 16, 16, 0);
955 expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
956 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 0, 0, 16, 16, 0);
957 expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
958 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 0, 0, 16, 16, 0);
959 expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
960 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 0, 0, 16, 16, 0);
961 expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
962 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 0, 0, 16, 16, 0);
963 expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
964 glCopyTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 0, 0, 16, 16, 0);
965 expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
966
967 glBindFramebuffer(GL_FRAMEBUFFER, 0);
968 glDeleteFramebuffers(1, &fbo);
969 m_log << tcu::TestLog::EndSection;
970 });
971
972 // glCopyTexSubImage2D
973
974 ES2F_ADD_API_CASE(copytexsubimage2d_invalid_target, "Invalid glCopyTexSubImage2D() usage",
975 {
976 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is invalid.");
977 glCopyTexSubImage2D(0, 0, 0, 0, 0, 0, 0, 0);
978 expectError(GL_INVALID_ENUM);
979 m_log << TestLog::EndSection;
980 });
981 ES2F_ADD_API_CASE(copytexsubimage2d_neg_level_tex2d, "Invalid glCopyTexSubImage2D() usage",
982 {
983 GLuint texture;
984 glGenTextures(1, &texture);
985 glBindTexture(GL_TEXTURE_2D, texture);
986 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
987
988 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
989 glCopyTexSubImage2D(GL_TEXTURE_2D, -1, 0, 0, 0, 0, 0, 0);
990 expectError(GL_INVALID_VALUE);
991 m_log << TestLog::EndSection;
992
993 glDeleteTextures(1, &texture);
994 });
995 ES2F_ADD_API_CASE(copytexsubimage2d_neg_level_cube, "Invalid glCopyTexSubImage2D() usage",
996 {
997 GLuint texture;
998 glGenTextures(1, &texture);
999 glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
1000 FOR_CUBE_FACES(faceGL, glTexImage2D(faceGL, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL););
1001
1002 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
1003 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, -1, 0, 0, 0, 0, 0, 0);
1004 expectError(GL_INVALID_VALUE);
1005 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, -1, 0, 0, 0, 0, 0, 0);
1006 expectError(GL_INVALID_VALUE);
1007 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, -1, 0, 0, 0, 0, 0, 0);
1008 expectError(GL_INVALID_VALUE);
1009 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, -1, 0, 0, 0, 0, 0, 0);
1010 expectError(GL_INVALID_VALUE);
1011 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, -1, 0, 0, 0, 0, 0, 0);
1012 expectError(GL_INVALID_VALUE);
1013 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, -1, 0, 0, 0, 0, 0, 0);
1014 expectError(GL_INVALID_VALUE);
1015 m_log << TestLog::EndSection;
1016
1017 glDeleteTextures(1, &texture);
1018 });
1019 ES2F_ADD_API_CASE(copytexsubimage2d_level_max_tex2d, "Invalid glCopyTexSubImage2D() usage",
1020 {
1021 GLuint texture;
1022 glGenTextures(1, &texture);
1023 glBindTexture(GL_TEXTURE_2D, texture);
1024 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1025
1026 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
1027 deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
1028 glCopyTexSubImage2D(GL_TEXTURE_2D, log2MaxTextureSize, 0, 0, 0, 0, 0, 0);
1029 expectError(GL_INVALID_VALUE);
1030 m_log << TestLog::EndSection;
1031
1032 glDeleteTextures(1, &texture);
1033 });
1034 ES2F_ADD_API_CASE(copytexsubimage2d_level_max_cube_pos, "Invalid glCopyTexSubImage2D() usage",
1035 {
1036 GLuint texture;
1037 glGenTextures(1, &texture);
1038 glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
1039 FOR_CUBE_FACES(faceGL, glTexImage2D(faceGL, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL););
1040
1041 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_SIZE).");
1042 deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
1043 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, log2MaxTextureSize, 0, 0, 0, 0, 0, 0);
1044 expectError(GL_INVALID_VALUE);
1045 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, log2MaxTextureSize, 0, 0, 0, 0, 0, 0);
1046 expectError(GL_INVALID_VALUE);
1047 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, log2MaxTextureSize, 0, 0, 0, 0, 0, 0);
1048 expectError(GL_INVALID_VALUE);
1049 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, log2MaxTextureSize, 0, 0, 0, 0, 0, 0);
1050 expectError(GL_INVALID_VALUE);
1051 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, log2MaxTextureSize, 0, 0, 0, 0, 0, 0);
1052 expectError(GL_INVALID_VALUE);
1053 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, log2MaxTextureSize, 0, 0, 0, 0, 0, 0);
1054 expectError(GL_INVALID_VALUE);
1055 m_log << TestLog::EndSection;
1056
1057 glDeleteTextures(1, &texture);
1058 });
1059 ES2F_ADD_API_CASE(copytexsubimage2d_neg_offset, "Invalid glCopyTexSubImage2D() usage",
1060 {
1061 GLuint texture;
1062 glGenTextures(1, &texture);
1063 glBindTexture(GL_TEXTURE_2D, texture);
1064 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1065
1066 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if xoffset < 0 or yoffset < 0.");
1067 glCopyTexSubImage2D(GL_TEXTURE_2D, 0, -1, 0, 0, 0, 0, 0);
1068 expectError(GL_INVALID_VALUE);
1069 glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, -1, 0, 0, 0, 0);
1070 expectError(GL_INVALID_VALUE);
1071 glCopyTexSubImage2D(GL_TEXTURE_2D, 0, -1, -1, 0, 0, 0, 0);
1072 expectError(GL_INVALID_VALUE);
1073 m_log << TestLog::EndSection;
1074
1075 glDeleteTextures(1, &texture);
1076 });
1077 ES2F_ADD_API_CASE(copytexsubimage2d_offset_allowed, "Invalid glCopyTexSubImage2D() usage",
1078 {
1079 GLuint texture;
1080 glGenTextures(1, &texture);
1081 glBindTexture(GL_TEXTURE_2D, texture);
1082 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1083
1084 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if xoffset + width > texture_width or yoffset + height > texture_height.");
1085 glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 8, 4, 0, 0, 10, 10);
1086 expectError(GL_INVALID_VALUE);
1087 glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 4, 8, 0, 0, 10, 10);
1088 expectError(GL_INVALID_VALUE);
1089 glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 8, 8, 0, 0, 10, 10);
1090 expectError(GL_INVALID_VALUE);
1091 m_log << TestLog::EndSection;
1092
1093 glDeleteTextures(1, &texture);
1094 });
1095 ES2F_ADD_API_CASE(copytexsubimage2d_neg_wdt_hgt, "Invalid glCopyTexSubImage2D() usage",
1096 {
1097 GLuint texture;
1098 glGenTextures(1, &texture);
1099 glBindTexture(GL_TEXTURE_2D, texture);
1100 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1101
1102 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
1103 glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, -1, 0);
1104 expectError(GL_INVALID_VALUE);
1105 glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, -1);
1106 expectError(GL_INVALID_VALUE);
1107 glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, -1, -1);
1108 expectError(GL_INVALID_VALUE);
1109 m_log << TestLog::EndSection;
1110
1111 glDeleteTextures(1, &texture);
1112 });
1113 ES2F_ADD_API_CASE(copytexsubimage2d_incomplete_framebuffer, "Invalid glCopyTexSubImage2D() usage",
1114 {
1115 m_log << tcu::TestLog::Section("", "GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
1116
1117 GLuint texture[2];
1118 GLuint fbo;
1119
1120 glGenTextures (2, texture);
1121 glBindTexture (GL_TEXTURE_2D, texture[0]);
1122 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1123 glBindTexture (GL_TEXTURE_CUBE_MAP, texture[1]);
1124 glTexImage2D (GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1125 glTexImage2D (GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1126 glTexImage2D (GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1127 glTexImage2D (GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1128 glTexImage2D (GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1129 glTexImage2D (GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1130 expectError(GL_NO_ERROR);
1131
1132 glGenFramebuffers(1, &fbo);
1133 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1134 glCheckFramebufferStatus(GL_FRAMEBUFFER);
1135 expectError(GL_NO_ERROR);
1136
1137 glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 0);
1138 expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1139 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, 0, 0, 0, 0, 0, 0);
1140 expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1141 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, 0, 0, 0, 0, 0, 0);
1142 expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1143 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, 0, 0, 0, 0, 0, 0);
1144 expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1145 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, 0, 0, 0, 0, 0, 0);
1146 expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1147 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, 0, 0, 0, 0, 0, 0);
1148 expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1149 glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, 0, 0, 0, 0, 0, 0);
1150 expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
1151
1152 glBindFramebuffer(GL_FRAMEBUFFER, 0);
1153 glDeleteFramebuffers(1, &fbo);
1154 glDeleteTextures(2, texture);
1155
1156 m_log << tcu::TestLog::EndSection;
1157
1158 });
1159
1160 // glDeleteTextures
1161
1162 ES2F_ADD_API_CASE(deletetextures_invalid_number, "Invalid glDeleteTextures() usage",
1163 {
1164 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
1165 glDeleteTextures(-1,0);
1166 expectError(GL_INVALID_VALUE);
1167 m_log << TestLog::EndSection;
1168 });
1169 ES2F_ADD_API_CASE(deletetextures_invalid_number_bind, "Invalid glDeleteTextures() usage",
1170 {
1171 GLuint texture;
1172 glGenTextures(1, &texture);
1173
1174 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
1175 glBindTexture(GL_TEXTURE_2D, texture);
1176 glDeleteTextures(-1,0);
1177 expectError(GL_INVALID_VALUE);
1178 m_log << TestLog::EndSection;
1179
1180 glDeleteTextures(1, &texture);
1181 });
1182
1183 // glGenerateMipmap
1184
1185 ES2F_ADD_API_CASE(generatemipmap_invalid_target, "Invalid glGenerateMipmap() usage",
1186 {
1187 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_TEXTURE_2D or GL_TEXTURE_CUBE_MAP.");
1188 glGenerateMipmap(0);
1189 expectError(GL_INVALID_ENUM);
1190 m_log << TestLog::EndSection;
1191 });
1192 ES2F_ADD_API_CASE(generatemipmap_npot_wdt_hgt, "Invalid glGenerateMipmap() usage",
1193 {
1194 GLuint texture;
1195
1196 if (m_context.getContextInfo().isExtensionSupported("GL_OES_texture_npot"))
1197 {
1198 m_log << tcu::TestLog::Message
1199 << "GL_OES_texture_npot extension removes error condition, skipping test"
1200 << tcu::TestLog::EndMessage;
1201 return;
1202 }
1203
1204 glActiveTexture(GL_TEXTURE0);
1205 glGenTextures(1, &texture);
1206 glBindTexture(GL_TEXTURE_2D, texture);
1207
1208 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if either the width or height of the zero level array is not a power of two.");
1209 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256, 257, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1210 glGenerateMipmap(GL_TEXTURE_2D);
1211 expectError(GL_INVALID_OPERATION);
1212 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 257, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1213 glGenerateMipmap(GL_TEXTURE_2D);
1214 expectError(GL_INVALID_OPERATION);
1215 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 257, 257, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1216 glGenerateMipmap(GL_TEXTURE_2D);
1217 expectError(GL_INVALID_OPERATION);
1218 m_log << TestLog::EndSection;
1219
1220 glDeleteTextures(1, &texture);
1221 });
1222 ES2F_ADD_API_CASE(generatemipmap_zero_level_array_compressed, "Invalid glGenerateMipmap() usage",
1223 {
1224 vector<deInt32> compressedFormats;
1225 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, compressedFormats);
1226 if (!compressedFormats.empty())
1227 {
1228 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the zero level array is stored in a compressed internal format.");
1229 glCompressedTexImage2D(GL_TEXTURE_2D, 0, compressedFormats[0], 0, 0, 0, 0, 0);
1230 glGenerateMipmap(GL_TEXTURE_2D);
1231 expectError(GL_INVALID_OPERATION);
1232 m_log << TestLog::EndSection;
1233 }
1234 });
1235 ES2F_ADD_API_CASE(generatemipmap_incomplete_cube, "Invalid glGenerateMipmap() usage",
1236 {
1237 GLuint texture;
1238 glGenTextures(1, &texture);
1239 glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
1240
1241 m_log << TestLog::Section("", "INVALID_OPERATION is generated if the texture bound to target is not cube complete.");
1242 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1243 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1244 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1245 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1246 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1247 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 32, 32, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1248 glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
1249 expectError(GL_INVALID_OPERATION);
1250 m_log << TestLog::EndSection;
1251
1252 glDeleteTextures(1, &texture);
1253 });
1254
1255 // glGenTextures
1256
1257 ES2F_ADD_API_CASE(gentextures_invalid_size, "Invalid glGenTextures() usage",
1258 {
1259 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
1260 glGenTextures(-1, 0);
1261 expectError(GL_INVALID_VALUE);
1262 m_log << TestLog::EndSection;
1263 });
1264
1265 // glPixelStorei
1266
1267 ES2F_ADD_API_CASE(pixelstorei_invalid_pname, "Invalid glPixelStorei() usage",
1268 {
1269 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if pname is not an accepted value.");
1270 glPixelStorei(0,1);
1271 expectError(GL_INVALID_ENUM);
1272 m_log << TestLog::EndSection;
1273 });
1274 ES2F_ADD_API_CASE(pixelstorei_invalid_param, "Invalid glPixelStorei() usage",
1275 {
1276 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if alignment is specified as other than 1, 2, 4, or 8.");
1277 glPixelStorei(GL_PACK_ALIGNMENT, 0);
1278 expectError(GL_INVALID_VALUE);
1279 glPixelStorei(GL_UNPACK_ALIGNMENT, 0);
1280 expectError(GL_INVALID_VALUE);
1281 glPixelStorei(GL_PACK_ALIGNMENT, 16);
1282 expectError(GL_INVALID_VALUE);
1283 glPixelStorei(GL_UNPACK_ALIGNMENT, 16);
1284 expectError(GL_INVALID_VALUE);
1285 m_log << TestLog::EndSection;
1286 });
1287
1288 // glTexImage2D
1289
1290 ES2F_ADD_API_CASE(teximage2d_invalid_target, "Invalid glTexImage2D() usage",
1291 {
1292 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is invalid.");
1293 glTexImage2D(0, 0, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1294 expectError(GL_INVALID_ENUM);
1295 m_log << TestLog::EndSection;
1296 });
1297 ES2F_ADD_API_CASE(teximage2d_invalid_format, "Invalid glTexImage2D() usage",
1298 {
1299 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if format or type is not an accepted value.");
1300 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, 0, GL_UNSIGNED_BYTE, 0);
1301 expectError(GL_INVALID_ENUM);
1302 m_log << TestLog::EndSection;
1303 });
1304 ES2F_ADD_API_CASE(teximage2d_invalid_type, "Invalid glTexImage2D() usage",
1305 {
1306 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if format or type is not an accepted value.");
1307 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, GL_RGB, 0, 0);
1308 expectError(GL_INVALID_ENUM);
1309 m_log << TestLog::EndSection;
1310 });
1311 ES2F_ADD_API_CASE(teximage2d_inequal_width_height_cube, "Invalid glTexImage2D() usage",
1312 {
1313 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if target is one of the six cube map 2D image targets and the width and height parameters are not equal.");
1314 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1315 expectError(GL_INVALID_VALUE);
1316 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1317 expectError(GL_INVALID_VALUE);
1318 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1319 expectError(GL_INVALID_VALUE);
1320 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1321 expectError(GL_INVALID_VALUE);
1322 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1323 expectError(GL_INVALID_VALUE);
1324 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 1, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1325 expectError(GL_INVALID_VALUE);
1326 m_log << TestLog::EndSection;
1327 });
1328 ES2F_ADD_API_CASE(teximage2d_neg_level_tex2d, "Invalid glTexImage2D() usage",
1329 {
1330 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
1331 glTexImage2D(GL_TEXTURE_2D, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1332 expectError(GL_INVALID_VALUE);
1333 m_log << TestLog::EndSection;
1334 });
1335 ES2F_ADD_API_CASE(teximage2d_neg_level_cube, "Invalid glTexImage2D() usage",
1336 {
1337 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
1338 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1339 expectError(GL_INVALID_VALUE);
1340 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1341 expectError(GL_INVALID_VALUE);
1342 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1343 expectError(GL_INVALID_VALUE);
1344 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1345 expectError(GL_INVALID_VALUE);
1346 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1347 expectError(GL_INVALID_VALUE);
1348 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, -1, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1349 expectError(GL_INVALID_VALUE);
1350 m_log << TestLog::EndSection;
1351 });
1352 ES2F_ADD_API_CASE(teximage2d_level_max_tex2d, "Invalid glTexImage2D() usage",
1353 {
1354 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
1355 deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
1356 glTexImage2D(GL_TEXTURE_2D, log2MaxTextureSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1357 expectError(GL_INVALID_VALUE);
1358 m_log << TestLog::EndSection;
1359 });
1360 ES2F_ADD_API_CASE(teximage2d_level_max_cube, "Invalid glTexImage2D() usage",
1361 {
1362 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_TEXTURE_SIZE).");
1363 deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
1364 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, log2MaxTextureSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1365 expectError(GL_INVALID_VALUE);
1366 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, log2MaxTextureSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1367 expectError(GL_INVALID_VALUE);
1368 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, log2MaxTextureSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1369 expectError(GL_INVALID_VALUE);
1370 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, log2MaxTextureSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1371 expectError(GL_INVALID_VALUE);
1372 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, log2MaxTextureSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1373 expectError(GL_INVALID_VALUE);
1374 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, log2MaxTextureSize, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1375 expectError(GL_INVALID_VALUE);
1376 m_log << TestLog::EndSection;
1377 });
1378 ES2F_ADD_API_CASE(teximage2d_invalid_internalformat, "Invalid glTexImage2D() usage",
1379 {
1380 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if internalformat is not an accepted format.");
1381 glTexImage2D(GL_TEXTURE_2D, 0, 0, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1382 expectError(GL_INVALID_VALUE);
1383 m_log << TestLog::EndSection;
1384 });
1385 ES2F_ADD_API_CASE(teximage2d_neg_width_height_tex2d, "Invalid glTexImage2D() usage",
1386 {
1387 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
1388 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1389 expectError(GL_INVALID_VALUE);
1390 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1391 expectError(GL_INVALID_VALUE);
1392 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1393 expectError(GL_INVALID_VALUE);
1394 m_log << TestLog::EndSection;
1395 });
1396 ES2F_ADD_API_CASE(teximage2d_neg_width_height_cube_pos_x, "Invalid glTexImage2D() usage",
1397 {
1398 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
1399 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1400 expectError(GL_INVALID_VALUE);
1401 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1402 expectError(GL_INVALID_VALUE);
1403 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1404 expectError(GL_INVALID_VALUE);
1405 m_log << TestLog::EndSection;
1406 });
1407 ES2F_ADD_API_CASE(teximage2d_neg_width_height_cube_pos_y, "Invalid glTexImage2D() usage",
1408 {
1409 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
1410 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1411 expectError(GL_INVALID_VALUE);
1412 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1413 expectError(GL_INVALID_VALUE);
1414 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1415 expectError(GL_INVALID_VALUE);
1416 m_log << TestLog::EndSection;
1417 });
1418 ES2F_ADD_API_CASE(teximage2d_neg_width_height_cube_pos_z, "Invalid glTexImage2D() usage",
1419 {
1420 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
1421 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1422 expectError(GL_INVALID_VALUE);
1423 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1424 expectError(GL_INVALID_VALUE);
1425 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1426 expectError(GL_INVALID_VALUE);
1427 m_log << TestLog::EndSection;
1428 });
1429 ES2F_ADD_API_CASE(teximage2d_neg_width_height_cube_neg_x, "Invalid glTexImage2D() usage",
1430 {
1431 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
1432 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1433 expectError(GL_INVALID_VALUE);
1434 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1435 expectError(GL_INVALID_VALUE);
1436 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1437 expectError(GL_INVALID_VALUE);
1438 m_log << TestLog::EndSection;
1439 });
1440 ES2F_ADD_API_CASE(teximage2d_neg_width_height_cube_neg_y, "Invalid glTexImage2D() usage",
1441 {
1442 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
1443 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1444 expectError(GL_INVALID_VALUE);
1445 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1446 expectError(GL_INVALID_VALUE);
1447 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1448 expectError(GL_INVALID_VALUE);
1449 m_log << TestLog::EndSection;
1450 });
1451 ES2F_ADD_API_CASE(teximage2d_neg_width_height_cube_neg_z, "Invalid glTexImage2D() usage",
1452 {
1453 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
1454 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, -1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1455 expectError(GL_INVALID_VALUE);
1456 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1457 expectError(GL_INVALID_VALUE);
1458 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, -1, -1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1459 expectError(GL_INVALID_VALUE);
1460 m_log << TestLog::EndSection;
1461 });
1462 ES2F_ADD_API_CASE(teximage2d_width_height_max_tex2d, "Invalid glTexImage2D() usage",
1463 {
1464 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_TEXTURE_SIZE.");
1465 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE) + 1;
1466 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, maxTextureSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1467 expectError(GL_INVALID_VALUE);
1468 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1469 expectError(GL_INVALID_VALUE);
1470 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, maxTextureSize, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1471 expectError(GL_INVALID_VALUE);
1472 m_log << TestLog::EndSection;
1473 });
1474 ES2F_ADD_API_CASE(teximage2d_width_height_max_cube_pos_x, "Invalid glTexImage2D() usage",
1475 {
1476 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
1477 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
1478 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, maxTextureSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1479 expectError(GL_INVALID_VALUE);
1480 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 1, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1481 expectError(GL_INVALID_VALUE);
1482 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, maxTextureSize, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1483 expectError(GL_INVALID_VALUE);
1484 m_log << TestLog::EndSection;
1485 });
1486 ES2F_ADD_API_CASE(teximage2d_width_height_max_cube_pos_y, "Invalid glTexImage2D() usage",
1487 {
1488 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
1489 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
1490 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, maxTextureSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1491 expectError(GL_INVALID_VALUE);
1492 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 1, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1493 expectError(GL_INVALID_VALUE);
1494 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, maxTextureSize, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1495 expectError(GL_INVALID_VALUE);
1496 m_log << TestLog::EndSection;
1497 });
1498 ES2F_ADD_API_CASE(teximage2d_width_height_max_cube_pos_z, "Invalid glTexImage2D() usage",
1499 {
1500 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
1501 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
1502 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, maxTextureSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1503 expectError(GL_INVALID_VALUE);
1504 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 1, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1505 expectError(GL_INVALID_VALUE);
1506 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, maxTextureSize, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1507 expectError(GL_INVALID_VALUE);
1508 m_log << TestLog::EndSection;
1509 });
1510 ES2F_ADD_API_CASE(teximage2d_width_height_max_cube_neg_x, "Invalid glTexImage2D() usage",
1511 {
1512 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
1513 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
1514 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, maxTextureSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1515 expectError(GL_INVALID_VALUE);
1516 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 1, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1517 expectError(GL_INVALID_VALUE);
1518 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, maxTextureSize, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1519 expectError(GL_INVALID_VALUE);
1520 m_log << TestLog::EndSection;
1521 });
1522 ES2F_ADD_API_CASE(teximage2d_width_height_max_cube_neg_y, "Invalid glTexImage2D() usage",
1523 {
1524 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
1525 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
1526 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, maxTextureSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1527 expectError(GL_INVALID_VALUE);
1528 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 1, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1529 expectError(GL_INVALID_VALUE);
1530 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, maxTextureSize, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1531 expectError(GL_INVALID_VALUE);
1532 m_log << TestLog::EndSection;
1533 });
1534 ES2F_ADD_API_CASE(teximage2d_width_height_max_cube_neg_z, "Invalid glTexImage2D() usage",
1535 {
1536 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_CUBE_MAP_TEXTURE_SIZE.");
1537 int maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
1538 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, maxTextureSize, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1539 expectError(GL_INVALID_VALUE);
1540 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 1, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1541 expectError(GL_INVALID_VALUE);
1542 glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, maxTextureSize, maxTextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1543 expectError(GL_INVALID_VALUE);
1544 m_log << TestLog::EndSection;
1545 });
1546 ES2F_ADD_API_CASE(teximage2d_invalid_border, "Invalid glTexImage2D() usage",
1547 {
1548 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if border is not 0.");
1549 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1550 expectError(GL_INVALID_VALUE);
1551 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, -1, GL_RGB, GL_UNSIGNED_BYTE, 0);
1552 expectError(GL_INVALID_VALUE);
1553 m_log << TestLog::EndSection;
1554 });
1555 ES2F_ADD_API_CASE(teximage2d_format_mismatch, "Invalid glTexImage2D() usage",
1556 {
1557 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if format does not match internalformat.");
1558 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1559 expectError(GL_INVALID_OPERATION);
1560 m_log << TestLog::EndSection;
1561 });
1562 ES2F_ADD_API_CASE(teximage2d_type_format_mismatch, "Invalid glTexImage2D() usage",
1563 {
1564 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if type is GL_UNSIGNED_SHORT_4_4_4_4 or GL_UNSIGNED_SHORT_5_5_5_1 and format is not GL_RGBA.");
1565 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, 0);
1566 expectError(GL_INVALID_OPERATION);
1567 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, 0);
1568 expectError(GL_INVALID_OPERATION);
1569 m_log << TestLog::EndSection;
1570 });
1571
1572 // glTexSubImage2D
1573
1574 ES2F_ADD_API_CASE(texsubimage2d_invalid_target, "Invalid glTexSubImage2D() usage",
1575 {
1576 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is invalid.");
1577 glTexSubImage2D(0, 0, 0, 0, 0, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1578 expectError(GL_INVALID_ENUM);
1579 m_log << TestLog::EndSection;
1580 });
1581 ES2F_ADD_API_CASE(texsubimage2d_invalid_format, "Invalid glTexSubImage2D() usage",
1582 {
1583 GLuint texture;
1584 glGenTextures(1, &texture);
1585 glBindTexture(GL_TEXTURE_2D, texture);
1586 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1587
1588 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if format or type is not an accepted value.");
1589 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, GL_UNSIGNED_BYTE, 0);
1590 expectError(GL_INVALID_ENUM);
1591 m_log << TestLog::EndSection;
1592
1593 glDeleteTextures(1, &texture);
1594 });
1595 ES2F_ADD_API_CASE(texsubimage2d_invalid_type, "Invalid glTexSubImage2D() usage",
1596 {
1597 GLuint texture;
1598 glGenTextures(1, &texture);
1599 glBindTexture(GL_TEXTURE_2D, texture);
1600 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1601
1602 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if format or type is not an accepted value.");
1603 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, GL_RGB, 0, 0);
1604 expectError(GL_INVALID_ENUM);
1605 m_log << TestLog::EndSection;
1606
1607 glDeleteTextures(1, &texture);
1608 });
1609 ES2F_ADD_API_CASE(texsubimage2d_neg_level_tex2d, "Invalid glTexSubImage2D() usage",
1610 {
1611 GLuint texture;
1612 glGenTextures(1, &texture);
1613 glBindTexture(GL_TEXTURE_2D, texture);
1614 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1615
1616 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
1617 glTexSubImage2D(GL_TEXTURE_2D, -1, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1618 expectError(GL_INVALID_VALUE);
1619 m_log << TestLog::EndSection;
1620
1621 glDeleteTextures(1, &texture);
1622 });
1623 ES2F_ADD_API_CASE(texsubimage2d_neg_level_cube, "Invalid glTexSubImage2D() usage",
1624 {
1625 GLuint texture;
1626 glGenTextures(1, &texture);
1627 glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
1628 FOR_CUBE_FACES(faceGL, glTexImage2D(faceGL, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL););
1629
1630 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
1631 glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, -1, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1632 expectError(GL_INVALID_VALUE);
1633 glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, -1, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1634 expectError(GL_INVALID_VALUE);
1635 glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, -1, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1636 expectError(GL_INVALID_VALUE);
1637 glTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, -1, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1638 expectError(GL_INVALID_VALUE);
1639 glTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, -1, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1640 expectError(GL_INVALID_VALUE);
1641 glTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, -1, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1642 expectError(GL_INVALID_VALUE);
1643 m_log << TestLog::EndSection;
1644
1645 glDeleteTextures(1, &texture);
1646 });
1647 ES2F_ADD_API_CASE(texsubimage2d_level_max_tex2d, "Invalid glTexSubImage2D() usage",
1648 {
1649 GLuint texture;
1650 glGenTextures(1, &texture);
1651 glBindTexture(GL_TEXTURE_2D, texture);
1652 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1653
1654 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
1655 deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
1656 glTexSubImage2D(GL_TEXTURE_2D, log2MaxTextureSize, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1657 expectError(GL_INVALID_VALUE);
1658 m_log << TestLog::EndSection;
1659
1660 glDeleteTextures(1, &texture);
1661 });
1662 ES2F_ADD_API_CASE(texsubimage2d_level_max_cube, "Invalid glTexSubImage2D() usage",
1663 {
1664 GLuint texture;
1665 glGenTextures(1, &texture);
1666 glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
1667 FOR_CUBE_FACES(faceGL, glTexImage2D(faceGL, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL););
1668
1669 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_TEXTURE_SIZE).");
1670 deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
1671 glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, log2MaxTextureSize, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1672 expectError(GL_INVALID_VALUE);
1673 glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, log2MaxTextureSize, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1674 expectError(GL_INVALID_VALUE);
1675 glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, log2MaxTextureSize, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1676 expectError(GL_INVALID_VALUE);
1677 glTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, log2MaxTextureSize, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1678 expectError(GL_INVALID_VALUE);
1679 glTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, log2MaxTextureSize, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1680 expectError(GL_INVALID_VALUE);
1681 glTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, log2MaxTextureSize, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1682 expectError(GL_INVALID_VALUE);
1683 m_log << TestLog::EndSection;
1684
1685 glDeleteTextures(1, &texture);
1686 });
1687 ES2F_ADD_API_CASE(texsubimage2d_neg_offset, "Invalid glTexSubImage2D() usage",
1688 {
1689 GLuint texture;
1690 glGenTextures(1, &texture);
1691 glBindTexture(GL_TEXTURE_2D, texture);
1692 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1693
1694 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if xoffset or yoffset are negative.");
1695 glTexSubImage2D(GL_TEXTURE_2D, 0, -1, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1696 expectError(GL_INVALID_VALUE);
1697 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, -1, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1698 expectError(GL_INVALID_VALUE);
1699 glTexSubImage2D(GL_TEXTURE_2D, 0, -1, -1, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1700 expectError(GL_INVALID_VALUE);
1701 m_log << TestLog::EndSection;
1702
1703 glDeleteTextures(1, &texture);
1704 });
1705 ES2F_ADD_API_CASE(texsubimage2d_offset_allowed, "Invalid glTexSubImage2D() usage",
1706 {
1707 GLuint texture;
1708 glGenTextures(1, &texture);
1709 glBindTexture(GL_TEXTURE_2D, texture);
1710 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1711
1712 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if xoffset + width > texture_width or yoffset + height > texture_height.");
1713 glTexSubImage2D(GL_TEXTURE_2D, 0, 8, 4, 10, 10, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1714 expectError(GL_INVALID_VALUE);
1715 glTexSubImage2D(GL_TEXTURE_2D, 0, 4, 8, 10, 10, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1716 expectError(GL_INVALID_VALUE);
1717 glTexSubImage2D(GL_TEXTURE_2D, 0, 8, 8, 10, 10, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1718 expectError(GL_INVALID_VALUE);
1719 m_log << TestLog::EndSection;
1720
1721 glDeleteTextures(1, &texture);
1722 });
1723 ES2F_ADD_API_CASE(texsubimage2d_neg_wdt_hgt, "Invalid glTexSubImage2D() usage",
1724 {
1725 GLuint texture;
1726 glGenTextures(1, &texture);
1727 glBindTexture(GL_TEXTURE_2D, texture);
1728 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1729
1730 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
1731 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, -1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1732 expectError(GL_INVALID_VALUE);
1733 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, -1, GL_RGBA, GL_UNSIGNED_BYTE, 0);
1734 expectError(GL_INVALID_VALUE);
1735 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, -1, -1, -GL_RGBA, GL_UNSIGNED_BYTE, 0);
1736 expectError(GL_INVALID_VALUE);
1737 m_log << TestLog::EndSection;
1738
1739 glDeleteTextures(1, &texture);
1740 });
1741 ES2F_ADD_API_CASE(texsubimage2d_type_format_mismatch, "Invalid glTexSubImage2D() usage",
1742 {
1743 GLuint texture;
1744 glGenTextures(1, &texture);
1745 glBindTexture(GL_TEXTURE_2D, texture);
1746 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1747
1748 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if type is GL_UNSIGNED_SHORT_5_6_5 and format is not GL_RGB");
1749 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_SHORT_5_6_5, 0);
1750 expectError(GL_INVALID_OPERATION);
1751 m_log << tcu::TestLog::EndSection;
1752
1753 m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if type is GL_UNSIGNED_SHORT_4_4_4_4 or GL_UNSIGNED_SHORT_5_5_5_1 and format is not GL_RGBA.");
1754 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, 0);
1755 expectError(GL_INVALID_OPERATION);
1756 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, 0);
1757 expectError(GL_INVALID_OPERATION);
1758 m_log << tcu::TestLog::EndSection;
1759
1760 glDeleteTextures(1, &texture);
1761 });
1762
1763 // glTexParameteri
1764
1765 ES2F_ADD_API_CASE(texparameteri, "Invalid glTexParameteri() usage",
1766 {
1767 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1768 glTexParameteri(0, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1769 expectError(GL_INVALID_ENUM);
1770 glTexParameteri(GL_TEXTURE_2D, 0, GL_LINEAR);
1771 expectError(GL_INVALID_ENUM);
1772 glTexParameteri(0, 0, GL_LINEAR);
1773 expectError(GL_INVALID_ENUM);
1774 m_log << TestLog::EndSection;
1775
1776 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined symbolic constant value (based on the value of pname) and does not.");
1777 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 0);
1778 expectError(GL_INVALID_ENUM);
1779 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_REPEAT);
1780 expectError(GL_INVALID_ENUM);
1781 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, 0);
1782 expectError(GL_INVALID_ENUM);
1783 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_NEAREST);
1784 expectError(GL_INVALID_ENUM);
1785 m_log << TestLog::EndSection;
1786 });
1787 ES2F_ADD_API_CASE(texparameteri_bind, "Invalid glTexParameteri() usage",
1788 {
1789 GLuint texture;
1790 glGenTextures(1, &texture);
1791 glBindTexture(GL_TEXTURE_2D, texture);
1792
1793 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1794 glTexParameteri(0, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1795 expectError(GL_INVALID_ENUM);
1796 glTexParameteri(GL_TEXTURE_2D, 0, GL_LINEAR);
1797 expectError(GL_INVALID_ENUM);
1798 glTexParameteri(0, 0, GL_LINEAR);
1799 expectError(GL_INVALID_ENUM);
1800 m_log << TestLog::EndSection;
1801
1802 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined symbolic constant value (based on the value of pname) and does not.");
1803 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 0);
1804 expectError(GL_INVALID_ENUM);
1805 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_REPEAT);
1806 expectError(GL_INVALID_ENUM);
1807 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, 0);
1808 expectError(GL_INVALID_ENUM);
1809 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_NEAREST);
1810 expectError(GL_INVALID_ENUM);
1811 m_log << TestLog::EndSection;
1812
1813 glDeleteTextures(1, &texture);
1814 });
1815
1816 // glTexParameterf
1817
1818 ES2F_ADD_API_CASE(texparameterf, "Invalid glTexParameterf() usage",
1819 {
1820 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1821 glTexParameterf(0, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1822 expectError(GL_INVALID_ENUM);
1823 glTexParameterf(GL_TEXTURE_2D, 0, GL_LINEAR);
1824 expectError(GL_INVALID_ENUM);
1825 glTexParameterf(0, 0, GL_LINEAR);
1826 expectError(GL_INVALID_ENUM);
1827 m_log << TestLog::EndSection;
1828
1829 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined symbolic constant value (based on the value of pname) and does not.");
1830 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 0);
1831 expectError(GL_INVALID_ENUM);
1832 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_REPEAT);
1833 expectError(GL_INVALID_ENUM);
1834 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, 0);
1835 expectError(GL_INVALID_ENUM);
1836 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_NEAREST);
1837 expectError(GL_INVALID_ENUM);
1838 m_log << TestLog::EndSection;
1839 });
1840 ES2F_ADD_API_CASE(texparameterf_bind, "Invalid glTexParameterf() usage",
1841 {
1842 GLuint texture;
1843 glGenTextures(1, &texture);
1844 glBindTexture(GL_TEXTURE_2D, texture);
1845
1846 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1847 glTexParameterf(0, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1848 expectError(GL_INVALID_ENUM);
1849 glTexParameterf(GL_TEXTURE_2D, 0, GL_LINEAR);
1850 expectError(GL_INVALID_ENUM);
1851 glTexParameterf(0, 0, GL_LINEAR);
1852 expectError(GL_INVALID_ENUM);
1853 m_log << TestLog::EndSection;
1854
1855 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined symbolic constant value (based on the value of pname) and does not.");
1856 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 0);
1857 expectError(GL_INVALID_ENUM);
1858 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_REPEAT);
1859 expectError(GL_INVALID_ENUM);
1860 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, 0);
1861 expectError(GL_INVALID_ENUM);
1862 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_NEAREST);
1863 expectError(GL_INVALID_ENUM);
1864 m_log << TestLog::EndSection;
1865
1866 glDeleteTextures(1, &texture);
1867 });
1868
1869 // glTexParameteriv
1870
1871 ES2F_ADD_API_CASE(texparameteriv, "Invalid glTexParameteriv() usage",
1872 {
1873 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1874 GLint params[1] = {GL_LINEAR};
1875 glTexParameteriv(0, GL_TEXTURE_MIN_FILTER, ¶ms[0]);
1876 expectError(GL_INVALID_ENUM);
1877 glTexParameteriv(GL_TEXTURE_2D, 0, ¶ms[0]);
1878 expectError(GL_INVALID_ENUM);
1879 glTexParameteriv(0, 0, ¶ms[0]);
1880 expectError(GL_INVALID_ENUM);
1881 m_log << TestLog::EndSection;
1882
1883 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined symbolic constant value (based on the value of pname) and does not.");
1884 params[0] = 0;
1885 glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, ¶ms[0]);
1886 expectError(GL_INVALID_ENUM);
1887 params[0] = GL_REPEAT;
1888 glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, ¶ms[0]);
1889 expectError(GL_INVALID_ENUM);
1890 params[0] = 0;
1891 glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, ¶ms[0]);
1892 expectError(GL_INVALID_ENUM);
1893 params[0] = GL_NEAREST;
1894 glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, ¶ms[0]);
1895 expectError(GL_INVALID_ENUM);
1896 m_log << TestLog::EndSection;
1897 });
1898 ES2F_ADD_API_CASE(texparameteriv_bind, "Invalid glTexParameteriv() usage",
1899 {
1900 GLuint texture;
1901 glGenTextures(1, &texture);
1902 glBindTexture(GL_TEXTURE_2D, texture);
1903
1904 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1905 GLint params[1] = {GL_LINEAR};
1906 glTexParameteriv(0, GL_TEXTURE_MIN_FILTER, ¶ms[0]);
1907 expectError(GL_INVALID_ENUM);
1908 glTexParameteriv(GL_TEXTURE_2D, 0, ¶ms[0]);
1909 expectError(GL_INVALID_ENUM);
1910 glTexParameteriv(0, 0, ¶ms[0]);
1911 expectError(GL_INVALID_ENUM);
1912 m_log << TestLog::EndSection;
1913
1914 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined symbolic constant value (based on the value of pname) and does not.");
1915 params[0] = 0;
1916 glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, ¶ms[0]);
1917 expectError(GL_INVALID_ENUM);
1918 params[0] = GL_REPEAT;
1919 glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, ¶ms[0]);
1920 expectError(GL_INVALID_ENUM);
1921 params[0] = 0;
1922 glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, ¶ms[0]);
1923 expectError(GL_INVALID_ENUM);
1924 params[0] = GL_NEAREST;
1925 glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, ¶ms[0]);
1926 expectError(GL_INVALID_ENUM);
1927 m_log << TestLog::EndSection;
1928
1929 glDeleteTextures(1, &texture);
1930 });
1931
1932 // glTexParameterfv
1933
1934 ES2F_ADD_API_CASE(texparameterfv, "Invalid glTexParameterfv() usage",
1935 {
1936 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1937 GLfloat params[1] = {GL_LINEAR};
1938 glTexParameterfv(0, GL_TEXTURE_MIN_FILTER, ¶ms[0]);
1939 expectError(GL_INVALID_ENUM);
1940 glTexParameterfv(GL_TEXTURE_2D, 0, ¶ms[0]);
1941 expectError(GL_INVALID_ENUM);
1942 glTexParameterfv(0, 0, ¶ms[0]);
1943 expectError(GL_INVALID_ENUM);
1944 m_log << TestLog::EndSection;
1945
1946 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined symbolic constant value (based on the value of pname) and does not.");
1947 params[0] = 0.0f;
1948 glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, ¶ms[0]);
1949 expectError(GL_INVALID_ENUM);
1950 params[0] = GL_REPEAT;
1951 glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, ¶ms[0]);
1952 expectError(GL_INVALID_ENUM);
1953 params[0] = 0.0f;
1954 glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, ¶ms[0]);
1955 expectError(GL_INVALID_ENUM);
1956 params[0] = GL_NEAREST;
1957 glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, ¶ms[0]);
1958 expectError(GL_INVALID_ENUM);
1959 m_log << TestLog::EndSection;
1960 });
1961 ES2F_ADD_API_CASE(texparameterfv_bind, "Invalid glTexParameterfv() usage",
1962 {
1963 GLuint texture;
1964 glGenTextures(1, &texture);
1965 glBindTexture(GL_TEXTURE_2D, texture);
1966
1967 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target or pname is not one of the accepted defined values.");
1968 GLfloat params[1] = {GL_LINEAR};
1969 glTexParameterfv(0, GL_TEXTURE_MIN_FILTER, ¶ms[0]);
1970 expectError(GL_INVALID_ENUM);
1971 glTexParameterfv(GL_TEXTURE_2D, 0, ¶ms[0]);
1972 expectError(GL_INVALID_ENUM);
1973 glTexParameterfv(0, 0, ¶ms[0]);
1974 expectError(GL_INVALID_ENUM);
1975 m_log << TestLog::EndSection;
1976
1977 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if params should have a defined symbolic constant value (based on the value of pname) and does not.");
1978 params[0] = 0.0f;
1979 glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, ¶ms[0]);
1980 expectError(GL_INVALID_ENUM);
1981 params[0] = GL_REPEAT;
1982 glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, ¶ms[0]);
1983 expectError(GL_INVALID_ENUM);
1984 params[0] = 0.0f;
1985 glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, ¶ms[0]);
1986 expectError(GL_INVALID_ENUM);
1987 params[0] = GL_NEAREST;
1988 glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, ¶ms[0]);
1989 expectError(GL_INVALID_ENUM);
1990 m_log << TestLog::EndSection;
1991
1992 glDeleteTextures(1, &texture);
1993 });
1994
1995 // glCompressedTexSubImage2D
1996
1997 ES2F_ADD_API_CASE(compressedtexsubimage2d_invalid_target, "Invalid glCompressedTexSubImage2D() usage",
1998 {
1999 vector<deInt32> supported;
2000 vector<deInt32> accepted;
2001 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, supported);
2002 getCompressedTexSubImage2DFormat(supported, accepted);
2003
2004 if (accepted.empty())
2005 {
2006 m_log << TestLog::Message << "// No suitable compressed formats found, cannot evaluate test." << TestLog::EndMessage;
2007 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "No suitable compressed formats found");
2008 }
2009 else
2010 {
2011 for (int i = 0; i < (int)accepted.size(); i++)
2012 {
2013 const deInt32 glFormat = accepted[i];
2014
2015 try
2016 {
2017 const tcu::CompressedTexFormat format = glu::mapGLCompressedTexFormat(glFormat);
2018 const tcu::IVec3 blockPixelSize = tcu::getBlockPixelSize(format);
2019 const int blockSize = tcu::getBlockSize(format);
2020 const std::vector<deUint8> data (blockSize, 0);
2021 GLuint texture = 0;
2022
2023 glGenTextures(1, &texture);
2024 glBindTexture(GL_TEXTURE_2D, texture);
2025 expectError(GL_NO_ERROR);
2026
2027 glCompressedTexImage2D(GL_TEXTURE_2D, 0, glFormat, blockPixelSize.x(), blockPixelSize.y(), 0, blockSize, DE_NULL);
2028 expectError(GL_NO_ERROR);
2029
2030 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is invalid.");
2031 m_log << TestLog::Message << "// Using texture format " << tcu::toHex(accepted[i]) << TestLog::EndMessage;
2032 //glCompressedTexImage2D(GL_TEXTURE_2D, 0, accepted[i], 0, 0, 0, 0, 0);
2033 glCompressedTexSubImage2D(0, 0, 0, 0, 0, 0, accepted[i], 0, 0);
2034 expectError(GL_INVALID_ENUM);
2035 m_log << TestLog::EndSection;
2036
2037 glDeleteTextures(1, &texture);
2038 expectError(GL_NO_ERROR);
2039 }
2040 catch (const tcu::InternalError&)
2041 {
2042 m_log << TestLog::Message << "Skipping unknown format: " << glFormat << TestLog::EndMessage;
2043 }
2044 }
2045 }
2046 });
2047 ES2F_ADD_API_CASE(compressedtexsubimage2d_neg_level_tex2d, "Invalid glCompressedTexSubImage2D() usage",
2048 {
2049 vector<deInt32> supported;
2050 vector<deInt32> accepted;
2051 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, supported);
2052 getCompressedTexSubImage2DFormat(supported, accepted);
2053
2054 if (accepted.empty())
2055 {
2056 m_log << TestLog::Message << "// No suitable compressed formats found, cannot evaluate test." << TestLog::EndMessage;
2057 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "No suitable compressed formats found");
2058 }
2059 else
2060 {
2061 for (int i = 0; i < (int)accepted.size(); i++)
2062 {
2063 const deInt32 glFormat = accepted[i];
2064
2065 try
2066 {
2067 const tcu::CompressedTexFormat format = glu::mapGLCompressedTexFormat(glFormat);
2068 const tcu::IVec3 blockPixelSize = tcu::getBlockPixelSize(format);
2069 const int blockSize = tcu::getBlockSize(format);
2070 const std::vector<deUint8> data (blockSize, 0);
2071 GLuint texture = 0;
2072
2073 glGenTextures(1, &texture);
2074 glBindTexture(GL_TEXTURE_2D, texture);
2075 expectError(GL_NO_ERROR);
2076
2077 glCompressedTexImage2D(GL_TEXTURE_2D, 0, glFormat, blockPixelSize.x(), blockPixelSize.y(), 0, blockSize, DE_NULL);
2078 expectError(GL_NO_ERROR);
2079
2080 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
2081 m_log << TestLog::Message << "// Using texture format " << tcu::toHex(accepted[i]) << TestLog::EndMessage;
2082 //glCompressedTexImage2D(GL_TEXTURE_2D, 0, accepted[i], 0, 0, 0, 0, 0);
2083 //expectError(GL_NO_ERROR);
2084 glCompressedTexSubImage2D(GL_TEXTURE_2D, -1, 0, 0, 0, 0, accepted[i], 0, 0);
2085 expectError(GL_INVALID_VALUE);
2086 m_log << TestLog::EndSection;
2087
2088 glDeleteTextures(1, &texture);
2089 expectError(GL_NO_ERROR);
2090 }
2091 catch (const tcu::InternalError&)
2092 {
2093 m_log << TestLog::Message << "Skipping unknown format: " << glFormat << TestLog::EndMessage;
2094 }
2095 }
2096 }
2097 });
2098 ES2F_ADD_API_CASE(compressedtexsubimage2d_neg_level_cube, "Invalid glCompressedTexSubImage2D() usage",
2099 {
2100 vector<deInt32> supported;
2101 vector<deInt32> accepted;
2102 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, supported);
2103 getCompressedTexSubImage2DFormat(supported, accepted);
2104
2105 if (accepted.empty())
2106 {
2107 m_log << TestLog::Message << "// No suitable compressed formats found, cannot evaluate test." << TestLog::EndMessage;
2108 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "No suitable compressed formats found");
2109 }
2110 else
2111 {
2112 for (int i = 0; i < (int)accepted.size(); i++)
2113 {
2114 const deInt32 glFormat = accepted[i];
2115
2116 try
2117 {
2118 const tcu::CompressedTexFormat format = glu::mapGLCompressedTexFormat(glFormat);
2119 const tcu::IVec3 blockPixelSize = tcu::getBlockPixelSize(format);
2120 const int blockSize = tcu::getBlockSize(format);
2121 const std::vector<deUint8> data (blockSize, 0);
2122 GLuint texture = 0;
2123
2124 glGenTextures(1, &texture);
2125 glBindTexture(GL_TEXTURE_2D, texture);
2126 expectError(GL_NO_ERROR);
2127
2128 glCompressedTexImage2D(GL_TEXTURE_2D, 0, glFormat, blockPixelSize.x(), blockPixelSize.y(), 0, blockSize, DE_NULL);
2129 expectError(GL_NO_ERROR);
2130
2131 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0.");
2132 m_log << TestLog::Message << "// Using texture format " << tcu::toHex(accepted[i]) << TestLog::EndMessage;
2133 //glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, accepted[i], 0, 0, 0, 0, 0);
2134 //expectError(GL_NO_ERROR);
2135 glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, -1, 0, 0, 0, 0, accepted[i], 0, 0);
2136 expectError(GL_INVALID_VALUE);
2137 //glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, accepted[i], 0, 0, 0, 0, 0);
2138 //expectError(GL_NO_ERROR);
2139 glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, -1, 0, 0, 0, 0, accepted[i], 0, 0);
2140 expectError(GL_INVALID_VALUE);
2141 //glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, accepted[i], 0, 0, 0, 0, 0);
2142 //expectError(GL_NO_ERROR);
2143 glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, -1, 0, 0, 0, 0, accepted[i], 0, 0);
2144 expectError(GL_INVALID_VALUE);
2145 //glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, accepted[i], 0, 0, 0, 0, 0);
2146 //expectError(GL_NO_ERROR);
2147 glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, -1, 0, 0, 0, 0, accepted[i], 0, 0);
2148 expectError(GL_INVALID_VALUE);
2149 //glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, accepted[i], 0, 0, 0, 0, 0);
2150 //expectError(GL_NO_ERROR);
2151 glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, -1, 0, 0, 0, 0, accepted[i], 0, 0);
2152 expectError(GL_INVALID_VALUE);
2153 //glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, accepted[i], 0, 0, 0, 0, 0);
2154 //expectError(GL_NO_ERROR);
2155 glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, -1, 0, 0, 0, 0, accepted[i], 0, 0);
2156 expectError(GL_INVALID_VALUE);
2157 m_log << TestLog::EndSection;
2158
2159 glDeleteTextures(1, &texture);
2160 expectError(GL_NO_ERROR);
2161 }
2162 catch (const tcu::InternalError&)
2163 {
2164 m_log << TestLog::Message << "Skipping unknown format: " << glFormat << TestLog::EndMessage;
2165 }
2166 }
2167 }
2168 });
2169 ES2F_ADD_API_CASE(compressedtexsubimage2d_level_max_tex2d, "Invalid glCompressedTexSubImage2D() usage",
2170 {
2171 vector<deInt32> supported;
2172 vector<deInt32> accepted;
2173 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, supported);
2174 getCompressedTexSubImage2DFormat(supported, accepted);
2175
2176 if (accepted.empty())
2177 {
2178 m_log << TestLog::Message << "// No suitable compressed formats found, cannot evaluate test." << TestLog::EndMessage;
2179 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "No suitable compressed formats found");
2180 }
2181 else
2182 {
2183 for (int i = 0; i < (int)accepted.size(); i++)
2184 {
2185 const deInt32 glFormat = accepted[i];
2186
2187 try
2188 {
2189 const tcu::CompressedTexFormat format = glu::mapGLCompressedTexFormat(glFormat);
2190 const tcu::IVec3 blockPixelSize = tcu::getBlockPixelSize(format);
2191 const int blockSize = tcu::getBlockSize(format);
2192 const std::vector<deUint8> data (blockSize, 0);
2193 GLuint texture = 0;
2194
2195 glGenTextures(1, &texture);
2196 glBindTexture(GL_TEXTURE_2D, texture);
2197 expectError(GL_NO_ERROR);
2198
2199 glCompressedTexImage2D(GL_TEXTURE_2D, 0, glFormat, blockPixelSize.x(), blockPixelSize.y(), 0, blockSize, DE_NULL);
2200 expectError(GL_NO_ERROR);
2201
2202 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_TEXTURE_SIZE).");
2203 m_log << TestLog::Message << "// Using texture format " << tcu::toHex(accepted[i]) << TestLog::EndMessage;
2204 deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
2205 //glCompressedTexImage2D(GL_TEXTURE_2D, 0, accepted[i], 0, 0, 0, 0, 0);
2206 //expectError(GL_NO_ERROR);
2207 glCompressedTexSubImage2D(GL_TEXTURE_2D, log2MaxTextureSize, 0, 0, 0, 0, accepted[i], 0, 0);
2208 expectError(GL_INVALID_VALUE);
2209 m_log << TestLog::EndSection;
2210
2211 glDeleteTextures(1, &texture);
2212 expectError(GL_NO_ERROR);
2213 }
2214 catch (const tcu::InternalError&)
2215 {
2216 m_log << TestLog::Message << "Skipping unknown format: " << glFormat << TestLog::EndMessage;
2217 }
2218 }
2219 }
2220 });
2221 ES2F_ADD_API_CASE(compressedtexsubimage2d_level_max_cube, "Invalid glCompressedTexSubImage2D() usage",
2222 {
2223 vector<deInt32> supported;
2224 vector<deInt32> accepted;
2225 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, supported);
2226 getCompressedTexSubImage2DFormat(supported, accepted);
2227
2228 if (accepted.empty())
2229 {
2230 m_log << TestLog::Message << "// No suitable compressed formats found, cannot evaluate test." << TestLog::EndMessage;
2231 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "No suitable compressed formats found");
2232 }
2233 else
2234 {
2235 for (int i = 0; i < (int)accepted.size(); i++)
2236 {
2237 const deInt32 glFormat = accepted[i];
2238
2239 try
2240 {
2241 const tcu::CompressedTexFormat format = glu::mapGLCompressedTexFormat(glFormat);
2242 const tcu::IVec3 blockPixelSize = tcu::getBlockPixelSize(format);
2243 const int blockSize = tcu::getBlockSize(format);
2244 const std::vector<deUint8> data (blockSize, 0);
2245 GLuint texture = 0;
2246
2247 glGenTextures(1, &texture);
2248 glBindTexture(GL_TEXTURE_2D, texture);
2249 expectError(GL_NO_ERROR);
2250
2251 glCompressedTexImage2D(GL_TEXTURE_2D, 0, glFormat, blockPixelSize.x(), blockPixelSize.y(), 0, blockSize, DE_NULL);
2252 expectError(GL_NO_ERROR);
2253
2254 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is greater than log_2(GL_MAX_CUBE_MAP_TEXTURE_SIZE).");
2255 m_log << TestLog::Message << "// Using texture format " << tcu::toHex(accepted[i]) << TestLog::EndMessage;
2256 deUint32 log2MaxTextureSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
2257 //glCompressedTexImage2D(GL_TEXTURE_2D, 0, accepted[i], 0, 0, 0, 0, 0);
2258 //expectError(GL_NO_ERROR);
2259 glCompressedTexSubImage2D(GL_TEXTURE_2D, log2MaxTextureSize, 0, 0, 0, 0, accepted[i], 0, 0);
2260 expectError(GL_INVALID_VALUE);
2261 //glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, accepted[i], 0, 0, 0, 0, 0);
2262 //expectError(GL_NO_ERROR);
2263 glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, log2MaxTextureSize, 0, 0, 0, 0, accepted[i], 0, 0);
2264 expectError(GL_INVALID_VALUE);
2265 //glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, accepted[i], 0, 0, 0, 0, 0);
2266 //expectError(GL_NO_ERROR);
2267 glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, log2MaxTextureSize, 0, 0, 0, 0, accepted[i], 0, 0);
2268 expectError(GL_INVALID_VALUE);
2269 //glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, accepted[i], 0, 0, 0, 0, 0);
2270 //expectError(GL_NO_ERROR);
2271 glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, log2MaxTextureSize, 0, 0, 0, 0, accepted[i], 0, 0);
2272 expectError(GL_INVALID_VALUE);
2273 //glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, accepted[i], 0, 0, 0, 0, 0);
2274 //expectError(GL_NO_ERROR);
2275 glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, log2MaxTextureSize, 0, 0, 0, 0, accepted[i], 0, 0);
2276 expectError(GL_INVALID_VALUE);
2277 //glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, accepted[i], 0, 0, 0, 0, 0);
2278 //expectError(GL_NO_ERROR);
2279 glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, log2MaxTextureSize, 0, 0, 0, 0, accepted[i], 0, 0);
2280 expectError(GL_INVALID_VALUE);
2281 //glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, accepted[i], 0, 0, 0, 0, 0);
2282 //expectError(GL_NO_ERROR);
2283 glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, log2MaxTextureSize, 0, 0, 0, 0, accepted[i], 0, 0);
2284 expectError(GL_INVALID_VALUE);
2285 m_log << TestLog::EndSection;
2286
2287 glDeleteTextures(1, &texture);
2288 expectError(GL_NO_ERROR);
2289 }
2290 catch (const tcu::InternalError&)
2291 {
2292 m_log << TestLog::Message << "Skipping unknown format: " << glFormat << TestLog::EndMessage;
2293 }
2294 }
2295 }
2296 });
2297 ES2F_ADD_API_CASE(compressedtexsubimage2d_neg_offset, "Invalid glCompressedTexSubImage2D() usage",
2298 {
2299 vector<deInt32> supported;
2300 vector<deInt32> accepted;
2301 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, supported);
2302 getCompressedTexSubImage2DFormat(supported, accepted);
2303
2304 if (accepted.empty())
2305 {
2306 m_log << TestLog::Message << "// No suitable compressed formats found, cannot evaluate test." << TestLog::EndMessage;
2307 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "No suitable compressed formats found");
2308 }
2309 else
2310 {
2311 for (int i = 0; i < (int)accepted.size(); i++)
2312 {
2313 const deInt32 glFormat = accepted[i];
2314
2315 try
2316 {
2317 const tcu::CompressedTexFormat format = glu::mapGLCompressedTexFormat(glFormat);
2318 const tcu::IVec3 blockPixelSize = tcu::getBlockPixelSize(format);
2319 const int blockSize = tcu::getBlockSize(format);
2320 const std::vector<deUint8> data (blockSize, 0);
2321 GLuint texture = 0;
2322
2323 glGenTextures(1, &texture);
2324 glBindTexture(GL_TEXTURE_2D, texture);
2325 expectError(GL_NO_ERROR);
2326
2327 glCompressedTexImage2D(GL_TEXTURE_2D, 0, glFormat, blockPixelSize.x(), blockPixelSize.y(), 0, blockSize, DE_NULL);
2328 expectError(GL_NO_ERROR);
2329
2330 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if xoffset or yoffset are negative.");
2331 m_log << TestLog::Message << "// Using texture format " << tcu::toHex(accepted[i]) << TestLog::EndMessage;
2332 //glCompressedTexImage2D(GL_TEXTURE_2D, 0, accepted[i], 0, 0, 0, 0, 0);
2333 //expectError(GL_NO_ERROR);
2334 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, -1, 0, 0, 0, accepted[i], 0, 0);
2335 expectError(GL_INVALID_VALUE);
2336 //glCompressedTexImage2D(GL_TEXTURE_2D, 0, accepted[i], 0, 0, 0, 0, 0);
2337 //expectError(GL_NO_ERROR);
2338 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, -1, 0, 0, accepted[i], 0, 0);
2339 expectError(GL_INVALID_VALUE);
2340 //glCompressedTexImage2D(GL_TEXTURE_2D, 0, accepted[i], 0, 0, 0, 0, 0);
2341 //expectError(GL_NO_ERROR);
2342 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, -1, -1, 0, 0, accepted[i], 0, 0);
2343 expectError(GL_INVALID_VALUE);
2344 m_log << TestLog::EndSection;
2345
2346 glDeleteTextures(1, &texture);
2347 expectError(GL_NO_ERROR);
2348 }
2349 catch (const tcu::InternalError&)
2350 {
2351 m_log << TestLog::Message << "Skipping unknown format: " << glFormat << TestLog::EndMessage;
2352 }
2353 }
2354 }
2355 });
2356 ES2F_ADD_API_CASE(compressedtexsubimage2d_offset_allowed, "Invalid glCompressedTexSubImage2D() usage",
2357 {
2358 vector<deInt32> supported;
2359 vector<deInt32> accepted;
2360 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, supported);
2361 getCompressedTexSubImage2DFormat(supported, accepted);
2362
2363 if (accepted.empty())
2364 {
2365 m_log << TestLog::Message << "// No suitable compressed formats found, cannot evaluate test." << TestLog::EndMessage;
2366 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "No suitable compressed formats found");
2367 }
2368 else
2369 {
2370 for (int i = 0; i < (int)accepted.size(); i++)
2371 {
2372 const deInt32 glFormat = accepted[i];
2373
2374 try
2375 {
2376 const tcu::CompressedTexFormat format = glu::mapGLCompressedTexFormat(glFormat);
2377 const tcu::IVec3 blockPixelSize = tcu::getBlockPixelSize(format);
2378 const int blockSize = tcu::getBlockSize(format);
2379 const std::vector<deUint8> data (blockSize, 0);
2380 GLuint texture = 0;
2381
2382 glGenTextures(1, &texture);
2383 glBindTexture(GL_TEXTURE_2D, texture);
2384 expectError(GL_NO_ERROR);
2385
2386 glCompressedTexImage2D(GL_TEXTURE_2D, 0, glFormat, blockPixelSize.x(), blockPixelSize.y(), 0, blockSize, DE_NULL);
2387 expectError(GL_NO_ERROR);
2388
2389 deUint32 maxTextureSize = m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE) + 1;
2390 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if xoffset + width > texture_width or yoffset + height > texture_height.");
2391 m_log << TestLog::Message << "// Using texture format " << tcu::toHex(accepted[i]) << TestLog::EndMessage;
2392 //glCompressedTexImage2D(GL_TEXTURE_2D, 0, accepted[i], 0, 0, 0, 0, 0);
2393 //expectError(GL_NO_ERROR);
2394 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, maxTextureSize, 0, 0, 0, accepted[i], 0, 0);
2395 expectError(GL_INVALID_VALUE);
2396 //glCompressedTexImage2D(GL_TEXTURE_2D, 0, accepted[i], 0, 0, 0, 0, 0);
2397 //expectError(GL_NO_ERROR);
2398 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, maxTextureSize, 0, 0, accepted[i], 0, 0);
2399 expectError(GL_INVALID_VALUE);
2400 //glCompressedTexImage2D(GL_TEXTURE_2D, 0, accepted[i], 0, 0, 0, 0, 0);
2401 //expectError(GL_NO_ERROR);
2402 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, maxTextureSize, maxTextureSize, 0, 0, accepted[i], 0, 0);
2403 expectError(GL_INVALID_VALUE);
2404 m_log << TestLog::EndSection;
2405
2406 glDeleteTextures(1, &texture);
2407 expectError(GL_NO_ERROR);
2408 }
2409 catch (const tcu::InternalError&)
2410 {
2411 m_log << TestLog::Message << "Skipping unknown format: " << glFormat << TestLog::EndMessage;
2412 }
2413 }
2414 }
2415 });
2416 ES2F_ADD_API_CASE(compressedtexsubimage2d_neg_wdt_hgt, "Invalid glCompressedTexSubImage2D() usage",
2417 {
2418 vector<deInt32> supported;
2419 vector<deInt32> accepted;
2420 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, supported);
2421 getCompressedTexSubImage2DFormat(supported, accepted);
2422
2423 if (accepted.empty())
2424 {
2425 m_log << TestLog::Message << "// No suitable compressed formats found, cannot evaluate test." << TestLog::EndMessage;
2426 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "No suitable compressed formats found");
2427 }
2428 else
2429 {
2430 for (int i = 0; i < (int)accepted.size(); i++)
2431 {
2432 const deInt32 glFormat = accepted[i];
2433
2434 try
2435 {
2436 const tcu::CompressedTexFormat format = glu::mapGLCompressedTexFormat(glFormat);
2437 const tcu::IVec3 blockPixelSize = tcu::getBlockPixelSize(format);
2438 const int blockSize = tcu::getBlockSize(format);
2439 const std::vector<deUint8> data (blockSize, 0);
2440 GLuint texture = 0;
2441
2442 glGenTextures(1, &texture);
2443 glBindTexture(GL_TEXTURE_2D, texture);
2444 expectError(GL_NO_ERROR);
2445
2446 glCompressedTexImage2D(GL_TEXTURE_2D, 0, glFormat, blockPixelSize.x(), blockPixelSize.y(), 0, blockSize, DE_NULL);
2447 expectError(GL_NO_ERROR);
2448
2449 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than 0.");
2450 m_log << TestLog::Message << "// Using texture format " << tcu::toHex(accepted[i]) << TestLog::EndMessage;
2451 //glCompressedTexImage2D(GL_TEXTURE_2D, 0, accepted[i], 0, 0, 0, 0, 0);
2452 //expectError(GL_NO_ERROR);
2453 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, -1, 0, accepted[i], 0, 0);
2454 expectError(GL_INVALID_VALUE);
2455 //glCompressedTexImage2D(GL_TEXTURE_2D, 0, accepted[i], 0, 0, 0, 0, 0);
2456 //expectError(GL_NO_ERROR);
2457 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, -1, accepted[i], 0, 0);
2458 expectError(GL_INVALID_VALUE);
2459 //glCompressedTexImage2D(GL_TEXTURE_2D, 0, accepted[i], 0, 0, 0, 0, 0);
2460 //expectError(GL_NO_ERROR);
2461 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, -1, -1, accepted[i], 0, 0);
2462 expectError(GL_INVALID_VALUE);
2463 m_log << TestLog::EndSection;
2464
2465 glDeleteTextures(1, &texture);
2466 expectError(GL_NO_ERROR);
2467 }
2468 catch (const tcu::InternalError&)
2469 {
2470 m_log << TestLog::Message << "Skipping unknown format: " << glFormat << TestLog::EndMessage;
2471 }
2472 }
2473 }
2474 });
2475 ES2F_ADD_API_CASE(compressedtexsubimage2d_invalid_size, "Invalid glCompressedTexImage2D() usage",
2476 {
2477 vector<deInt32> supported;
2478 vector<deInt32> accepted;
2479 getSupportedExtensions(GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_COMPRESSED_TEXTURE_FORMATS, supported);
2480 getCompressedTexSubImage2DFormat(supported, accepted);
2481
2482 if (accepted.empty())
2483 {
2484 m_log << TestLog::Message << "// No suitable compressed formats found, cannot evaluate test." << TestLog::EndMessage;
2485 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "No suitable compressed formats found");
2486 }
2487 else
2488 {
2489 for (int i = 0; i < (int)accepted.size(); i++)
2490 {
2491 const deInt32 glFormat = accepted[i];
2492
2493 try
2494 {
2495 const tcu::CompressedTexFormat format = glu::mapGLCompressedTexFormat(glFormat);
2496 const tcu::IVec3 blockPixelSize = tcu::getBlockPixelSize(format);
2497 const int blockSize = tcu::getBlockSize(format);
2498 const std::vector<deUint8> data (blockSize, 0);
2499 GLuint texture = 0;
2500
2501 glGenTextures(1, &texture);
2502 glBindTexture(GL_TEXTURE_2D, texture);
2503 expectError(GL_NO_ERROR);
2504
2505 glCompressedTexImage2D(GL_TEXTURE_2D, 0, glFormat, blockPixelSize.x(), blockPixelSize.y(), 0, blockSize, DE_NULL);
2506 expectError(GL_NO_ERROR);
2507
2508 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if imageSize is not consistent with the format, dimensions, and contents of the specified compressed image data.");
2509 m_log << TestLog::Message << "// Using texture format " << tcu::toHex(glFormat) << TestLog::EndMessage;
2510 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, blockPixelSize.x(), blockPixelSize.y(), glFormat, -1, &data[0]);
2511 expectError(GL_INVALID_VALUE);
2512
2513 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, blockPixelSize.x(), blockPixelSize.y(), glFormat, blockSize / 2, &data[0]);
2514 expectError(GL_INVALID_VALUE);
2515
2516 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, blockPixelSize.x(), blockPixelSize.y(), glFormat, blockSize * 2, &data[0]);
2517 expectError(GL_INVALID_VALUE);
2518
2519 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, blockPixelSize.x(), blockPixelSize.y() * 2, glFormat, blockSize, &data[0]);
2520 expectError(GL_INVALID_VALUE);
2521
2522 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, blockPixelSize.x() * 2, blockPixelSize.y(), glFormat, blockSize, &data[0]);
2523 expectError(GL_INVALID_VALUE);
2524
2525 m_log << TestLog::EndSection;
2526
2527 glDeleteTextures(1, &texture);
2528 expectError(GL_NO_ERROR);
2529 }
2530 catch (const tcu::InternalError&)
2531 {
2532 m_log << TestLog::Message << "Skipping unknown format: " << glFormat << TestLog::EndMessage;
2533 }
2534 }
2535 }
2536 });
2537 }
2538
2539 } // Functional
2540 } // gles2
2541 } // deqp
2542