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