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 Buffer API tests.
22 *//*--------------------------------------------------------------------*/
23
24 #include "es3fNegativeBufferApiTests.hpp"
25 #include "es3fApiCase.hpp"
26 #include "gluContextInfo.hpp"
27
28 #include "glwDefs.hpp"
29 #include "glwEnums.hpp"
30
31 using namespace glw; // GL types
32
33 namespace deqp
34 {
35 namespace gles3
36 {
37 namespace Functional
38 {
39
40 using tcu::TestLog;
41
NegativeBufferApiTests(Context & context)42 NegativeBufferApiTests::NegativeBufferApiTests (Context& context)
43 : TestCaseGroup(context, "buffer", "Negative Buffer API Cases")
44 {
45 }
46
~NegativeBufferApiTests(void)47 NegativeBufferApiTests::~NegativeBufferApiTests (void)
48 {
49 }
50
init(void)51 void NegativeBufferApiTests::init (void)
52 {
53 // Buffers
54
55 ES3F_ADD_API_CASE(bind_buffer, "Invalid glBindBuffer() usage",
56 {
57 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not one of the allowable values.");
58 glBindBuffer(-1, 0);
59 expectError(GL_INVALID_ENUM);
60 m_log << TestLog::EndSection;
61 });
62 ES3F_ADD_API_CASE(delete_buffers, "Invalid glDeleteBuffers() usage",
63 {
64 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
65 glDeleteBuffers(-1, 0);
66 expectError(GL_INVALID_VALUE);
67 m_log << TestLog::EndSection;
68 });
69 ES3F_ADD_API_CASE(gen_buffers, "Invalid glGenBuffers() usage",
70 {
71 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
72 glGenBuffers(-1, 0);
73 expectError(GL_INVALID_VALUE);
74 m_log << TestLog::EndSection;
75 });
76 ES3F_ADD_API_CASE(buffer_data, "Invalid glBufferData() usage",
77 {
78 GLuint buffer;
79 glGenBuffers(1, &buffer);
80 glBindBuffer(GL_ARRAY_BUFFER, buffer);
81
82 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_ARRAY_BUFFER or GL_ELEMENT_ARRAY_BUFFER.");
83 glBufferData(-1, 0, NULL, GL_STREAM_DRAW);
84 expectError(GL_INVALID_ENUM);
85 m_log << TestLog::EndSection;
86
87 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if usage is not GL_STREAM_DRAW, GL_STATIC_DRAW, or GL_DYNAMIC_DRAW.");
88 glBufferData(GL_ARRAY_BUFFER, 0, NULL, -1);
89 expectError(GL_INVALID_ENUM);
90 m_log << TestLog::EndSection;
91
92 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if size is negative.");
93 glBufferData(GL_ARRAY_BUFFER, -1, NULL, GL_STREAM_DRAW);
94 expectError(GL_INVALID_VALUE);
95 m_log << TestLog::EndSection;
96
97 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the reserved buffer object name 0 is bound to target.");
98 glBindBuffer(GL_ARRAY_BUFFER, 0);
99 glBufferData(GL_ARRAY_BUFFER, 0, NULL, GL_STREAM_DRAW);
100 expectError(GL_INVALID_OPERATION);
101 m_log << TestLog::EndSection;
102
103 glDeleteBuffers(1, &buffer);
104 });
105 ES3F_ADD_API_CASE(buffer_sub_data, "Invalid glBufferSubData() usage",
106 {
107 GLuint buffer;
108 glGenBuffers(1, &buffer);
109 glBindBuffer(GL_ARRAY_BUFFER, buffer);
110 glBufferData(GL_ARRAY_BUFFER, 10, 0, GL_STREAM_DRAW);
111
112 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_ARRAY_BUFFER or GL_ELEMENT_ARRAY_BUFFER.");
113 glBufferSubData(-1, 1, 1, 0);
114 expectError(GL_INVALID_ENUM);
115 m_log << TestLog::EndSection;
116
117 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the reserved buffer object name 0 is bound to target.");
118 glBindBuffer(GL_ARRAY_BUFFER, 0);
119 glBufferSubData(GL_ARRAY_BUFFER, 1, 1, 0);
120 expectError(GL_INVALID_OPERATION);
121 m_log << TestLog::EndSection;
122
123 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the buffer object being updated is mapped.");
124 glBindBuffer(GL_ARRAY_BUFFER, buffer);
125 glMapBufferRange(GL_ARRAY_BUFFER, 0, 5, GL_MAP_READ_BIT);
126 expectError(GL_NO_ERROR);
127 glBufferSubData(GL_ARRAY_BUFFER, 1, 1, 0);
128 expectError(GL_INVALID_OPERATION);
129 m_log << TestLog::EndSection;
130
131 glDeleteBuffers(1, &buffer);
132 });
133 ES3F_ADD_API_CASE(buffer_sub_data_size_offset, "Invalid glBufferSubData() usage",
134 {
135 GLuint buffer;
136 glGenBuffers(1, &buffer);
137 glBindBuffer(GL_ARRAY_BUFFER, buffer);
138 glBufferData(GL_ARRAY_BUFFER, 10, 0, GL_STREAM_DRAW);
139
140 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if offset or size is negative, or if together they define a region of memory that extends beyond the buffer object's allocated data store.");
141 glBufferSubData(GL_ARRAY_BUFFER, -1, 1, 0);
142 expectError(GL_INVALID_VALUE);
143 glBufferSubData(GL_ARRAY_BUFFER, -1, -1, 0);
144 expectError(GL_INVALID_VALUE);
145 glBufferSubData(GL_ARRAY_BUFFER, 1, -1, 0);
146 expectError(GL_INVALID_VALUE);
147 glBufferSubData(GL_ARRAY_BUFFER, 15, 1, 0);
148 expectError(GL_INVALID_VALUE);
149 glBufferSubData(GL_ARRAY_BUFFER, 1, 15, 0);
150 expectError(GL_INVALID_VALUE);
151 glBufferSubData(GL_ARRAY_BUFFER, 8, 8, 0);
152 expectError(GL_INVALID_VALUE);
153 m_log << TestLog::EndSection;
154
155 glDeleteBuffers(1, &buffer);
156 });
157 ES3F_ADD_API_CASE(clear, "Invalid glClear() usage",
158 {
159 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if any bit other than the three defined bits is set in mask.");
160 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
161 expectError(GL_NO_ERROR);
162 glClear(0x00000200);
163 expectError(GL_INVALID_VALUE);
164 glClear(0x00001000);
165 expectError(GL_INVALID_VALUE);
166 glClear(0x00000010);
167 expectError(GL_INVALID_VALUE);
168 m_log << TestLog::EndSection;
169 });
170 ES3F_ADD_API_CASE(read_pixels, "Invalid glReadPixels() usage",
171 {
172 std::vector<GLubyte> ubyteData(4);
173
174 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the combination of format and type is unsupported.");
175 glReadPixels(0, 0, 1, 1, GL_LUMINANCE_ALPHA, GL_UNSIGNED_SHORT_4_4_4_4, &ubyteData[0]);
176 expectError(GL_INVALID_OPERATION);
177 m_log << TestLog::EndSection;
178
179 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if either width or height is negative.");
180 glReadPixels(0, 0, -1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]);
181 expectError(GL_INVALID_VALUE);
182 glReadPixels(0, 0, 1, -1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]);
183 expectError(GL_INVALID_VALUE);
184 glReadPixels(0, 0, -1, -1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]);
185 expectError(GL_INVALID_VALUE);
186 m_log << TestLog::EndSection;
187
188 m_log << TestLog::Section("", "GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
189 GLuint fbo;
190 glGenFramebuffers(1, &fbo);
191 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
192 glCheckFramebufferStatus(GL_FRAMEBUFFER);
193 glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]);
194 expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
195 m_log << TestLog::EndSection;
196
197 glDeleteFramebuffers(1, &fbo);
198 });
199 ES3F_ADD_API_CASE(read_pixels_format_mismatch, "Invalid glReadPixels() usage",
200 {
201 std::vector<GLubyte> ubyteData(4);
202 std::vector<GLushort> ushortData(4);
203
204 m_log << TestLog::Section("", "Unsupported combinations of format and type will generate an INVALID_OPERATION error.");
205 glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_SHORT_5_6_5, &ushortData[0]);
206 expectError(GL_INVALID_OPERATION);
207 glReadPixels(0, 0, 1, 1, GL_ALPHA, GL_UNSIGNED_SHORT_5_6_5, &ushortData[0]);
208 expectError(GL_INVALID_OPERATION);
209 glReadPixels(0, 0, 1, 1, GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, &ushortData[0]);
210 expectError(GL_INVALID_OPERATION);
211 glReadPixels(0, 0, 1, 1, GL_ALPHA, GL_UNSIGNED_SHORT_4_4_4_4, &ushortData[0]);
212 expectError(GL_INVALID_OPERATION);
213 glReadPixels(0, 0, 1, 1, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, &ushortData[0]);
214 expectError(GL_INVALID_OPERATION);
215 glReadPixels(0, 0, 1, 1, GL_ALPHA, GL_UNSIGNED_SHORT_5_5_5_1, &ushortData[0]);
216 expectError(GL_INVALID_OPERATION);
217 m_log << TestLog::EndSection;
218
219 m_log << TestLog::Section("", "GL_RGBA/GL_UNSIGNED_BYTE is always accepted and the other acceptable pair can be discovered by querying GL_IMPLEMENTATION_COLOR_READ_FORMAT and GL_IMPLEMENTATION_COLOR_READ_TYPE.");
220 glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]);
221 expectError(GL_NO_ERROR);
222 GLint readFormat;
223 GLint readType;
224 glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &readFormat);
225 glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &readType);
226 glReadPixels(0, 0, 1, 1, readFormat, readType, &ubyteData[0]);
227 expectError(GL_NO_ERROR);
228 m_log << TestLog::EndSection;
229 });
230 ES3F_ADD_API_CASE(read_pixels_fbo_format_mismatch, "Invalid glReadPixels() usage",
231 {
232 std::vector<GLubyte> ubyteData(4);
233 std::vector<float> floatData(4);
234 deUint32 fbo;
235 deUint32 texture;
236
237 glGenTextures (1, &texture);
238 glBindTexture (GL_TEXTURE_2D, texture);
239 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
240 glGenFramebuffers (1, &fbo);
241 glBindFramebuffer (GL_FRAMEBUFFER, fbo);
242 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
243 expectError (GL_NO_ERROR);
244
245 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if currently bound framebuffer format is incompatible with format and type.");
246
247 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
248 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
249 glCheckFramebufferStatus(GL_FRAMEBUFFER);
250 expectError (GL_NO_ERROR);
251 glReadPixels (0, 0, 1, 1, GL_RGBA, GL_FLOAT, &floatData[0]);
252 expectError (GL_INVALID_OPERATION);
253
254 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32I, 32, 32, 0, GL_RGBA_INTEGER, GL_INT, NULL);
255 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
256 glCheckFramebufferStatus(GL_FRAMEBUFFER);
257 expectError (GL_NO_ERROR);
258 glReadPixels (0, 0, 1, 1, GL_RGBA, GL_FLOAT, &floatData[0]);
259 expectError (GL_INVALID_OPERATION);
260
261 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32UI, 32, 32, 0, GL_RGBA_INTEGER, GL_UNSIGNED_INT, NULL);
262 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
263 glCheckFramebufferStatus(GL_FRAMEBUFFER);
264 expectError (GL_NO_ERROR);
265 glReadPixels (0, 0, 1, 1, GL_RGBA, GL_FLOAT, &floatData[0]);
266 expectError (GL_INVALID_OPERATION);
267
268 m_log << TestLog::EndSection;
269
270 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if GL_READ_FRAMEBUFFER_BINDING is non-zero, the read framebuffer is complete, and the value of GL_SAMPLE_BUFFERS for the read framebuffer is greater than zero.");
271
272 int binding = -1;
273 int sampleBuffers;
274 deUint32 rbo;
275
276 glGenRenderbuffers(1, &rbo);
277 glBindRenderbuffer(GL_RENDERBUFFER, rbo);
278 glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_RGBA8, 32, 32);
279 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo);
280
281 glGetIntegerv (GL_READ_FRAMEBUFFER_BINDING, &binding);
282 m_log << TestLog::Message << "// GL_READ_FRAMEBUFFER_BINDING: " << binding << TestLog::EndMessage;
283 glCheckFramebufferStatus(GL_FRAMEBUFFER);
284 glGetIntegerv (GL_SAMPLE_BUFFERS, &sampleBuffers);
285 m_log << TestLog::Message << "// GL_SAMPLE_BUFFERS: " << sampleBuffers << TestLog::EndMessage;
286 expectError (GL_NO_ERROR);
287
288 if (binding == 0 || sampleBuffers <= 0)
289 {
290 m_log << TestLog::Message << "// ERROR: expected GL_READ_FRAMEBUFFER_BINDING to be non-zero and GL_SAMPLE_BUFFERS to be greater than zero" << TestLog::EndMessage;
291 if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
292 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
293 }
294 else
295 {
296 glReadPixels (0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]);
297 expectError (GL_INVALID_OPERATION);
298 }
299
300 m_log << TestLog::EndSection;
301
302 glBindRenderbuffer (GL_RENDERBUFFER, 0);
303 glBindTexture (GL_TEXTURE_2D, 0);
304 glBindFramebuffer (GL_FRAMEBUFFER, 0);
305 glDeleteFramebuffers (1, &fbo);
306 glDeleteTextures (1, &texture);
307 glDeleteRenderbuffers (1, &rbo);
308 });
309 ES3F_ADD_API_CASE(bind_buffer_range, "Invalid glBindBufferRange() usage",
310 {
311 deUint32 bufU;
312 glGenBuffers(1, &bufU);
313 glBindBuffer(GL_UNIFORM_BUFFER, bufU);
314 glBufferData(GL_UNIFORM_BUFFER, 16, NULL, GL_STREAM_DRAW);
315
316 deUint32 bufTF;
317 glGenBuffers(1, &bufTF);
318 glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, bufTF);
319 glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_STREAM_DRAW);
320
321 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_TRANSFORM_FEEDBACK_BUFFER or GL_UNIFORM_BUFFER.");
322 glBindBufferRange(GL_ARRAY_BUFFER, 0, bufU, 0, 4);
323 expectError(GL_INVALID_ENUM);
324 m_log << TestLog::EndSection;
325
326 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if target is GL_TRANSFORM_FEEDBACK_BUFFER and index is greater than or equal to GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS.");
327 int maxTFSize;
328 glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxTFSize);
329 glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, maxTFSize, bufTF, 0, 4);
330 expectError(GL_INVALID_VALUE);
331 m_log << TestLog::EndSection;
332
333 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if target is GL_UNIFORM_BUFFER and index is greater than or equal to GL_MAX_UNIFORM_BUFFER_BINDINGS.");
334 int maxUSize;
335 glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUSize);
336 glBindBufferRange(GL_UNIFORM_BUFFER, maxUSize, bufU, 0, 4);
337 expectError(GL_INVALID_VALUE);
338 m_log << TestLog::EndSection;
339
340 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if size is less than or equal to zero.");
341 glBindBufferRange(GL_UNIFORM_BUFFER, 0, bufU, 0, -1);
342 expectError(GL_INVALID_VALUE);
343 glBindBufferRange(GL_UNIFORM_BUFFER, 0, bufU, 0, 0);
344 expectError(GL_INVALID_VALUE);
345 m_log << TestLog::EndSection;
346
347 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if target is GL_TRANSFORM_FEEDBACK_BUFFER and size or offset are not multiples of 4.");
348 glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufTF, 4, 5);
349 expectError(GL_INVALID_VALUE);
350 glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufTF, 5, 4);
351 expectError(GL_INVALID_VALUE);
352 glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufTF, 5, 7);
353 expectError(GL_INVALID_VALUE);
354 m_log << TestLog::EndSection;
355
356 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if target is GL_UNIFORM_BUFFER and offset is not a multiple of GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT.");
357 int alignment;
358 glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &alignment);
359 glBindBufferRange(GL_UNIFORM_BUFFER, 0, bufU, alignment+1, 4);
360 expectError(GL_INVALID_VALUE);
361 m_log << TestLog::EndSection;
362
363 glDeleteBuffers(1, &bufU);
364 glDeleteBuffers(1, &bufTF);
365 });
366 ES3F_ADD_API_CASE(bind_buffer_base, "Invalid glBindBufferBase() usage",
367 {
368 deUint32 bufU;
369 glGenBuffers(1, &bufU);
370 glBindBuffer(GL_UNIFORM_BUFFER, bufU);
371 glBufferData(GL_UNIFORM_BUFFER, 16, NULL, GL_STREAM_DRAW);
372
373 deUint32 bufTF;
374 glGenBuffers(1, &bufTF);
375 glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, bufTF);
376 glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_STREAM_DRAW);
377 expectError(GL_NO_ERROR);
378
379 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_TRANSFORM_FEEDBACK_BUFFER or GL_UNIFORM_BUFFER.");
380 glBindBufferBase(-1, 0, bufU);
381 expectError(GL_INVALID_ENUM);
382 glBindBufferBase(GL_ARRAY_BUFFER, 0, bufU);
383 expectError(GL_INVALID_ENUM);
384 m_log << TestLog::EndSection;
385
386 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if target is GL_UNIFORM_BUFFER and index is greater than or equal to GL_MAX_UNIFORM_BUFFER_BINDINGS.");
387 int maxUSize;
388 glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUSize);
389 glBindBufferBase(GL_UNIFORM_BUFFER, maxUSize, bufU);
390 expectError(GL_INVALID_VALUE);
391 m_log << TestLog::EndSection;
392
393 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if target is GL_TRANSFORM_FEEDBACK_BUFFER andindex is greater than or equal to GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS.");
394 int maxTFSize;
395 glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxTFSize);
396 glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, maxTFSize, bufTF);
397 expectError(GL_INVALID_VALUE);
398 m_log << TestLog::EndSection;
399
400 glDeleteBuffers(1, &bufU);
401 glDeleteBuffers(1, &bufTF);
402 });
403 ES3F_ADD_API_CASE(clear_bufferiv, "Invalid glClearBufferiv() usage",
404 {
405 std::vector<int> data(32*32);
406 deUint32 fbo;
407 deUint32 texture;
408
409 glGenTextures (1, &texture);
410 glBindTexture (GL_TEXTURE_2D, texture);
411 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32I, 32, 32, 0, GL_RGBA_INTEGER, GL_INT, NULL);
412 glGenFramebuffers (1, &fbo);
413 glBindFramebuffer (GL_FRAMEBUFFER, fbo);
414 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
415 glCheckFramebufferStatus(GL_FRAMEBUFFER);
416 expectError (GL_NO_ERROR);
417
418 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if buffer is not an accepted value.");
419 glClearBufferiv(-1, 0, &data[0]);
420 expectError(GL_INVALID_ENUM);
421 glClearBufferiv(GL_FRAMEBUFFER, 0, &data[0]);
422 expectError(GL_INVALID_ENUM);
423 m_log << TestLog::EndSection;
424
425 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if buffer is GL_COLOR, GL_FRONT, GL_BACK, GL_LEFT, GL_RIGHT, or GL_FRONT_AND_BACK and drawBuffer is greater than or equal to GL_MAX_DRAW_BUFFERS.");
426 int maxDrawBuffers;
427 glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
428 glClearBufferiv(GL_COLOR, maxDrawBuffers, &data[0]);
429 expectError(GL_INVALID_VALUE);
430 m_log << TestLog::EndSection;
431
432 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if buffer is GL_DEPTH or GL_DEPTH_STENCIL.");
433 glClearBufferiv(GL_DEPTH, 1, &data[0]);
434 expectError(GL_INVALID_ENUM);
435 glClearBufferiv(GL_DEPTH_STENCIL, 1, &data[0]);
436 expectError(GL_INVALID_ENUM);
437 m_log << TestLog::EndSection;
438
439 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if buffer is GL_STENCIL and drawBuffer is not zero.");
440 glClearBufferiv(GL_STENCIL, 1, &data[0]);
441 expectError(GL_INVALID_VALUE);
442 m_log << TestLog::EndSection;
443
444 glDeleteFramebuffers(1, &fbo);
445 glDeleteTextures(1, &texture);
446 });
447 ES3F_ADD_API_CASE(clear_bufferuiv, "Invalid glClearBufferuiv() usage",
448 {
449 std::vector<deUint32> data(32*32);
450 deUint32 fbo;
451 deUint32 texture;
452
453 glGenTextures (1, &texture);
454 glBindTexture (GL_TEXTURE_2D, texture);
455 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32UI, 32, 32, 0, GL_RGBA_INTEGER, GL_UNSIGNED_INT, NULL);
456 glGenFramebuffers (1, &fbo);
457 glBindFramebuffer (GL_FRAMEBUFFER, fbo);
458 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
459 glCheckFramebufferStatus(GL_FRAMEBUFFER);
460 expectError (GL_NO_ERROR);
461
462 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if buffer is not an accepted value.");
463 glClearBufferuiv(-1, 0, &data[0]);
464 expectError(GL_INVALID_ENUM);
465 glClearBufferuiv(GL_FRAMEBUFFER, 0, &data[0]);
466 expectError(GL_INVALID_ENUM);
467 m_log << TestLog::EndSection;
468
469 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if buffer is GL_COLOR, GL_FRONT, GL_BACK, GL_LEFT, GL_RIGHT, or GL_FRONT_AND_BACK and drawBuffer is greater than or equal to GL_MAX_DRAW_BUFFERS.");
470 int maxDrawBuffers;
471 glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
472 glClearBufferuiv(GL_COLOR, maxDrawBuffers, &data[0]);
473 expectError(GL_INVALID_VALUE);
474 m_log << TestLog::EndSection;
475
476 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if buffer is GL_DEPTH, GL_STENCIL or GL_DEPTH_STENCIL.");
477 glClearBufferuiv(GL_DEPTH, 1, &data[0]);
478 expectError(GL_INVALID_ENUM);
479 glClearBufferuiv(GL_STENCIL, 1, &data[0]);
480 expectError(GL_INVALID_ENUM);
481 glClearBufferuiv(GL_DEPTH_STENCIL, 1, &data[0]);
482 expectError(GL_INVALID_ENUM);
483 m_log << TestLog::EndSection;
484
485 glDeleteFramebuffers(1, &fbo);
486 glDeleteTextures(1, &texture);
487 });
488 ES3F_ADD_API_CASE(clear_bufferfv, "Invalid glClearBufferfv() usage",
489 {
490 std::vector<float> data(32*32);
491 deUint32 fbo;
492 deUint32 texture;
493
494 glGenTextures (1, &texture);
495 glBindTexture (GL_TEXTURE_2D, texture);
496 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32F, 32, 32, 0, GL_RGBA, GL_FLOAT, NULL);
497 glGenFramebuffers (1, &fbo);
498 glBindFramebuffer (GL_FRAMEBUFFER, fbo);
499 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
500 glCheckFramebufferStatus(GL_FRAMEBUFFER);
501 expectError (GL_NO_ERROR);
502
503 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if buffer is not an accepted value.");
504 glClearBufferfv(-1, 0, &data[0]);
505 expectError(GL_INVALID_ENUM);
506 glClearBufferfv(GL_FRAMEBUFFER, 0, &data[0]);
507 expectError(GL_INVALID_ENUM);
508 m_log << TestLog::EndSection;
509
510 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if buffer is GL_COLOR, GL_FRONT, GL_BACK, GL_LEFT, GL_RIGHT, or GL_FRONT_AND_BACK and drawBuffer is greater than or equal to GL_MAX_DRAW_BUFFERS.");
511 int maxDrawBuffers;
512 glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
513 glClearBufferfv(GL_COLOR, maxDrawBuffers, &data[0]);
514 expectError(GL_INVALID_VALUE);
515 m_log << TestLog::EndSection;
516
517 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if buffer is GL_STENCIL or GL_DEPTH_STENCIL.");
518 glClearBufferfv(GL_STENCIL, 1, &data[0]);
519 expectError(GL_INVALID_ENUM);
520 glClearBufferfv(GL_DEPTH_STENCIL, 1, &data[0]);
521 expectError(GL_INVALID_ENUM);
522 m_log << TestLog::EndSection;
523
524 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if buffer is GL_DEPTH and drawBuffer is not zero.");
525 glClearBufferfv(GL_DEPTH, 1, &data[0]);
526 expectError(GL_INVALID_VALUE);
527 m_log << TestLog::EndSection;
528
529 glDeleteFramebuffers(1, &fbo);
530 glDeleteTextures(1, &texture);
531 });
532 ES3F_ADD_API_CASE(clear_bufferfi, "Invalid glClearBufferfi() usage",
533 {
534 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if buffer is not an accepted value.");
535 glClearBufferfi(-1, 0, 1.0f, 1);
536 expectError(GL_INVALID_ENUM);
537 glClearBufferfi(GL_FRAMEBUFFER, 0, 1.0f, 1);
538 expectError(GL_INVALID_ENUM);
539 m_log << TestLog::EndSection;
540
541 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if buffer is not GL_DEPTH_STENCIL.");
542 glClearBufferfi(GL_DEPTH, 0, 1.0f, 1);
543 expectError(GL_INVALID_ENUM);
544 glClearBufferfi(GL_STENCIL, 0, 1.0f, 1);
545 expectError(GL_INVALID_ENUM);
546 glClearBufferfi(GL_COLOR, 0, 1.0f, 1);
547 expectError(GL_INVALID_ENUM);
548 m_log << TestLog::EndSection;
549
550 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if buffer is GL_DEPTH_STENCIL and drawBuffer is not zero.");
551 glClearBufferfi(GL_DEPTH_STENCIL, 1, 1.0f, 1);
552 expectError(GL_INVALID_VALUE);
553 m_log << TestLog::EndSection;
554 });
555 ES3F_ADD_API_CASE(copy_buffer_sub_data, "Invalid glCopyBufferSubData() usage",
556 {
557 deUint32 buf[2];
558 std::vector<float> data(32*32);
559
560 glGenBuffers (2, buf);
561 glBindBuffer (GL_COPY_READ_BUFFER, buf[0]);
562 glBufferData (GL_COPY_READ_BUFFER, 32, &data[0], GL_DYNAMIC_COPY);
563 glBindBuffer (GL_COPY_WRITE_BUFFER, buf[1]);
564 glBufferData (GL_COPY_WRITE_BUFFER, 32, &data[0], GL_DYNAMIC_COPY);
565 expectError (GL_NO_ERROR);
566
567 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if any of readoffset, writeoffset or size is negative.");
568 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, -4);
569 expectError (GL_INVALID_VALUE);
570 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, -1, 0, 4);
571 expectError (GL_INVALID_VALUE);
572 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, -1, 4);
573 expectError (GL_INVALID_VALUE);
574 m_log << TestLog::EndSection;
575
576 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if readoffset + size exceeds the size of the buffer object bound to readtarget.");
577 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 36);
578 expectError (GL_INVALID_VALUE);
579 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 24, 0, 16);
580 expectError (GL_INVALID_VALUE);
581 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 36, 0, 4);
582 expectError (GL_INVALID_VALUE);
583 m_log << TestLog::EndSection;
584
585 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if writeoffset + size exceeds the size of the buffer object bound to writetarget.");
586 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 36);
587 expectError (GL_INVALID_VALUE);
588 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 24, 16);
589 expectError (GL_INVALID_VALUE);
590 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 36, 4);
591 expectError (GL_INVALID_VALUE);
592 m_log << TestLog::EndSection;
593
594 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if the same buffer object is bound to both readtarget and writetarget and the ranges [readoffset, readoffset + size) and [writeoffset, writeoffset + size) overlap.");
595 glBindBuffer (GL_COPY_WRITE_BUFFER, buf[0]);
596 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 16, 4);
597 expectError (GL_NO_ERROR);
598 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 4);
599 expectError (GL_INVALID_VALUE);
600 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 16, 18);
601 expectError (GL_INVALID_VALUE);
602 glBindBuffer (GL_COPY_WRITE_BUFFER, buf[1]);
603 m_log << TestLog::EndSection;
604
605 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if zero is bound to readtarget or writetarget.");
606 glBindBuffer (GL_COPY_READ_BUFFER, 0);
607 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 16);
608 expectError (GL_INVALID_OPERATION);
609
610 glBindBuffer (GL_COPY_READ_BUFFER, buf[0]);
611 glBindBuffer (GL_COPY_WRITE_BUFFER, 0);
612 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 16);
613 expectError (GL_INVALID_OPERATION);
614
615 glBindBuffer (GL_COPY_WRITE_BUFFER, buf[1]);
616 m_log << TestLog::EndSection;
617
618 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the buffer object bound to either readtarget or writetarget is mapped.");
619 glMapBufferRange (GL_COPY_READ_BUFFER, 0, 4, GL_MAP_READ_BIT);
620 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 16);
621 expectError (GL_INVALID_OPERATION);
622 glUnmapBuffer (GL_COPY_READ_BUFFER);
623
624 glMapBufferRange (GL_COPY_WRITE_BUFFER, 0, 4, GL_MAP_READ_BIT);
625 glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 16);
626 expectError (GL_INVALID_OPERATION);
627 glUnmapBuffer (GL_COPY_WRITE_BUFFER);
628 m_log << TestLog::EndSection;
629
630 glDeleteBuffers(2, buf);
631 });
632 ES3F_ADD_API_CASE(draw_buffers, "Invalid glDrawBuffers() usage",
633 {
634 deUint32 fbo;
635 deUint32 texture;
636 int maxDrawBuffers;
637 glGetIntegerv (GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
638 std::vector<deUint32> values(maxDrawBuffers+1);
639 values[0] = GL_NONE;
640 values[1] = GL_BACK;
641 values[2] = GL_COLOR_ATTACHMENT0;
642 values[3] = GL_DEPTH_ATTACHMENT;
643 std::vector<GLfloat> data(32*32);
644
645 glGenTextures (1, &texture);
646 glBindTexture (GL_TEXTURE_2D, texture);
647 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
648 glGenFramebuffers (1, &fbo);
649 glBindFramebuffer (GL_FRAMEBUFFER, fbo);
650 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
651 glCheckFramebufferStatus(GL_FRAMEBUFFER);
652 expectError (GL_NO_ERROR);
653
654 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if one of the values in bufs is not an accepted value.");
655 glDrawBuffers (2, &values[2]);
656 expectError (GL_INVALID_ENUM);
657 m_log << TestLog::EndSection;
658
659 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the GL is bound to the default framebuffer and n is not 1.");
660 glBindFramebuffer (GL_FRAMEBUFFER, 0);
661 glDrawBuffers (2, &values[0]);
662 expectError (GL_INVALID_OPERATION);
663 m_log << TestLog::EndSection;
664
665 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the GL is bound to the default framebuffer and the value in bufs is one of the GL_COLOR_ATTACHMENTn tokens.");
666 glBindFramebuffer (GL_FRAMEBUFFER, 0);
667 glDrawBuffers (1, &values[2]);
668 expectError (GL_INVALID_OPERATION);
669 m_log << TestLog::EndSection;
670
671 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the GL is bound to a framebuffer object and the ith buffer listed in bufs is anything other than GL_NONE or GL_COLOR_ATTACHMENTSi.");
672 glBindFramebuffer (GL_FRAMEBUFFER, fbo);
673 glDrawBuffers (1, &values[1]);
674 expectError (GL_INVALID_OPERATION);
675 m_log << TestLog::EndSection;
676
677 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is less than 0 or greater than GL_MAX_DRAW_BUFFERS.");
678 glDrawBuffers (-1, &values[1]);
679 expectError (GL_INVALID_VALUE);
680 glDrawBuffers (maxDrawBuffers+1, &values[0]);
681 expectError (GL_INVALID_VALUE);
682 m_log << TestLog::EndSection;
683
684 glDeleteTextures(1, &texture);
685 glDeleteFramebuffers(1, &fbo);
686 });
687 ES3F_ADD_API_CASE(flush_mapped_buffer_range, "Invalid glFlushMappedBufferRange() usage",
688 {
689 deUint32 buf;
690 std::vector<GLfloat> data(32);
691
692 glGenBuffers (1, &buf);
693 glBindBuffer (GL_ARRAY_BUFFER, buf);
694 glBufferData (GL_ARRAY_BUFFER, 32, &data[0], GL_STATIC_READ);
695 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
696 expectError (GL_NO_ERROR);
697
698 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if offset or length is negative, or if offset + length exceeds the size of the mapping.");
699 glFlushMappedBufferRange(GL_ARRAY_BUFFER, -1, 1);
700 expectError (GL_INVALID_VALUE);
701 glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, -1);
702 expectError (GL_INVALID_VALUE);
703 glFlushMappedBufferRange(GL_ARRAY_BUFFER, 12, 8);
704 expectError (GL_INVALID_VALUE);
705 glFlushMappedBufferRange(GL_ARRAY_BUFFER, 24, 4);
706 expectError (GL_INVALID_VALUE);
707 glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 24);
708 expectError (GL_INVALID_VALUE);
709 m_log << TestLog::EndSection;
710
711 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if zero is bound to target.");
712 glBindBuffer (GL_ARRAY_BUFFER, 0);
713 glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 8);
714 expectError (GL_INVALID_OPERATION);
715 m_log << TestLog::EndSection;
716
717 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the buffer bound to target is not mapped, or is mapped without the GL_MAP_FLUSH_EXPLICIT flag.");
718 glBindBuffer (GL_ARRAY_BUFFER, buf);
719 glUnmapBuffer (GL_ARRAY_BUFFER);
720 glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 8);
721 expectError (GL_INVALID_OPERATION);
722 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_WRITE_BIT);
723 glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 8);
724 expectError (GL_INVALID_OPERATION);
725 m_log << TestLog::EndSection;
726
727 glUnmapBuffer (GL_ARRAY_BUFFER);
728 glDeleteBuffers (1, &buf);
729 });
730 ES3F_ADD_API_CASE(map_buffer_range, "Invalid glMapBufferRange() usage",
731 {
732 deUint32 buf;
733 std::vector<GLfloat> data(32);
734
735 glGenBuffers (1, &buf);
736 glBindBuffer (GL_ARRAY_BUFFER, buf);
737 glBufferData (GL_ARRAY_BUFFER, 32, &data[0], GL_DYNAMIC_COPY);
738 expectError (GL_NO_ERROR);
739
740 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if either of offset or length is negative.");
741 glMapBufferRange (GL_ARRAY_BUFFER, -1, 1, GL_MAP_READ_BIT);
742 expectError (GL_INVALID_VALUE);
743
744 glMapBufferRange (GL_ARRAY_BUFFER, 1, -1, GL_MAP_READ_BIT);
745 expectError (GL_INVALID_VALUE);
746 m_log << TestLog::EndSection;
747
748 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if offset + length is greater than the value of GL_BUFFER_SIZE.");
749 glMapBufferRange (GL_ARRAY_BUFFER, 0, 33, GL_MAP_READ_BIT);
750 expectError (GL_INVALID_VALUE);
751
752 glMapBufferRange (GL_ARRAY_BUFFER, 32, 1, GL_MAP_READ_BIT);
753 expectError (GL_INVALID_VALUE);
754
755 glMapBufferRange (GL_ARRAY_BUFFER, 16, 17, GL_MAP_READ_BIT);
756 expectError (GL_INVALID_VALUE);
757 m_log << TestLog::EndSection;
758
759 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if access has any bits set other than those accepted.");
760 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | 0x1000);
761 expectError (GL_INVALID_VALUE);
762
763 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_WRITE_BIT | 0x1000);
764 expectError (GL_INVALID_VALUE);
765 m_log << TestLog::EndSection;
766
767 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the buffer is already in a mapped state.");
768 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_WRITE_BIT);
769 expectError (GL_NO_ERROR);
770 glMapBufferRange (GL_ARRAY_BUFFER, 16, 8, GL_MAP_READ_BIT);
771 expectError (GL_INVALID_OPERATION);
772 glUnmapBuffer (GL_ARRAY_BUFFER);
773 m_log << TestLog::EndSection;
774
775 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if neither GL_MAP_READ_BIT or GL_MAP_WRITE_BIT is set.");
776 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_INVALIDATE_RANGE_BIT);
777 expectError (GL_INVALID_OPERATION);
778 m_log << TestLog::EndSection;
779
780 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if ");
781 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_INVALIDATE_RANGE_BIT);
782 expectError (GL_INVALID_OPERATION);
783 m_log << TestLog::EndSection;
784
785 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if GL_MAP_READ_BIT is set and any of GL_MAP_INVALIDATE_RANGE_BIT, GL_MAP_INVALIDATE_BUFFER_BIT, or GL_MAP_UNSYNCHRONIZED_BIT is set.");
786 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | GL_MAP_INVALIDATE_RANGE_BIT);
787 expectError (GL_INVALID_OPERATION);
788
789 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
790 expectError (GL_INVALID_OPERATION);
791
792 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
793 expectError (GL_INVALID_OPERATION);
794 m_log << TestLog::EndSection;
795
796 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if GL_MAP_FLUSH_EXPLICIT_BIT is set and GL_MAP_WRITE_BIT is not set.");
797 glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
798 expectError (GL_INVALID_OPERATION);
799 m_log << TestLog::EndSection;
800
801 glDeleteBuffers (1, &buf);
802 });
803 ES3F_ADD_API_CASE(read_buffer, "Invalid glReadBuffer() usage",
804 {
805 deUint32 fbo;
806 deUint32 texture;
807 int maxColorAttachments;
808
809 glGetIntegerv (GL_MAX_COLOR_ATTACHMENTS, &maxColorAttachments);
810 glGenTextures (1, &texture);
811 glBindTexture (GL_TEXTURE_2D, texture);
812 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
813 glGenFramebuffers (1, &fbo);
814 glBindFramebuffer (GL_FRAMEBUFFER, fbo);
815 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
816 glCheckFramebufferStatus(GL_FRAMEBUFFER);
817 expectError (GL_NO_ERROR);
818
819 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if mode is not GL_BACK, GL_NONE, or GL_COLOR_ATTACHMENTi.");
820 glReadBuffer (GL_NONE);
821 expectError (GL_NO_ERROR);
822 glReadBuffer (1);
823 expectError (GL_INVALID_ENUM);
824 glReadBuffer (GL_FRAMEBUFFER);
825 expectError (GL_INVALID_ENUM);
826 glReadBuffer (GL_COLOR_ATTACHMENT0 - 1);
827 expectError (GL_INVALID_ENUM);
828 glReadBuffer (GL_FRONT);
829 expectError (GL_INVALID_ENUM);
830
831 // \ note Spec isn't actually clear here, but it is safe to assume that
832 // GL_DEPTH_ATTACHMENT can't be interpreted as GL_COLOR_ATTACHMENTm
833 // where m = (GL_DEPTH_ATTACHMENT - GL_COLOR_ATTACHMENT0).
834 glReadBuffer (GL_DEPTH_ATTACHMENT);
835 expectError (GL_INVALID_ENUM);
836 glReadBuffer (GL_STENCIL_ATTACHMENT);
837 expectError (GL_INVALID_ENUM);
838 glReadBuffer (GL_STENCIL_ATTACHMENT+1);
839 expectError (GL_INVALID_ENUM);
840 glReadBuffer (0xffffffffu);
841 expectError (GL_INVALID_ENUM);
842 m_log << TestLog::EndSection;
843
844 m_log << TestLog::Section("", "GL_INVALID_OPERATION error is generated if src is GL_BACK or if src is GL_COLOR_ATTACHMENTm where m is greater than or equal to the value of GL_MAX_COLOR_ATTACHMENTS.");
845 glReadBuffer (GL_BACK);
846 expectError (GL_INVALID_OPERATION);
847 glReadBuffer (GL_COLOR_ATTACHMENT0 + maxColorAttachments);
848 expectError (GL_INVALID_OPERATION);
849
850 if (GL_COLOR_ATTACHMENT0+maxColorAttachments < GL_DEPTH_ATTACHMENT-1)
851 {
852 glReadBuffer (GL_DEPTH_ATTACHMENT - 1);
853 expectError (GL_INVALID_OPERATION);
854 }
855
856 m_log << TestLog::EndSection;
857
858 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the current framebuffer is the default framebuffer and mode is not GL_NONE or GL_BACK.");
859 glBindFramebuffer (GL_FRAMEBUFFER, 0);
860 glReadBuffer (GL_COLOR_ATTACHMENT0);
861 expectError (GL_INVALID_OPERATION);
862 m_log << TestLog::EndSection;
863
864 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the current framebuffer is a named framebuffer and mode is not GL_NONE or GL_COLOR_ATTACHMENTi.");
865 glBindFramebuffer (GL_FRAMEBUFFER, fbo);
866 glReadBuffer (GL_BACK);
867 expectError (GL_INVALID_OPERATION);
868 m_log << TestLog::EndSection;
869
870 glDeleteTextures(1, &texture);
871 glDeleteFramebuffers(1, &fbo);
872 });
873 ES3F_ADD_API_CASE(unmap_buffer, "Invalid glUnmapBuffer() usage",
874 {
875 deUint32 buf;
876 std::vector<GLfloat> data(32);
877
878 glGenBuffers (1, &buf);
879 glBindBuffer (GL_ARRAY_BUFFER, buf);
880 glBufferData (GL_ARRAY_BUFFER, 32, &data[0], GL_DYNAMIC_COPY);
881 expectError (GL_NO_ERROR);
882
883 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the buffer data store is already in an unmapped state.");
884 glUnmapBuffer (GL_ARRAY_BUFFER);
885 expectError (GL_INVALID_OPERATION);
886 m_log << TestLog::EndSection;
887
888 glDeleteBuffers (1, &buf);
889 });
890 // Framebuffer Objects
891
892 ES3F_ADD_API_CASE(bind_framebuffer, "Invalid glBindFramebuffer() usage",
893 {
894 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_FRAMEBUFFER.");
895 glBindFramebuffer(-1, 0);
896 expectError(GL_INVALID_ENUM);
897 glBindFramebuffer(GL_RENDERBUFFER, 0);
898 expectError(GL_INVALID_ENUM);
899 m_log << TestLog::EndSection;
900 });
901 ES3F_ADD_API_CASE(bind_renderbuffer, "Invalid glBindRenderbuffer() usage",
902 {
903 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_RENDERBUFFER.");
904 glBindRenderbuffer(-1, 0);
905 expectError(GL_INVALID_ENUM);
906 glBindRenderbuffer(GL_FRAMEBUFFER, 0);
907 expectError(GL_INVALID_ENUM);
908 m_log << TestLog::EndSection;
909 });
910 ES3F_ADD_API_CASE(check_framebuffer_status, "Invalid glCheckFramebufferStatus() usage",
911 {
912 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_FRAMEBUFFER.");
913 glCheckFramebufferStatus(-1);
914 expectError(GL_INVALID_ENUM);
915 glCheckFramebufferStatus(GL_RENDERBUFFER);
916 expectError(GL_INVALID_ENUM);
917 m_log << TestLog::EndSection;
918 });
919 ES3F_ADD_API_CASE(gen_framebuffers, "Invalid glGenFramebuffers() usage",
920 {
921 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
922 glGenFramebuffers(-1, 0);
923 expectError(GL_INVALID_VALUE);
924 m_log << TestLog::EndSection;
925 });
926 ES3F_ADD_API_CASE(gen_renderbuffers, "Invalid glGenRenderbuffers() usage",
927 {
928 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
929 glGenRenderbuffers(-1, 0);
930 expectError(GL_INVALID_VALUE);
931 m_log << TestLog::EndSection;
932 });
933 ES3F_ADD_API_CASE(delete_framebuffers, "Invalid glDeleteFramebuffers() usage",
934 {
935 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
936 glDeleteFramebuffers(-1, 0);
937 expectError(GL_INVALID_VALUE);
938 m_log << TestLog::EndSection;
939 });
940 ES3F_ADD_API_CASE(delete_renderbuffers, "Invalid glDeleteRenderbuffers() usage",
941 {;
942 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if n is negative.");
943 glDeleteRenderbuffers(-1, 0);
944 expectError(GL_INVALID_VALUE);
945 m_log << TestLog::EndSection;
946 });
947 ES3F_ADD_API_CASE(framebuffer_renderbuffer, "Invalid glFramebufferRenderbuffer() usage",
948 {
949 GLuint fbo;
950 GLuint rbo;
951 glGenFramebuffers(1, &fbo);
952 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
953 glGenRenderbuffers(1, &rbo);
954
955 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not one of the accepted tokens.");
956 glFramebufferRenderbuffer(-1, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, 0);
957 expectError(GL_INVALID_ENUM);
958 m_log << TestLog::EndSection;
959
960 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if renderbuffertarget is not GL_RENDERBUFFER.");
961 glBindRenderbuffer(GL_RENDERBUFFER, rbo);
962 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, -1, rbo);
963 expectError(GL_INVALID_ENUM);
964 glBindRenderbuffer(GL_RENDERBUFFER, 0);
965 m_log << TestLog::EndSection;
966
967 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if renderbuffer is neither 0 nor the name of an existing renderbuffer object.");
968 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, -1);
969 expectError(GL_INVALID_OPERATION);
970 m_log << TestLog::EndSection;
971
972 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if zero is bound to target.");
973 glBindFramebuffer(GL_FRAMEBUFFER, 0);
974 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, 0);
975 expectError(GL_INVALID_OPERATION);
976 m_log << TestLog::EndSection;
977
978 glDeleteRenderbuffers(1, &rbo);
979 glDeleteFramebuffers(1, &fbo);
980 });
981 ES3F_ADD_API_CASE(framebuffer_texture2d, "Invalid glFramebufferTexture2D() usage",
982 {
983 GLuint fbo;
984 GLuint tex2D;
985 GLuint texCube;
986 glGenFramebuffers(1, &fbo);
987 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
988 glGenTextures(1, &tex2D);
989 glBindTexture(GL_TEXTURE_2D, tex2D);
990 glGenTextures(1, &texCube);
991 glBindTexture(GL_TEXTURE_CUBE_MAP, texCube);
992 expectError(GL_NO_ERROR);
993
994 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not one of the accepted tokens.");
995 glFramebufferTexture2D(-1, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
996 expectError(GL_INVALID_ENUM);
997 m_log << TestLog::EndSection;
998
999 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if textarget is not an accepted texture target.");
1000 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, -1, tex2D, 0);
1001 expectError(GL_INVALID_ENUM);
1002 m_log << TestLog::EndSection;
1003
1004 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if level is less than 0 or larger than log_2 of maximum texture size.");
1005 int maxSize;
1006 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex2D, -1);
1007 expectError(GL_INVALID_VALUE);
1008 maxSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_TEXTURE_SIZE)) + 1;
1009 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex2D, maxSize);
1010 expectError(GL_INVALID_VALUE);
1011 maxSize = deLog2Floor32(m_context.getContextInfo().getInt(GL_MAX_CUBE_MAP_TEXTURE_SIZE)) + 1;
1012 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X, texCube, maxSize);
1013 expectError(GL_INVALID_VALUE);
1014 m_log << TestLog::EndSection;
1015
1016 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if texture is neither 0 nor the name of an existing texture object.");
1017 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, -1, 0);
1018 expectError(GL_INVALID_OPERATION);
1019 m_log << TestLog::EndSection;
1020
1021 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if textarget and texture are not compatible.");
1022 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X, tex2D, 0);
1023 expectError(GL_INVALID_OPERATION);
1024 glDeleteTextures(1, &tex2D);
1025
1026 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texCube, 0);
1027 expectError(GL_INVALID_OPERATION);
1028 glDeleteTextures(1, &texCube);
1029 m_log << TestLog::EndSection;
1030
1031 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if zero is bound to target.");
1032 glBindFramebuffer(GL_FRAMEBUFFER, 0);
1033 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
1034 expectError(GL_INVALID_OPERATION);
1035 m_log << TestLog::EndSection;
1036
1037 glDeleteFramebuffers(1, &fbo);
1038 });
1039 ES3F_ADD_API_CASE(renderbuffer_storage, "Invalid glRenderbufferStorage() usage",
1040 {
1041 deUint32 rbo;
1042 glGenRenderbuffers (1, &rbo);
1043 glBindRenderbuffer (GL_RENDERBUFFER, rbo);
1044
1045 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_RENDERBUFFER.");
1046 glRenderbufferStorage (-1, GL_RGBA4, 1, 1);
1047 expectError (GL_INVALID_ENUM);
1048 glRenderbufferStorage (GL_FRAMEBUFFER, GL_RGBA4, 1, 1);
1049 expectError (GL_INVALID_ENUM);
1050 m_log << TestLog::EndSection;
1051
1052 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if internalformat is not a color-renderable, depth-renderable, or stencil-renderable format.");
1053 glRenderbufferStorage (GL_RENDERBUFFER, -1, 1, 1);
1054 expectError (GL_INVALID_ENUM);
1055
1056 if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_color_buffer_half_float")) // GL_EXT_color_buffer_half_float disables error
1057 {
1058 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGB16F, 1, 1);
1059 expectError (GL_INVALID_ENUM);
1060 }
1061
1062 if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_render_snorm")) // GL_EXT_render_snorm disables error
1063 {
1064 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA8_SNORM, 1, 1);
1065 expectError (GL_INVALID_ENUM);
1066 }
1067
1068 m_log << TestLog::EndSection;
1069
1070 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than zero.");
1071 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, -1, 1);
1072 expectError (GL_INVALID_VALUE);
1073 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, 1, -1);
1074 expectError (GL_INVALID_VALUE);
1075 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, -1, -1);
1076 expectError (GL_INVALID_VALUE);
1077 m_log << TestLog::EndSection;
1078
1079 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_RENDERBUFFER_SIZE.");
1080 GLint maxSize;
1081 glGetIntegerv (GL_MAX_RENDERBUFFER_SIZE, &maxSize);
1082 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, 1, maxSize+1);
1083 expectError (GL_INVALID_VALUE);
1084 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, maxSize+1, 1);
1085 expectError (GL_INVALID_VALUE);
1086 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, maxSize+1, maxSize+1);
1087 expectError (GL_INVALID_VALUE);
1088 m_log << TestLog::EndSection;
1089
1090 glDeleteRenderbuffers(1, &rbo);
1091 });
1092 ES3F_ADD_API_CASE(blit_framebuffer, "Invalid glBlitFramebuffer() usage",
1093 {
1094 deUint32 fbo[2];
1095 deUint32 rbo[2];
1096 deUint32 texture[2];
1097
1098 glGenFramebuffers (2, fbo);
1099 glGenTextures (2, texture);
1100 glGenRenderbuffers (2, rbo);
1101
1102 glBindTexture (GL_TEXTURE_2D, texture[0]);
1103 glBindRenderbuffer (GL_RENDERBUFFER, rbo[0]);
1104 glBindFramebuffer (GL_READ_FRAMEBUFFER, fbo[0]);
1105
1106 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1107 glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 32, 32);
1108 glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0);
1109 glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo[0]);
1110 glCheckFramebufferStatus(GL_READ_FRAMEBUFFER);
1111
1112 glBindTexture (GL_TEXTURE_2D, texture[1]);
1113 glBindRenderbuffer (GL_RENDERBUFFER, rbo[1]);
1114 glBindFramebuffer (GL_DRAW_FRAMEBUFFER, fbo[1]);
1115
1116 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1117 glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 32, 32);
1118 glFramebufferTexture2D (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[1], 0);
1119 glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo[1]);
1120 glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
1121 expectError (GL_NO_ERROR);
1122
1123 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if mask contains any of the GL_DEPTH_BUFFER_BIT or GL_STENCIL_BUFFER_BIT and filter is not GL_NEAREST.");
1124 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT, GL_LINEAR);
1125 expectError (GL_INVALID_OPERATION);
1126 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, GL_LINEAR);
1127 expectError (GL_INVALID_OPERATION);
1128 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT, GL_LINEAR);
1129 expectError (GL_INVALID_OPERATION);
1130 m_log << TestLog::EndSection;
1131
1132 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if mask contains GL_COLOR_BUFFER_BIT and read buffer format is incompatible with draw buffer format.");
1133 glBindTexture (GL_TEXTURE_2D, texture[0]);
1134
1135 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32UI, 32, 32, 0, GL_RGBA_INTEGER, GL_UNSIGNED_INT, NULL);
1136 glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0);
1137 m_log << TestLog::Message << "// Read buffer: GL_RGBA32UI, draw buffer: GL_RGBA" << TestLog::EndMessage;
1138 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST);
1139 expectError (GL_INVALID_OPERATION);
1140
1141 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32I, 32, 32, 0, GL_RGBA_INTEGER, GL_INT, NULL);
1142 glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0);
1143 m_log << TestLog::Message << "// Read buffer: GL_RGBA32I, draw buffer: GL_RGBA" << TestLog::EndMessage;
1144 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST);
1145 expectError (GL_INVALID_OPERATION);
1146
1147 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1148 glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0);
1149 glBindTexture (GL_TEXTURE_2D, texture[1]);
1150 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32I, 32, 32, 0, GL_RGBA_INTEGER, GL_INT, NULL);
1151 glFramebufferTexture2D (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[1], 0);
1152 m_log << TestLog::Message << "// Read buffer: GL_RGBA8, draw buffer: GL_RGBA32I" << TestLog::EndMessage;
1153 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST);
1154 expectError (GL_INVALID_OPERATION);
1155 m_log << TestLog::EndSection;
1156
1157 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if filter is GL_LINEAR and the read buffer contains integer data.");
1158 glBindTexture (GL_TEXTURE_2D, texture[0]);
1159 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32UI, 32, 32, 0, GL_RGBA_INTEGER, GL_UNSIGNED_INT, NULL);
1160 glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0);
1161 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1162 glFramebufferTexture2D (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[1], 0);
1163 m_log << TestLog::Message << "// Read buffer: GL_RGBA32I, draw buffer: GL_RGBA8" << TestLog::EndMessage;
1164 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_LINEAR);
1165 expectError (GL_INVALID_OPERATION);
1166 m_log << TestLog::EndSection;
1167
1168 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if mask contains GL_DEPTH_BUFFER_BIT or GL_STENCIL_BUFFER_BIT and the source and destination depth and stencil formats do not match.");
1169 glBindRenderbuffer (GL_RENDERBUFFER, rbo[0]);
1170 glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH32F_STENCIL8, 32, 32);
1171 glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo[0]);
1172 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_DEPTH_BUFFER_BIT, GL_NEAREST);
1173 expectError (GL_INVALID_OPERATION);
1174 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_STENCIL_BUFFER_BIT, GL_NEAREST);
1175 expectError (GL_INVALID_OPERATION);
1176 m_log << TestLog::EndSection;
1177
1178 glBindFramebuffer (GL_FRAMEBUFFER, 0);
1179 glDeleteFramebuffers (2, fbo);
1180 glDeleteTextures (2, texture);
1181 glDeleteRenderbuffers (2, rbo);
1182 });
1183 ES3F_ADD_API_CASE(blit_framebuffer_multisample, "Invalid glBlitFramebuffer() usage",
1184 {
1185 deUint32 fbo[2];
1186 deUint32 rbo[2];
1187
1188 glGenFramebuffers (2, fbo);
1189 glGenRenderbuffers (2, rbo);
1190
1191 glBindRenderbuffer (GL_RENDERBUFFER, rbo[0]);
1192 glBindFramebuffer (GL_READ_FRAMEBUFFER, fbo[0]);
1193 glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_RGBA8, 32, 32);
1194 glFramebufferRenderbuffer (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo[0]);
1195 glCheckFramebufferStatus (GL_READ_FRAMEBUFFER);
1196
1197 glBindRenderbuffer (GL_RENDERBUFFER, rbo[1]);
1198 glBindFramebuffer (GL_DRAW_FRAMEBUFFER, fbo[1]);
1199
1200 expectError (GL_NO_ERROR);
1201
1202 if (!m_context.getContextInfo().isExtensionSupported("GL_NV_framebuffer_multisample"))
1203 {
1204 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if the value of GL_SAMPLE_BUFFERS for the draw buffer is greater than zero.");
1205 glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_RGBA8, 32, 32);
1206 glFramebufferRenderbuffer (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo[1]);
1207 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST);
1208 expectError (GL_INVALID_OPERATION);
1209 m_log << TestLog::EndSection;
1210
1211 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if GL_SAMPLE_BUFFERS for the read buffer is greater than zero and the formats of draw and read buffers are not identical.");
1212 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, 32, 32);
1213 glFramebufferRenderbuffer (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo[1]);
1214 glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST);
1215 expectError (GL_INVALID_OPERATION);
1216 m_log << TestLog::EndSection;
1217
1218 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if GL_SAMPLE_BUFFERS for the read buffer is greater than zero and the source and destination rectangles are not defined with the same (X0, Y0) and (X1, Y1) bounds.");
1219 glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA8, 32, 32);
1220 glFramebufferRenderbuffer (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo[1]);
1221 glBlitFramebuffer (0, 0, 16, 16, 2, 2, 18, 18, GL_COLOR_BUFFER_BIT, GL_NEAREST);
1222 expectError (GL_INVALID_OPERATION);
1223 m_log << TestLog::EndSection;
1224 }
1225
1226 glBindFramebuffer (GL_FRAMEBUFFER, 0);
1227 glDeleteRenderbuffers (2, rbo);
1228 glDeleteFramebuffers (2, fbo);
1229 });
1230 ES3F_ADD_API_CASE(framebuffer_texture_layer, "Invalid glFramebufferTextureLayer() usage",
1231 {
1232 deUint32 fbo;
1233 deUint32 tex3D;
1234 deUint32 tex2DArray;
1235 deUint32 tex2D;
1236
1237 glGenFramebuffers (1, &fbo);
1238 glGenTextures (1, &tex3D);
1239 glGenTextures (1, &tex2DArray);
1240 glGenTextures (1, &tex2D);
1241 glBindFramebuffer (GL_FRAMEBUFFER, fbo);
1242
1243 glBindTexture (GL_TEXTURE_3D, tex3D);
1244 glTexImage3D (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1245 glBindTexture (GL_TEXTURE_2D_ARRAY, tex2DArray);
1246 glTexImage3D (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1247 glBindTexture (GL_TEXTURE_2D, tex2D);
1248 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1249
1250 expectError (GL_NO_ERROR);
1251
1252 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not one of the accepted tokens.");
1253 glFramebufferTextureLayer (-1, GL_COLOR_ATTACHMENT0, tex3D, 0, 1);
1254 expectError (GL_INVALID_ENUM);
1255 glFramebufferTextureLayer (GL_RENDERBUFFER, GL_COLOR_ATTACHMENT0, tex3D, 0, 1);
1256 expectError (GL_INVALID_ENUM);
1257 m_log << TestLog::EndSection;
1258
1259 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if attachment is not one of the accepted tokens.");
1260 glFramebufferTextureLayer (GL_FRAMEBUFFER, -1, tex3D, 0, 1);
1261 expectError (GL_INVALID_ENUM);
1262 glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_BACK, tex3D, 0, 1);
1263 expectError (GL_INVALID_ENUM);
1264 m_log << TestLog::EndSection;
1265
1266 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if texture is non-zero and not the name of a 3D texture or 2D array texture.");
1267 glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, -1, 0, 0);
1268 expectError (GL_INVALID_OPERATION);
1269 glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex2D, 0, 0);
1270 expectError (GL_INVALID_OPERATION);
1271 m_log << TestLog::EndSection;
1272
1273 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if texture is not zero and layer is negative.");
1274 glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex3D, 0, -1);
1275 expectError (GL_INVALID_VALUE);
1276 m_log << TestLog::EndSection;
1277
1278 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if texture is not zero and layer is greater than GL_MAX_3D_TEXTURE_SIZE-1 for a 3D texture.");
1279 int max3DTexSize;
1280 glGetIntegerv (GL_MAX_3D_TEXTURE_SIZE, &max3DTexSize);
1281 glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex3D, 0, max3DTexSize);
1282 expectError (GL_INVALID_VALUE);
1283 m_log << TestLog::EndSection;
1284
1285 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if texture is not zero and layer is greater than GL_MAX_ARRAY_TEXTURE_LAYERS-1 for a 2D array texture.");
1286 int maxArrayTexLayers;
1287 glGetIntegerv (GL_MAX_ARRAY_TEXTURE_LAYERS, &maxArrayTexLayers);
1288 glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex2DArray, 0, maxArrayTexLayers);
1289 expectError (GL_INVALID_VALUE);
1290 m_log << TestLog::EndSection;
1291
1292 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if zero is bound to target.");
1293 glBindFramebuffer (GL_FRAMEBUFFER, 0);
1294 glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex3D, 0, 1);
1295 expectError (GL_INVALID_OPERATION);
1296 m_log << TestLog::EndSection;
1297
1298 glDeleteTextures (1, &tex3D);
1299 glDeleteTextures (1, &tex2DArray);
1300 glDeleteTextures (1, &tex2D);
1301 glDeleteFramebuffers (1, &fbo);
1302 });
1303 ES3F_ADD_API_CASE(invalidate_framebuffer, "Invalid glInvalidateFramebuffer() usage",
1304 {
1305 deUint32 fbo;
1306 deUint32 texture;
1307 deUint32 attachments[2];
1308 int maxColorAttachments;
1309 glGetIntegerv (GL_MAX_COLOR_ATTACHMENTS, &maxColorAttachments);
1310 attachments[0] = GL_COLOR_ATTACHMENT0;
1311 attachments[1] = GL_COLOR_ATTACHMENT0 + maxColorAttachments;
1312
1313 glGenFramebuffers (1, &fbo);
1314 glGenTextures (1, &texture);
1315 glBindFramebuffer (GL_FRAMEBUFFER, fbo);
1316 glBindTexture (GL_TEXTURE_2D, texture);
1317 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1318 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
1319 glCheckFramebufferStatus (GL_FRAMEBUFFER);
1320 expectError (GL_NO_ERROR);
1321
1322 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_FRAMEBUFFER, GL_READ_FRAMEBUFFER or GL_DRAW_FRAMEBUFFER.");
1323 glInvalidateFramebuffer (-1, 1, &attachments[0]);
1324 expectError (GL_INVALID_ENUM);
1325 glInvalidateFramebuffer (GL_BACK, 1, &attachments[0]);
1326 expectError (GL_INVALID_ENUM);
1327 m_log << TestLog::EndSection;
1328
1329 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if attachments contains GL_COLOR_ATTACHMENTm and m is greater than or equal to the value of GL_MAX_COLOR_ATTACHMENTS.");
1330 glInvalidateFramebuffer (GL_FRAMEBUFFER, 1, &attachments[1]);
1331 expectError (GL_INVALID_OPERATION);
1332 m_log << TestLog::EndSection;
1333
1334 glDeleteTextures (1, &texture);
1335 glDeleteFramebuffers (1, &fbo);
1336 });
1337 ES3F_ADD_API_CASE(invalidate_sub_framebuffer, "Invalid glInvalidateSubFramebuffer() usage",
1338 {
1339 deUint32 fbo;
1340 deUint32 texture;
1341 deUint32 attachments[2];
1342 int maxColorAttachments;
1343 glGetIntegerv (GL_MAX_COLOR_ATTACHMENTS, &maxColorAttachments);
1344 attachments[0] = GL_COLOR_ATTACHMENT0;
1345 attachments[1] = GL_COLOR_ATTACHMENT0 + maxColorAttachments;
1346
1347 glGenFramebuffers (1, &fbo);
1348 glGenTextures (1, &texture);
1349 glBindFramebuffer (GL_FRAMEBUFFER, fbo);
1350 glBindTexture (GL_TEXTURE_2D, texture);
1351 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1352 glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
1353 glCheckFramebufferStatus (GL_FRAMEBUFFER);
1354 expectError (GL_NO_ERROR);
1355
1356 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_FRAMEBUFFER, GL_READ_FRAMEBUFFER or GL_DRAW_FRAMEBUFFER.");
1357 glInvalidateSubFramebuffer (-1, 1, &attachments[0], 0, 0, 16, 16);
1358 expectError (GL_INVALID_ENUM);
1359 glInvalidateSubFramebuffer (GL_BACK, 1, &attachments[0], 0, 0, 16, 16);
1360 expectError (GL_INVALID_ENUM);
1361 m_log << TestLog::EndSection;
1362
1363 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if attachments contains GL_COLOR_ATTACHMENTm and m is greater than or equal to the value of GL_MAX_COLOR_ATTACHMENTS.");
1364 glInvalidateSubFramebuffer (GL_FRAMEBUFFER, 1, &attachments[1], 0, 0, 16, 16);
1365 expectError (GL_INVALID_OPERATION);
1366 m_log << TestLog::EndSection;
1367
1368 glDeleteTextures (1, &texture);
1369 glDeleteFramebuffers (1, &fbo);
1370 });
1371 ES3F_ADD_API_CASE(renderbuffer_storage_multisample, "Invalid glRenderbufferStorageMultisample() usage",
1372 {
1373 deUint32 rbo;
1374 int maxSamplesSupportedRGBA4 = -1;
1375
1376 glGetInternalformativ (GL_RENDERBUFFER, GL_RGBA4, GL_SAMPLES, 1, &maxSamplesSupportedRGBA4);
1377 glGenRenderbuffers (1, &rbo);
1378 glBindRenderbuffer (GL_RENDERBUFFER, rbo);
1379
1380 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if target is not GL_RENDERBUFFER.");
1381 glRenderbufferStorageMultisample (-1, 2, GL_RGBA4, 1, 1);
1382 expectError (GL_INVALID_ENUM);
1383 glRenderbufferStorageMultisample (GL_FRAMEBUFFER, 2, GL_RGBA4, 1, 1);
1384 expectError (GL_INVALID_ENUM);
1385 m_log << TestLog::EndSection;
1386
1387 m_log << TestLog::Section("", "GL_INVALID_OPERATION is generated if samples is greater than the maximum number of samples supported for internalformat.");
1388 glRenderbufferStorageMultisample (GL_RENDERBUFFER, maxSamplesSupportedRGBA4+1, GL_RGBA4, 1, 1);
1389 expectError (GL_INVALID_OPERATION);
1390 m_log << TestLog::EndSection;
1391
1392 m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if internalformat is not a color-renderable, depth-renderable, or stencil-renderable format.");
1393 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, -1, 1, 1);
1394 expectError (GL_INVALID_ENUM);
1395
1396 if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_color_buffer_half_float")) // GL_EXT_color_buffer_half_float disables error
1397 {
1398 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGB16F, 1, 1);
1399 expectError (GL_INVALID_ENUM);
1400 }
1401
1402 if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_render_snorm")) // GL_EXT_render_snorm disables error
1403 {
1404 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGBA8_SNORM, 1, 1);
1405 expectError (GL_INVALID_ENUM);
1406 }
1407
1408 m_log << TestLog::EndSection;
1409
1410 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is less than zero.");
1411 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGBA4, -1, 1);
1412 expectError (GL_INVALID_VALUE);
1413 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGBA4, 1, -1);
1414 expectError (GL_INVALID_VALUE);
1415 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGBA4, -1, -1);
1416 expectError (GL_INVALID_VALUE);
1417 m_log << TestLog::EndSection;
1418
1419 m_log << TestLog::Section("", "GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_RENDERBUFFER_SIZE.");
1420 GLint maxSize;
1421 glGetIntegerv (GL_MAX_RENDERBUFFER_SIZE, &maxSize);
1422 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 4, GL_RGBA4, 1, maxSize+1);
1423 expectError (GL_INVALID_VALUE);
1424 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 4, GL_RGBA4, maxSize+1, 1);
1425 expectError (GL_INVALID_VALUE);
1426 glRenderbufferStorageMultisample (GL_RENDERBUFFER, 4, GL_RGBA4, maxSize+1, maxSize+1);
1427 expectError (GL_INVALID_VALUE);
1428 m_log << TestLog::EndSection;
1429
1430 glDeleteRenderbuffers(1, &rbo);
1431 });
1432 }
1433
1434 } // Functional
1435 } // gles3
1436 } // deqp
1437