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