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