1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 3.1 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 "es31fNegativeBufferApiTests.hpp"
25
26 #include "gluCallLogWrapper.hpp"
27
28 #include "glwDefs.hpp"
29 #include "glwEnums.hpp"
30
31 namespace deqp
32 {
33 namespace gles31
34 {
35 namespace Functional
36 {
37 namespace NegativeTestShared
38 {
39
40 using tcu::TestLog;
41 using glu::CallLogWrapper;
42 using namespace glw;
43
44 // Buffers
bind_buffer(NegativeTestContext & ctx)45 void bind_buffer (NegativeTestContext& ctx)
46 {
47 ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the allowable values.");
48 ctx.glBindBuffer(-1, 0);
49 ctx.expectError(GL_INVALID_ENUM);
50 ctx.endSection();
51 }
52
delete_buffers(NegativeTestContext & ctx)53 void delete_buffers (NegativeTestContext& ctx)
54 {
55 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
56 ctx.glDeleteBuffers(-1, 0);
57 ctx.expectError(GL_INVALID_VALUE);
58 ctx.endSection();
59 }
60
gen_buffers(NegativeTestContext & ctx)61 void gen_buffers (NegativeTestContext& ctx)
62 {
63 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
64 ctx.glGenBuffers(-1, 0);
65 ctx.expectError(GL_INVALID_VALUE);
66 ctx.endSection();
67 }
68
buffer_data(NegativeTestContext & ctx)69 void buffer_data (NegativeTestContext& ctx)
70 {
71 GLuint buffer = 0x1234;
72 ctx.glGenBuffers(1, &buffer);
73 ctx.glBindBuffer(GL_ARRAY_BUFFER, buffer);
74
75 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_ARRAY_BUFFER or GL_ELEMENT_ARRAY_BUFFER.");
76 ctx.glBufferData(-1, 0, NULL, GL_STREAM_DRAW);
77 ctx.expectError(GL_INVALID_ENUM);
78 ctx.endSection();
79
80 ctx.beginSection("GL_INVALID_ENUM is generated if usage is not GL_STREAM_DRAW, GL_STATIC_DRAW, or GL_DYNAMIC_DRAW.");
81 ctx.glBufferData(GL_ARRAY_BUFFER, 0, NULL, -1);
82 ctx.expectError(GL_INVALID_ENUM);
83 ctx.endSection();
84
85 ctx.beginSection("GL_INVALID_VALUE is generated if size is negative.");
86 ctx.glBufferData(GL_ARRAY_BUFFER, -1, NULL, GL_STREAM_DRAW);
87 ctx.expectError(GL_INVALID_VALUE);
88 ctx.endSection();
89
90 ctx.beginSection("GL_INVALID_OPERATION is generated if the reserved buffer object name 0 is bound to target.");
91 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
92 ctx.glBufferData(GL_ARRAY_BUFFER, 0, NULL, GL_STREAM_DRAW);
93 ctx.expectError(GL_INVALID_OPERATION);
94 ctx.endSection();
95
96 ctx.glDeleteBuffers(1, &buffer);
97 }
98
buffer_sub_data(NegativeTestContext & ctx)99 void buffer_sub_data (NegativeTestContext& ctx)
100 {
101 GLuint buffer = 0x1234;
102 ctx.glGenBuffers(1, &buffer);
103 ctx.glBindBuffer(GL_ARRAY_BUFFER, buffer);
104 ctx.glBufferData(GL_ARRAY_BUFFER, 10, 0, GL_STREAM_DRAW);
105
106 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_ARRAY_BUFFER or GL_ELEMENT_ARRAY_BUFFER.");
107 ctx.glBufferSubData(-1, 1, 1, 0);
108 ctx.expectError(GL_INVALID_ENUM);
109 ctx.endSection();
110
111 ctx.beginSection("GL_INVALID_OPERATION is generated if the reserved buffer object name 0 is bound to target.");
112 ctx.glBindBuffer(GL_ARRAY_BUFFER, 0);
113 ctx.glBufferSubData(GL_ARRAY_BUFFER, 1, 1, 0);
114 ctx.expectError(GL_INVALID_OPERATION);
115 ctx.endSection();
116
117 ctx.beginSection("GL_INVALID_OPERATION is generated if the buffer object being updated is mapped.");
118 ctx.glBindBuffer(GL_ARRAY_BUFFER, buffer);
119 ctx.glMapBufferRange(GL_ARRAY_BUFFER, 0, 5, GL_MAP_READ_BIT);
120 ctx.expectError(GL_NO_ERROR);
121 ctx.glBufferSubData(GL_ARRAY_BUFFER, 1, 1, 0);
122 ctx.expectError(GL_INVALID_OPERATION);
123 ctx.endSection();
124
125 ctx.glDeleteBuffers(1, &buffer);
126 }
127
buffer_sub_data_size_offset(NegativeTestContext & ctx)128 void buffer_sub_data_size_offset (NegativeTestContext& ctx)
129 {
130 GLuint buffer = 0x1234;
131 ctx.glGenBuffers(1, &buffer);
132 ctx.glBindBuffer(GL_ARRAY_BUFFER, buffer);
133 ctx.glBufferData(GL_ARRAY_BUFFER, 10, 0, GL_STREAM_DRAW);
134
135 ctx.beginSection("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.");
136 ctx.glBufferSubData(GL_ARRAY_BUFFER, -1, 1, 0);
137 ctx.expectError(GL_INVALID_VALUE);
138 ctx.glBufferSubData(GL_ARRAY_BUFFER, -1, -1, 0);
139 ctx.expectError(GL_INVALID_VALUE);
140 ctx.glBufferSubData(GL_ARRAY_BUFFER, 1, -1, 0);
141 ctx.expectError(GL_INVALID_VALUE);
142 ctx.glBufferSubData(GL_ARRAY_BUFFER, 15, 1, 0);
143 ctx.expectError(GL_INVALID_VALUE);
144 ctx.glBufferSubData(GL_ARRAY_BUFFER, 1, 15, 0);
145 ctx.expectError(GL_INVALID_VALUE);
146 ctx.glBufferSubData(GL_ARRAY_BUFFER, 8, 8, 0);
147 ctx.expectError(GL_INVALID_VALUE);
148 ctx.endSection();
149
150 ctx.glDeleteBuffers(1, &buffer);
151 }
152
clear(NegativeTestContext & ctx)153 void clear (NegativeTestContext& ctx)
154 {
155 ctx.beginSection("GL_INVALID_VALUE is generated if any bit other than the three defined bits is set in mask.");
156 ctx.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
157 ctx.expectError(GL_NO_ERROR);
158 ctx.glClear(0x00000200);
159 ctx.expectError(GL_INVALID_VALUE);
160 ctx.glClear(0x00001000);
161 ctx.expectError(GL_INVALID_VALUE);
162 ctx.glClear(0x00000010);
163 ctx.expectError(GL_INVALID_VALUE);
164 ctx.endSection();
165 }
166
read_pixels(NegativeTestContext & ctx)167 void read_pixels (NegativeTestContext& ctx)
168 {
169 std::vector<GLubyte> ubyteData (4);
170 GLuint fbo = 0x1234;
171
172 ctx.beginSection("Unsupported combinations of format and type will generate an GL_INVALID_OPERATION error.");
173 ctx.glReadPixels(0, 0, 1, 1, GL_LUMINANCE_ALPHA, GL_UNSIGNED_SHORT_4_4_4_4, &ubyteData[0]);
174 ctx.expectError(GL_INVALID_OPERATION);
175 ctx.endSection();
176
177 ctx.beginSection("GL_INVALID_VALUE is generated if either width or height is negative.");
178 ctx.glReadPixels(0, 0, -1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]);
179 ctx.expectError(GL_INVALID_VALUE);
180 ctx.glReadPixels(0, 0, 1, -1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]);
181 ctx.expectError(GL_INVALID_VALUE);
182 ctx.glReadPixels(0, 0, -1, -1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]);
183 ctx.expectError(GL_INVALID_VALUE);
184 ctx.endSection();
185
186 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
187 ctx.glGenFramebuffers(1, &fbo);
188 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
189 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
190 ctx.glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]);
191 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
192 ctx.endSection();
193
194 ctx.glDeleteFramebuffers(1, &fbo);
195 }
196
readn_pixels(NegativeTestContext & ctx)197 void readn_pixels (NegativeTestContext& ctx)
198 {
199 std::vector<GLfloat> floatData (4);
200 std::vector<GLubyte> ubyteData (4);
201 GLuint fbo = 0x1234;
202
203 if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2))
204 && !contextSupports(ctx.getRenderContext().getType(), glu::ApiType::core(4, 5))
205 && !ctx.isExtensionSupported("GL_KHR_robustness")
206 && !ctx.isExtensionSupported("GL_EXT_robustness"))
207 {
208 TCU_THROW(NotSupportedError, "GLES 3.2 or robustness extension not supported");
209 }
210
211 ctx.beginSection("Unsupported combinations of format and type will generate an GL_INVALID_OPERATION error.");
212 ctx.glReadnPixels(0, 0, 1, 1, GL_LUMINANCE_ALPHA, GL_UNSIGNED_SHORT_4_4_4_4, (int)ubyteData.size(), &ubyteData[0]);
213 ctx.expectError(GL_INVALID_OPERATION);
214 ctx.endSection();
215
216 ctx.beginSection("GL_INVALID_VALUE is generated if either width or height is negative.");
217 ctx.glReadnPixels(0, 0, -1, 1, GL_RGBA, GL_UNSIGNED_BYTE, (int) ubyteData.size(), &ubyteData[0]);
218 ctx.expectError(GL_INVALID_VALUE);
219 ctx.glReadnPixels(0, 0, 1, -1, GL_RGBA, GL_UNSIGNED_BYTE, (int) ubyteData.size(), &ubyteData[0]);
220 ctx.expectError(GL_INVALID_VALUE);
221 ctx.glReadnPixels(0, 0, -1, -1, GL_RGBA, GL_UNSIGNED_BYTE, (int) ubyteData.size(), &ubyteData[0]);
222 ctx.expectError(GL_INVALID_VALUE);
223 ctx.endSection();
224
225 ctx.beginSection("GL_INVALID_OPERATION is generated by ReadnPixels if the buffer size required to store the requested data is larger than bufSize.");
226 ctx.glReadnPixels(0, 0, 0x1234, 0x1234, GL_RGBA, GL_UNSIGNED_BYTE, (int) ubyteData.size(), &ubyteData[0]);
227 ctx.expectError(GL_INVALID_OPERATION);
228 ctx.glReadnPixels(0, 0, 1, 1, GL_RGBA, GL_FLOAT, (int) floatData.size(), &floatData[0]);
229 ctx.expectError(GL_INVALID_OPERATION);
230 ctx.endSection();
231
232 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the currently bound framebuffer is not framebuffer complete.");
233 ctx.glGenFramebuffers(1, &fbo);
234 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
235 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
236 ctx.glReadnPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, (int) ubyteData.size(), &ubyteData[0]);
237 ctx.expectError(GL_INVALID_FRAMEBUFFER_OPERATION);
238 ctx.endSection();
239
240 ctx.glDeleteFramebuffers(1, &fbo);
241 }
242
read_pixels_format_mismatch(NegativeTestContext & ctx)243 void read_pixels_format_mismatch (NegativeTestContext& ctx)
244 {
245 std::vector<GLubyte> ubyteData (4);
246 std::vector<GLushort> ushortData (4);
247 GLint readFormat = 0x1234;
248 GLint readType = 0x1234;
249
250
251 ctx.beginSection("Unsupported combinations of format and type will generate an GL_INVALID_OPERATION error.");
252 ctx.glReadPixels(0, 0, 1, 1, GL_ALPHA, GL_UNSIGNED_SHORT_5_6_5, &ushortData[0]);
253 ctx.expectError(GL_INVALID_OPERATION);
254 ctx.glReadPixels(0, 0, 1, 1, GL_ALPHA, GL_UNSIGNED_SHORT_4_4_4_4, &ushortData[0]);
255 ctx.expectError(GL_INVALID_OPERATION);
256 ctx.glReadPixels(0, 0, 1, 1, GL_ALPHA, GL_UNSIGNED_SHORT_5_5_5_1, &ushortData[0]);
257 ctx.expectError(GL_INVALID_OPERATION);
258 ctx.endSection();
259
260 ctx.beginSection("Unsupported combinations of format and type will generate an GL_INVALID_OPERATION error.");
261 ctx.glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_SHORT_5_6_5, &ushortData[0]);
262 ctx.expectError(GL_INVALID_OPERATION);
263 ctx.glReadPixels(0, 0, 1, 1, GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, &ushortData[0]);
264 ctx.expectError(GL_INVALID_OPERATION);
265 ctx.glReadPixels(0, 0, 1, 1, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, &ushortData[0]);
266 ctx.expectError(GL_INVALID_OPERATION);
267 ctx.endSection();
268
269 ctx.beginSection("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.");
270 ctx.glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]);
271 ctx.expectError(GL_NO_ERROR);
272 ctx.glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &readFormat);
273 ctx.glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &readType);
274 ctx.glReadPixels(0, 0, 1, 1, readFormat, readType, &ubyteData[0]);
275 ctx.expectError(GL_NO_ERROR);
276 ctx.endSection();
277 }
278
read_pixels_fbo_format_mismatch(NegativeTestContext & ctx)279 void read_pixels_fbo_format_mismatch (NegativeTestContext& ctx)
280 {
281 std::vector<GLubyte> ubyteData(4);
282 std::vector<float> floatData(4);
283 deUint32 fbo = 0x1234;
284 deUint32 texture = 0x1234;
285 bool isES = glu::isContextTypeES(ctx.getRenderContext().getType());
286
287 ctx.glGenTextures (1, &texture);
288 ctx.glBindTexture (GL_TEXTURE_2D, texture);
289 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
290 ctx.glGenFramebuffers (1, &fbo);
291 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo);
292 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
293 ctx.expectError (GL_NO_ERROR);
294
295 ctx.beginSection("GL_INVALID_OPERATION is generated if currently bound framebuffer format is incompatible with format and type.");
296
297 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
298 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
299 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
300 ctx.expectError (GL_NO_ERROR);
301 ctx.glReadPixels (0, 0, 1, 1, GL_RGBA, GL_FLOAT, &floatData[0]);
302 ctx.expectError (isES ? GL_INVALID_OPERATION : GL_NO_ERROR);
303
304 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32I, 32, 32, 0, GL_RGBA_INTEGER, GL_INT, NULL);
305 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
306 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
307 ctx.expectError (GL_NO_ERROR);
308 ctx.glReadPixels (0, 0, 1, 1, GL_RGBA, GL_FLOAT, &floatData[0]);
309 ctx.expectError (GL_INVALID_OPERATION);
310
311 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32UI, 32, 32, 0, GL_RGBA_INTEGER, GL_UNSIGNED_INT, NULL);
312 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
313 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
314 ctx.expectError (GL_NO_ERROR);
315 ctx.glReadPixels (0, 0, 1, 1, GL_RGBA, GL_FLOAT, &floatData[0]);
316 ctx.expectError (GL_INVALID_OPERATION);
317
318 if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
319 ctx.isExtensionSupported("GL_EXT_color_buffer_float"))
320 {
321 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32F, 32, 32, 0, GL_RGBA, GL_FLOAT, NULL);
322 ctx.expectError (GL_NO_ERROR);
323 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
324 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
325 ctx.expectError (GL_NO_ERROR);
326 ctx.glReadPixels (0, 0, 1, 1, GL_RGBA, GL_INT, &floatData[0]);
327 ctx.expectError (GL_INVALID_OPERATION);
328 }
329
330 ctx.endSection();
331
332 ctx.beginSection("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.");
333
334 int binding = -1;
335 int sampleBuffers = 0x1234;
336 deUint32 rbo = 0x1234;
337
338 ctx.glGenRenderbuffers(1, &rbo);
339 ctx.glBindRenderbuffer(GL_RENDERBUFFER, rbo);
340 ctx.glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_RGBA8, 32, 32);
341 ctx.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo);
342
343 ctx.glGetIntegerv (GL_READ_FRAMEBUFFER_BINDING, &binding);
344 ctx.getLog() << TestLog::Message << "// GL_READ_FRAMEBUFFER_BINDING: " << binding << TestLog::EndMessage;
345 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
346 ctx.glGetIntegerv (GL_SAMPLE_BUFFERS, &sampleBuffers);
347 ctx.getLog() << TestLog::Message << "// GL_SAMPLE_BUFFERS: " << sampleBuffers << TestLog::EndMessage;
348 ctx.expectError (GL_NO_ERROR);
349
350 if (binding == 0 || sampleBuffers <= 0)
351 {
352 ctx.getLog() << TestLog::Message << "// ERROR: expected GL_READ_FRAMEBUFFER_BINDING to be non-zero and GL_SAMPLE_BUFFERS to be greater than zero" << TestLog::EndMessage;
353 ctx.fail("Got invalid value");
354 }
355 else
356 {
357 ctx.glReadPixels (0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &ubyteData[0]);
358 ctx.expectError (GL_INVALID_OPERATION);
359 }
360
361 ctx.endSection();
362
363 ctx.glBindRenderbuffer (GL_RENDERBUFFER, 0);
364 ctx.glBindTexture (GL_TEXTURE_2D, 0);
365 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0);
366 ctx.glDeleteFramebuffers (1, &fbo);
367 ctx.glDeleteTextures (1, &texture);
368 ctx.glDeleteRenderbuffers (1, &rbo);
369 }
370
bind_buffer_range(NegativeTestContext & ctx)371 void bind_buffer_range (NegativeTestContext& ctx)
372 {
373 deUint32 bufAC = 0x1234;
374 deUint32 bufU = 0x1234;
375 deUint32 bufTF = 0x1234;
376 int maxTFSize = 0x1234;
377 int maxUSize = 0x1234;
378 int uAlignment = 0x1234;
379
380 ctx.glGenBuffers(1, &bufU);
381 ctx.glBindBuffer(GL_UNIFORM_BUFFER, bufU);
382 ctx.glBufferData(GL_UNIFORM_BUFFER, 16, NULL, GL_STREAM_DRAW);
383
384 ctx.glGenBuffers(1, &bufTF);
385 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, bufTF);
386 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_STREAM_DRAW);
387
388 ctx.glGenBuffers(1, &bufAC);
389 ctx.glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, bufAC);
390 ctx.glBufferData(GL_ATOMIC_COUNTER_BUFFER, 16, NULL, GL_STREAM_DRAW);
391
392 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_ATOMIC_COUNTER_BUFFER, GL_SHADER_STORAGE_BUFFER, GL_TRANSFORM_FEEDBACK_BUFFER or GL_UNIFORM_BUFFER.");
393 ctx.glBindBufferRange(GL_ARRAY_BUFFER, 0, bufU, 0, 4);
394 ctx.expectError(GL_INVALID_ENUM);
395 ctx.endSection();
396
397 ctx.beginSection("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.");
398 ctx.glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxTFSize);
399 ctx.glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, maxTFSize, bufTF, 0, 4);
400 ctx.expectError(GL_INVALID_VALUE);
401 ctx.endSection();
402
403 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_UNIFORM_BUFFER and index is greater than or equal to GL_MAX_UNIFORM_BUFFER_BINDINGS.");
404 ctx.glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUSize);
405 ctx.glBindBufferRange(GL_UNIFORM_BUFFER, maxUSize, bufU, 0, 4);
406 ctx.expectError(GL_INVALID_VALUE);
407 ctx.endSection();
408
409 ctx.beginSection("GL_INVALID_VALUE is generated if size is less than or equal to zero.");
410 ctx.glBindBufferRange(GL_UNIFORM_BUFFER, 0, bufU, 0, -1);
411 ctx.expectError(GL_INVALID_VALUE);
412 ctx.glBindBufferRange(GL_UNIFORM_BUFFER, 0, bufU, 0, 0);
413 ctx.expectError(GL_INVALID_VALUE);
414 ctx.endSection();
415
416 ctx.beginSection("GL_INVALID_VALUE is generated if offset is less than zero.");
417 ctx.glBindBufferRange(GL_UNIFORM_BUFFER, 0, bufU, -1, 0);
418 ctx.expectError(GL_INVALID_VALUE);
419 ctx.endSection();
420
421 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_TRANSFORM_FEEDBACK_BUFFER and size or offset are not multiples of 4.");
422 ctx.glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufTF, 4, 5);
423 ctx.expectError(GL_INVALID_VALUE);
424 ctx.glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufTF, 5, 4);
425 ctx.expectError(GL_INVALID_VALUE);
426 ctx.glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufTF, 5, 7);
427 ctx.expectError(GL_INVALID_VALUE);
428 ctx.endSection();
429
430 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_UNIFORM_BUFFER and offset is not a multiple of GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT.");
431 ctx.glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &uAlignment);
432 ctx.glBindBufferRange(GL_UNIFORM_BUFFER, 0, bufU, uAlignment+1, 4);
433 ctx.expectError(GL_INVALID_VALUE);
434 ctx.endSection();
435
436 int maxACize = 0x1234;
437 int maxSSize = 0x1234;
438 int ssAlignment = 0x1234;
439
440 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_ATOMIC_COUNTER_BUFFER and index is greater than or equal to GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS.");
441 ctx.glGetIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, &maxACize);
442 ctx.glBindBufferRange(GL_ATOMIC_COUNTER_BUFFER, maxACize, bufU, 0, 4);
443 ctx.expectError(GL_INVALID_VALUE);
444 ctx.endSection();
445
446 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_SHADER_STORAGE_BUFFER and index is greater than or equal to GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS.");
447 ctx.glGetIntegerv(GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, &maxSSize);
448 ctx.glBindBufferRange(GL_SHADER_STORAGE_BUFFER, maxSSize, bufU, 0, 4);
449 ctx.expectError(GL_INVALID_VALUE);
450 ctx.endSection();
451
452 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_ATOMIC_COUNTER_BUFFER and offset is not multiples of 4.");
453 ctx.glBindBufferRange(GL_ATOMIC_COUNTER_BUFFER, 0, bufTF, 5, 4);
454 ctx.expectError(GL_INVALID_VALUE);
455 ctx.endSection();
456
457 ctx.glGetIntegerv(GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT, &ssAlignment);
458
459 if (ssAlignment != 1)
460 {
461 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_SHADER_STORAGE_BUFFER and offset is not a multiple of the value of GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT.");
462 ctx.glBindBufferRange(GL_SHADER_STORAGE_BUFFER, 0, bufTF, ssAlignment+1, 4);
463 ctx.expectError(GL_INVALID_VALUE);
464 ctx.endSection();
465 }
466
467 ctx.glDeleteBuffers(1, &bufU);
468 ctx.glDeleteBuffers(1, &bufTF);
469 ctx.glDeleteBuffers(1, &bufAC);
470 }
471
bind_buffer_base(NegativeTestContext & ctx)472 void bind_buffer_base (NegativeTestContext& ctx)
473 {
474 deUint32 bufU = 0x1234;
475 deUint32 bufTF = 0x1234;
476 int maxUSize = 0x1234;
477 int maxTFSize = 0x1234;
478
479 ctx.glGenBuffers(1, &bufU);
480 ctx.glBindBuffer(GL_UNIFORM_BUFFER, bufU);
481 ctx.glBufferData(GL_UNIFORM_BUFFER, 16, NULL, GL_STREAM_DRAW);
482
483 ctx.glGenBuffers(1, &bufTF);
484 ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, bufTF);
485 ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_STREAM_DRAW);
486 ctx.expectError(GL_NO_ERROR);
487
488 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_ATOMIC_COUNTER_BUFFER, GL_SHADER_STORAGE_BUFFER, GL_TRANSFORM_FEEDBACK_BUFFER or GL_UNIFORM_BUFFER.");
489 ctx.glBindBufferBase(-1, 0, bufU);
490 ctx.expectError(GL_INVALID_ENUM);
491 ctx.glBindBufferBase(GL_ARRAY_BUFFER, 0, bufU);
492 ctx.expectError(GL_INVALID_ENUM);
493 ctx.endSection();
494
495 ctx.beginSection("GL_INVALID_VALUE is generated if target is GL_UNIFORM_BUFFER and index is greater than or equal to GL_MAX_UNIFORM_BUFFER_BINDINGS.");
496 ctx.glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUSize);
497 ctx.glBindBufferBase(GL_UNIFORM_BUFFER, maxUSize, bufU);
498 ctx.expectError(GL_INVALID_VALUE);
499 ctx.endSection();
500
501 ctx.beginSection("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.");
502 ctx.glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxTFSize);
503 ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, maxTFSize, bufTF);
504 ctx.expectError(GL_INVALID_VALUE);
505 ctx.endSection();
506
507 ctx.glDeleteBuffers(1, &bufU);
508 ctx.glDeleteBuffers(1, &bufTF);
509 }
510
clear_bufferiv(NegativeTestContext & ctx)511 void clear_bufferiv (NegativeTestContext& ctx)
512 {
513 std::vector<int> data (32*32);
514 deUint32 fbo = 0x1234;
515 deUint32 texture = 0x1234;
516 int maxDrawBuffers = 0x1234;
517
518 ctx.glGenTextures (1, &texture);
519 ctx.glBindTexture (GL_TEXTURE_2D, texture);
520 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32I, 32, 32, 0, GL_RGBA_INTEGER, GL_INT, NULL);
521 ctx.glGenFramebuffers (1, &fbo);
522 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo);
523 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
524 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
525 ctx.expectError (GL_NO_ERROR);
526
527 ctx.beginSection("GL_INVALID_ENUM is generated if buffer is not an accepted value.");
528 ctx.glClearBufferiv (-1, 0, &data[0]);
529 ctx.expectError (GL_INVALID_ENUM);
530 ctx.glClearBufferiv (GL_FRAMEBUFFER, 0, &data[0]);
531 ctx.expectError (GL_INVALID_ENUM);
532 ctx.endSection();
533
534 ctx.beginSection("GL_INVALID_ENUM is generated if buffer is GL_DEPTH or GL_DEPTH_STENCIL.");
535 ctx.glClearBufferiv (GL_DEPTH, 1, &data[0]);
536 ctx.expectError (GL_INVALID_ENUM);
537 ctx.glClearBufferiv (GL_DEPTH_STENCIL, 1, &data[0]);
538 ctx.expectError (GL_INVALID_ENUM);
539 ctx.endSection();
540
541 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_COLOR or GL_STENCIL and drawBuffer is greater than or equal to GL_MAX_DRAW_BUFFERS.");
542 ctx.glGetIntegerv (GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
543 ctx.glClearBufferiv (GL_COLOR, maxDrawBuffers, &data[0]);
544 ctx.expectError (GL_INVALID_VALUE);
545 ctx.endSection();
546
547 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_COLOR or GL_STENCIL and drawBuffer is negative.");
548 ctx.glClearBufferiv (GL_COLOR, -1, &data[0]);
549 ctx.expectError (GL_INVALID_VALUE);
550 ctx.endSection();
551
552 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_STENCIL and drawBuffer is not zero.");
553 ctx.glClearBufferiv (GL_STENCIL, 1, &data[0]);
554 ctx.expectError (GL_INVALID_VALUE);
555 ctx.endSection();
556
557 ctx.glDeleteFramebuffers (1, &fbo);
558 ctx.glDeleteTextures (1, &texture);
559 }
560
clear_bufferuiv(NegativeTestContext & ctx)561 void clear_bufferuiv (NegativeTestContext& ctx)
562 {
563 std::vector<deUint32> data (32*32);
564 deUint32 fbo = 0x1234;
565 deUint32 texture = 0x1234;
566 int maxDrawBuffers = 0x1234;
567
568 ctx.glGenTextures (1, &texture);
569 ctx.glBindTexture (GL_TEXTURE_2D, texture);
570 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32UI, 32, 32, 0, GL_RGBA_INTEGER, GL_UNSIGNED_INT, NULL);
571 ctx.glGenFramebuffers (1, &fbo);
572 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo);
573 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
574 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
575 ctx.expectError (GL_NO_ERROR);
576
577 ctx.beginSection("GL_INVALID_ENUM is generated if buffer is not GL_COLOR.");
578 ctx.glClearBufferuiv (-1, 0, &data[0]);
579 ctx.expectError (GL_INVALID_ENUM);
580 ctx.glClearBufferuiv (GL_FRAMEBUFFER, 0, &data[0]);
581 ctx.expectError (GL_INVALID_ENUM);
582 ctx.endSection();
583
584 ctx.beginSection("GL_INVALID_ENUM is generated if buffer is GL_DEPTH, GL_STENCIL, or GL_DEPTH_STENCIL.");
585 ctx.glClearBufferuiv (GL_DEPTH, 0, &data[0]);
586 ctx.expectError (GL_INVALID_ENUM);
587 ctx.glClearBufferuiv (GL_STENCIL, 0, &data[0]);
588 ctx.expectError (GL_INVALID_ENUM);
589 ctx.glClearBufferuiv (GL_DEPTH_STENCIL, 0, &data[0]);
590 ctx.expectError (GL_INVALID_ENUM);
591 ctx.endSection();
592
593 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_COLOR and drawBuffer is greater than or equal to GL_MAX_DRAW_BUFFERS.");
594 ctx.glGetIntegerv (GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
595 ctx.glClearBufferuiv (GL_COLOR, maxDrawBuffers, &data[0]);
596 ctx.expectError (GL_INVALID_VALUE);
597 ctx.endSection();
598
599 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_COLOR and drawBuffer is negative.");
600 ctx.glClearBufferuiv (GL_COLOR, -1, &data[0]);
601 ctx.expectError (GL_INVALID_VALUE);
602 ctx.endSection();
603
604 ctx.glDeleteFramebuffers (1, &fbo);
605 ctx.glDeleteTextures (1, &texture);
606 }
607
clear_bufferfv(NegativeTestContext & ctx)608 void clear_bufferfv (NegativeTestContext& ctx)
609 {
610 std::vector<float> data (32*32);
611 deUint32 fbo = 0x1234;
612 deUint32 texture = 0x1234;
613 int maxDrawBuffers = 0x1234;
614
615 ctx.glGenTextures (1, &texture);
616 ctx.glBindTexture (GL_TEXTURE_2D, texture);
617 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32F, 32, 32, 0, GL_RGBA, GL_FLOAT, NULL);
618 ctx.glGenFramebuffers (1, &fbo);
619 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo);
620 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
621 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
622 ctx.expectError (GL_NO_ERROR);
623
624 ctx.beginSection("GL_INVALID_ENUM is generated if buffer is not GL_COLOR or GL_DEPTH.");
625 ctx.glClearBufferfv (-1, 0, &data[0]);
626 ctx.expectError (GL_INVALID_ENUM);
627 ctx.glClearBufferfv (GL_FRAMEBUFFER, 0, &data[0]);
628 ctx.expectError (GL_INVALID_ENUM);
629 ctx.endSection();
630
631 ctx.beginSection("GL_INVALID_ENUM is generated if buffer is GL_STENCIL or GL_DEPTH_STENCIL.");
632 ctx.glClearBufferfv (GL_STENCIL, 1, &data[0]);
633 ctx.expectError (GL_INVALID_ENUM);
634 ctx.glClearBufferfv (GL_DEPTH_STENCIL, 1, &data[0]);
635 ctx.expectError (GL_INVALID_ENUM);
636 ctx.endSection();
637
638 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_COLOR and drawBuffer is greater than or equal to GL_MAX_DRAW_BUFFERS.");
639 ctx.glGetIntegerv (GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
640 ctx.glClearBufferfv (GL_COLOR, maxDrawBuffers, &data[0]);
641 ctx.expectError (GL_INVALID_VALUE);
642 ctx.endSection();
643
644 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_COLOR and drawBuffer is negative.");
645 ctx.glClearBufferfv (GL_COLOR, -1, &data[0]);
646 ctx.expectError (GL_INVALID_VALUE);
647 ctx.endSection();
648
649 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_DEPTH and drawBuffer is not zero.");
650 ctx.glClearBufferfv (GL_DEPTH, 1, &data[0]);
651 ctx.expectError (GL_INVALID_VALUE);
652 ctx.endSection();
653
654 ctx.glDeleteFramebuffers (1, &fbo);
655 ctx.glDeleteTextures (1, &texture);
656 }
657
clear_bufferfi(NegativeTestContext & ctx)658 void clear_bufferfi (NegativeTestContext& ctx)
659 {
660 ctx.beginSection("GL_INVALID_ENUM is generated if buffer is not GL_DEPTH_STENCIL.");
661 ctx.glClearBufferfi (-1, 0, 1.0f, 1);
662 ctx.expectError (GL_INVALID_ENUM);
663 ctx.glClearBufferfi (GL_FRAMEBUFFER, 0, 1.0f, 1);
664 ctx.expectError (GL_INVALID_ENUM);
665 ctx.glClearBufferfi (GL_DEPTH, 0, 1.0f, 1);
666 ctx.expectError (GL_INVALID_ENUM);
667 ctx.glClearBufferfi (GL_STENCIL, 0, 1.0f, 1);
668 ctx.expectError (GL_INVALID_ENUM);
669 ctx.glClearBufferfi (GL_COLOR, 0, 1.0f, 1);
670 ctx.expectError (GL_INVALID_ENUM);
671 ctx.endSection();
672
673 ctx.beginSection("GL_INVALID_VALUE is generated if buffer is GL_DEPTH_STENCIL and drawBuffer is not zero.");
674 ctx.glClearBufferfi (GL_DEPTH_STENCIL, 1, 1.0f, 1);
675 ctx.expectError (GL_INVALID_VALUE);
676 ctx.endSection();
677 }
678
copy_buffer_sub_data(NegativeTestContext & ctx)679 void copy_buffer_sub_data (NegativeTestContext& ctx)
680 {
681 deUint32 buf[2];
682 std::vector<float> data (32*32);
683
684 ctx.glGenBuffers (2, buf);
685 ctx.glBindBuffer (GL_COPY_READ_BUFFER, buf[0]);
686 ctx.glBufferData (GL_COPY_READ_BUFFER, 32, &data[0], GL_DYNAMIC_COPY);
687 ctx.glBindBuffer (GL_COPY_WRITE_BUFFER, buf[1]);
688 ctx.glBufferData (GL_COPY_WRITE_BUFFER, 32, &data[0], GL_DYNAMIC_COPY);
689 ctx.expectError (GL_NO_ERROR);
690
691 ctx.beginSection("GL_INVALID_VALUE is generated if any of readoffset, writeoffset or size is negative.");
692 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, -4);
693 ctx.expectError (GL_INVALID_VALUE);
694 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, -1, 0, 4);
695 ctx.expectError (GL_INVALID_VALUE);
696 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, -1, 4);
697 ctx.expectError (GL_INVALID_VALUE);
698 ctx.endSection();
699
700 ctx.beginSection("GL_INVALID_VALUE is generated if readoffset + size exceeds the size of the buffer object bound to readtarget.");
701 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 36);
702 ctx.expectError (GL_INVALID_VALUE);
703 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 24, 0, 16);
704 ctx.expectError (GL_INVALID_VALUE);
705 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 36, 0, 4);
706 ctx.expectError (GL_INVALID_VALUE);
707 ctx.endSection();
708
709 ctx.beginSection("GL_INVALID_VALUE is generated if writeoffset + size exceeds the size of the buffer object bound to writetarget.");
710 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 36);
711 ctx.expectError (GL_INVALID_VALUE);
712 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 24, 16);
713 ctx.expectError (GL_INVALID_VALUE);
714 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 36, 4);
715 ctx.expectError (GL_INVALID_VALUE);
716 ctx.endSection();
717
718 ctx.beginSection("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.");
719 ctx.glBindBuffer (GL_COPY_WRITE_BUFFER, buf[0]);
720 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 16, 4);
721 ctx.expectError (GL_NO_ERROR);
722 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 4);
723 ctx.expectError (GL_INVALID_VALUE);
724 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 16, 18);
725 ctx.expectError (GL_INVALID_VALUE);
726 ctx.glBindBuffer (GL_COPY_WRITE_BUFFER, buf[1]);
727 ctx.endSection();
728
729 ctx.beginSection("GL_INVALID_OPERATION is generated if zero is bound to readtarget or writetarget.");
730 ctx.glBindBuffer (GL_COPY_READ_BUFFER, 0);
731 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 16);
732 ctx.expectError (GL_INVALID_OPERATION);
733
734 ctx.glBindBuffer (GL_COPY_READ_BUFFER, buf[0]);
735 ctx.glBindBuffer (GL_COPY_WRITE_BUFFER, 0);
736 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 16);
737 ctx.expectError (GL_INVALID_OPERATION);
738
739 ctx.glBindBuffer (GL_COPY_WRITE_BUFFER, buf[1]);
740 ctx.endSection();
741
742 ctx.beginSection("GL_INVALID_OPERATION is generated if the buffer object bound to either readtarget or writetarget is mapped.");
743 ctx.glMapBufferRange (GL_COPY_READ_BUFFER, 0, 4, GL_MAP_READ_BIT);
744 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 16);
745 ctx.expectError (GL_INVALID_OPERATION);
746 ctx.glUnmapBuffer (GL_COPY_READ_BUFFER);
747
748 ctx.glMapBufferRange (GL_COPY_WRITE_BUFFER, 0, 4, GL_MAP_READ_BIT);
749 ctx.glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 16);
750 ctx.expectError (GL_INVALID_OPERATION);
751 ctx.glUnmapBuffer (GL_COPY_WRITE_BUFFER);
752 ctx.endSection();
753
754 ctx.glDeleteBuffers(2, buf);
755 }
756
draw_buffers(NegativeTestContext & ctx)757 void draw_buffers (NegativeTestContext& ctx)
758 {
759 deUint32 fbo = 0x1234;
760 deUint32 texture = 0x1234;
761 int maxDrawBuffers = 0x1234;
762 int maxColorAttachments = -1;
763 ctx.glGetIntegerv (GL_MAX_COLOR_ATTACHMENTS, &maxColorAttachments);
764 ctx.glGetIntegerv (GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
765 std::vector<deUint32> values (maxDrawBuffers+1);
766 std::vector<deUint32> attachments (4);
767 std::vector<GLfloat> data (32*32);
768 bool isES = glu::isContextTypeES(ctx.getRenderContext().getType());
769 values[0] = GL_NONE;
770 values[1] = GL_BACK;
771 values[2] = GL_COLOR_ATTACHMENT0;
772 values[3] = GL_DEPTH_ATTACHMENT;
773 attachments[0] = (glw::GLenum) (GL_COLOR_ATTACHMENT0 + maxColorAttachments);
774 attachments[1] = GL_COLOR_ATTACHMENT0;
775 attachments[2] = GL_COLOR_ATTACHMENT1;
776 attachments[3] = GL_NONE;
777
778 ctx.glGenTextures (1, &texture);
779 ctx.glBindTexture (GL_TEXTURE_2D, texture);
780 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
781 ctx.glGenFramebuffers (1, &fbo);
782 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo);
783 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
784 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
785 ctx.expectError (GL_NO_ERROR);
786
787 ctx.beginSection("GL_INVALID_ENUM is generated if one of the values in bufs is not an accepted value.");
788 ctx.glDrawBuffers (2, &values[2]);
789 ctx.expectError (GL_INVALID_ENUM);
790 ctx.endSection();
791
792 ctx.beginSection("GL_INVALID_OPERATION is generated if the GL is bound to a draw framebuffer and DrawBuffers is supplied with BACK or COLOR_ATTACHMENTm where m is greater than or equal to the value of MAX_COLOR_ATTACHMENTS.");
793 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo);
794 ctx.glDrawBuffers (1, &values[1]);
795 ctx.expectError (isES ? GL_INVALID_OPERATION : GL_INVALID_ENUM);
796 ctx.glDrawBuffers (4, &attachments[0]);
797 ctx.expectError (GL_INVALID_OPERATION);
798 ctx.endSection();
799
800 ctx.beginSection("GL_INVALID_OPERATION is generated if the GL is bound to the default framebuffer and n is not 1.");
801 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0);
802 ctx.glDrawBuffers (2, &values[0]);
803 ctx.expectError (GL_INVALID_OPERATION);
804 ctx.endSection();
805
806 ctx.beginSection("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.");
807 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0);
808 ctx.glDrawBuffers (1, &values[2]);
809 ctx.expectError (GL_INVALID_OPERATION);
810 ctx.endSection();
811
812 ctx.beginSection("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.");
813 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo);
814 ctx.glDrawBuffers (1, &values[1]);
815 ctx.expectError (isES ? GL_INVALID_OPERATION : GL_INVALID_ENUM);
816 ctx.glDrawBuffers (4, &attachments[0]);
817 ctx.expectError (GL_INVALID_OPERATION);
818
819 ctx.endSection();
820
821 ctx.beginSection("GL_INVALID_VALUE is generated if n is less than 0 or greater than GL_MAX_DRAW_BUFFERS.");
822 ctx.glDrawBuffers (-1, &values[1]);
823 ctx.expectError (GL_INVALID_VALUE);
824 ctx.glDrawBuffers (maxDrawBuffers+1, &values[0]);
825 ctx.expectError (GL_INVALID_VALUE);
826 ctx.endSection();
827
828 ctx.glDeleteTextures(1, &texture);
829 ctx.glDeleteFramebuffers(1, &fbo);
830 }
831
flush_mapped_buffer_range(NegativeTestContext & ctx)832 void flush_mapped_buffer_range (NegativeTestContext& ctx)
833 {
834 deUint32 buf = 0x1234;
835 std::vector<GLfloat> data (32);
836
837 ctx.glGenBuffers (1, &buf);
838 ctx.glBindBuffer (GL_ARRAY_BUFFER, buf);
839 ctx.glBufferData (GL_ARRAY_BUFFER, 32, &data[0], GL_STATIC_READ);
840 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
841 ctx.expectError (GL_NO_ERROR);
842
843 ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the accepted values.");
844 ctx.glFlushMappedBufferRange(-1, 0, 16);
845 ctx.expectError (GL_INVALID_ENUM);
846 ctx.endSection();
847
848 ctx.beginSection("GL_INVALID_VALUE is generated if offset or length is negative, or if offset + length exceeds the size of the mapping.");
849 ctx.glFlushMappedBufferRange(GL_ARRAY_BUFFER, -1, 1);
850 ctx.expectError (GL_INVALID_VALUE);
851 ctx.glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, -1);
852 ctx.expectError (GL_INVALID_VALUE);
853 ctx.glFlushMappedBufferRange(GL_ARRAY_BUFFER, 12, 8);
854 ctx.expectError (GL_INVALID_VALUE);
855 ctx.glFlushMappedBufferRange(GL_ARRAY_BUFFER, 24, 4);
856 ctx.expectError (GL_INVALID_VALUE);
857 ctx.glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 24);
858 ctx.expectError (GL_INVALID_VALUE);
859 ctx.endSection();
860
861 ctx.beginSection("GL_INVALID_OPERATION is generated if zero is bound to target.");
862 ctx.glBindBuffer (GL_ARRAY_BUFFER, 0);
863 ctx.glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 8);
864 ctx.expectError (GL_INVALID_OPERATION);
865 ctx.endSection();
866
867 ctx.beginSection("GL_INVALID_OPERATION is generated if the buffer bound to target is not mapped, or is mapped without the GL_MAP_FLUSH_EXPLICIT flag.");
868 ctx.glBindBuffer (GL_ARRAY_BUFFER, buf);
869 ctx.glUnmapBuffer (GL_ARRAY_BUFFER);
870 ctx.glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 8);
871 ctx.expectError (GL_INVALID_OPERATION);
872 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_WRITE_BIT);
873 ctx.glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 8);
874 ctx.expectError (GL_INVALID_OPERATION);
875 ctx.endSection();
876
877 ctx.glUnmapBuffer (GL_ARRAY_BUFFER);
878 ctx.glDeleteBuffers (1, &buf);
879 }
880
map_buffer_range(NegativeTestContext & ctx)881 void map_buffer_range (NegativeTestContext& ctx)
882 {
883 deUint32 buf = 0x1234;
884 std::vector<GLfloat> data (32);
885
886 ctx.glGenBuffers (1, &buf);
887 ctx.glBindBuffer (GL_ARRAY_BUFFER, buf);
888 ctx.glBufferData (GL_ARRAY_BUFFER, 32, &data[0], GL_DYNAMIC_COPY);
889 ctx.expectError (GL_NO_ERROR);
890
891 ctx.beginSection("GL_INVALID_VALUE is generated if either of offset or length is negative.");
892 ctx.glMapBufferRange (GL_ARRAY_BUFFER, -1, 1, GL_MAP_READ_BIT);
893 ctx.expectError (GL_INVALID_VALUE);
894
895 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 1, -1, GL_MAP_READ_BIT);
896 ctx.expectError (GL_INVALID_VALUE);
897 ctx.endSection();
898
899 ctx.beginSection("GL_INVALID_VALUE is generated if offset + length is greater than the value of GL_BUFFER_SIZE.");
900 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 33, GL_MAP_READ_BIT);
901 ctx.expectError (GL_INVALID_VALUE);
902
903 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 32, 1, GL_MAP_READ_BIT);
904 ctx.expectError (GL_INVALID_VALUE);
905
906 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 16, 17, GL_MAP_READ_BIT);
907 ctx.expectError (GL_INVALID_VALUE);
908 ctx.endSection();
909
910 ctx.beginSection("GL_INVALID_VALUE is generated if access has any bits set other than those accepted.");
911 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | 0x1000);
912 ctx.expectError (GL_INVALID_VALUE);
913
914 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_WRITE_BIT | 0x1000);
915 ctx.expectError (GL_INVALID_VALUE);
916 ctx.endSection();
917
918 ctx.beginSection("GL_INVALID_OPERATION is generated if the buffer is already in a mapped state.");
919 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_WRITE_BIT);
920 ctx.expectError (GL_NO_ERROR);
921 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 16, 8, GL_MAP_READ_BIT);
922 ctx.expectError (GL_INVALID_OPERATION);
923 ctx.glUnmapBuffer (GL_ARRAY_BUFFER);
924 ctx.endSection();
925
926 ctx.beginSection("GL_INVALID_OPERATION is generated if neither GL_MAP_READ_BIT or GL_MAP_WRITE_BIT is set.");
927 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_INVALIDATE_RANGE_BIT);
928 ctx.expectError (GL_INVALID_OPERATION);
929 ctx.endSection();
930
931 ctx.beginSection("GL_INVALID_OPERATION is generated if length is 0");
932 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 0, GL_MAP_READ_BIT);
933 ctx.expectError (GL_INVALID_OPERATION);
934 ctx.endSection();
935
936 ctx.beginSection("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.");
937 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | GL_MAP_INVALIDATE_RANGE_BIT);
938 ctx.expectError (GL_INVALID_OPERATION);
939
940 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
941 ctx.expectError (GL_INVALID_OPERATION);
942
943 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
944 ctx.expectError (GL_INVALID_OPERATION);
945 ctx.endSection();
946
947 ctx.beginSection("GL_INVALID_OPERATION is generated if GL_MAP_FLUSH_EXPLICIT_BIT is set and GL_MAP_WRITE_BIT is not set.");
948 ctx.glMapBufferRange (GL_ARRAY_BUFFER, 0, 16, GL_MAP_READ_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
949 ctx.expectError (GL_INVALID_OPERATION);
950 ctx.endSection();
951
952 ctx.glDeleteBuffers (1, &buf);
953 }
954
read_buffer(NegativeTestContext & ctx)955 void read_buffer (NegativeTestContext& ctx)
956 {
957 deUint32 fbo = 0x1234;
958 deUint32 texture = 0x1234;
959 int maxColorAttachments = 0x1234;
960 bool isES = glu::isContextTypeES(ctx.getRenderContext().getType());
961
962 ctx.glGetIntegerv (GL_MAX_COLOR_ATTACHMENTS, &maxColorAttachments);
963 ctx.glGenTextures (1, &texture);
964 ctx.glBindTexture (GL_TEXTURE_2D, texture);
965 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
966 ctx.glGenFramebuffers (1, &fbo);
967 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo);
968 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
969 ctx.glCheckFramebufferStatus(GL_FRAMEBUFFER);
970 ctx.expectError (GL_NO_ERROR);
971
972 ctx.beginSection("GL_INVALID_ENUM is generated if mode is not GL_BACK, GL_NONE, or GL_COLOR_ATTACHMENTi.");
973 ctx.glReadBuffer (GL_NONE);
974 ctx.expectError (GL_NO_ERROR);
975 ctx.glReadBuffer (1);
976 ctx.expectError (GL_INVALID_ENUM);
977 ctx.glReadBuffer (GL_FRAMEBUFFER);
978 ctx.expectError (GL_INVALID_ENUM);
979 ctx.glReadBuffer (GL_COLOR_ATTACHMENT0 - 1);
980 ctx.expectError (GL_INVALID_ENUM);
981 ctx.glReadBuffer (GL_FRONT);
982 ctx.expectError (isES ? GL_INVALID_ENUM : GL_INVALID_OPERATION);
983
984 // \ note Spec isn't actually clear here, but it is safe to assume that
985 // GL_DEPTH_ATTACHMENT can't be interpreted as GL_COLOR_ATTACHMENTm
986 // where m = (GL_DEPTH_ATTACHMENT - GL_COLOR_ATTACHMENT0).
987 ctx.glReadBuffer (GL_DEPTH_ATTACHMENT);
988 ctx.expectError (GL_INVALID_ENUM);
989 ctx.glReadBuffer (GL_STENCIL_ATTACHMENT);
990 ctx.expectError (GL_INVALID_ENUM);
991 ctx.glReadBuffer (GL_STENCIL_ATTACHMENT+1);
992 ctx.expectError (GL_INVALID_ENUM);
993 ctx.glReadBuffer (0xffffffffu);
994 ctx.expectError (GL_INVALID_ENUM);
995 ctx.endSection();
996
997 ctx.beginSection("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.");
998 ctx.glReadBuffer (GL_BACK);
999 ctx.expectError (GL_INVALID_OPERATION);
1000 ctx.glReadBuffer (GL_COLOR_ATTACHMENT0 + maxColorAttachments);
1001 ctx.expectError (GL_INVALID_OPERATION);
1002
1003 if (GL_COLOR_ATTACHMENT0+maxColorAttachments < GL_DEPTH_ATTACHMENT-1)
1004 {
1005 ctx.glReadBuffer (GL_DEPTH_ATTACHMENT - 1);
1006 ctx.expectError (GL_INVALID_OPERATION);
1007 }
1008
1009 ctx.endSection();
1010
1011 ctx.beginSection("GL_INVALID_OPERATION is generated if the current framebuffer is the default framebuffer and mode is not GL_NONE or GL_BACK.");
1012 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0);
1013 ctx.glReadBuffer (GL_COLOR_ATTACHMENT0);
1014 ctx.expectError (GL_INVALID_OPERATION);
1015 ctx.endSection();
1016
1017 ctx.beginSection("GL_INVALID_OPERATION is generated if the current framebuffer is a named framebuffer and mode is not GL_NONE or GL_COLOR_ATTACHMENTi.");
1018 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo);
1019 ctx.glReadBuffer (GL_BACK);
1020 ctx.expectError (GL_INVALID_OPERATION);
1021 ctx.endSection();
1022
1023 ctx.glDeleteTextures(1, &texture);
1024 ctx.glDeleteFramebuffers(1, &fbo);
1025 }
1026
unmap_buffer(NegativeTestContext & ctx)1027 void unmap_buffer (NegativeTestContext& ctx)
1028 {
1029 deUint32 buf = 0x1234;
1030 std::vector<GLfloat> data (32);
1031
1032 ctx.glGenBuffers (1, &buf);
1033 ctx.glBindBuffer (GL_ARRAY_BUFFER, buf);
1034 ctx.glBufferData (GL_ARRAY_BUFFER, 32, &data[0], GL_DYNAMIC_COPY);
1035 ctx.expectError (GL_NO_ERROR);
1036
1037 ctx.beginSection("GL_INVALID_OPERATION is generated if the buffer data store is already in an unmapped state.");
1038 ctx.glUnmapBuffer (GL_ARRAY_BUFFER);
1039 ctx.expectError (GL_INVALID_OPERATION);
1040 ctx.endSection();
1041
1042 ctx.glDeleteBuffers (1, &buf);
1043 }
1044 // Framebuffer Objects
1045
bind_framebuffer(NegativeTestContext & ctx)1046 void bind_framebuffer (NegativeTestContext& ctx)
1047 {
1048 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_DRAW_FRAMEBUFFER, GL_READ_FRAMEBUFFER, or GL_FRAMEBUFFER.");
1049 ctx.glBindFramebuffer(-1, 0);
1050 ctx.expectError(GL_INVALID_ENUM);
1051 ctx.glBindFramebuffer(GL_RENDERBUFFER, 0);
1052 ctx.expectError(GL_INVALID_ENUM);
1053 ctx.endSection();
1054 }
1055
bind_renderbuffer(NegativeTestContext & ctx)1056 void bind_renderbuffer (NegativeTestContext& ctx)
1057 {
1058 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_RENDERBUFFER.");
1059 ctx.glBindRenderbuffer(-1, 0);
1060 ctx.expectError(GL_INVALID_ENUM);
1061 ctx.glBindRenderbuffer(GL_FRAMEBUFFER, 0);
1062 ctx.expectError(GL_INVALID_ENUM);
1063 ctx.endSection();
1064 }
1065
check_framebuffer_status(NegativeTestContext & ctx)1066 void check_framebuffer_status (NegativeTestContext& ctx)
1067 {
1068 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_DRAW_FRAMEBUFFER, GL_READ_FRAMEBUFFER, or GL_FRAMEBUFFER..");
1069 ctx.glCheckFramebufferStatus(-1);
1070 ctx.expectError(GL_INVALID_ENUM);
1071 ctx.glCheckFramebufferStatus(GL_RENDERBUFFER);
1072 ctx.expectError(GL_INVALID_ENUM);
1073 ctx.endSection();
1074 }
1075
gen_framebuffers(NegativeTestContext & ctx)1076 void gen_framebuffers (NegativeTestContext& ctx)
1077 {
1078 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
1079 ctx.glGenFramebuffers(-1, 0);
1080 ctx.expectError(GL_INVALID_VALUE);
1081 ctx.endSection();
1082 }
1083
gen_renderbuffers(NegativeTestContext & ctx)1084 void gen_renderbuffers (NegativeTestContext& ctx)
1085 {
1086 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
1087 ctx.glGenRenderbuffers(-1, 0);
1088 ctx.expectError(GL_INVALID_VALUE);
1089 ctx.endSection();
1090 }
1091
delete_framebuffers(NegativeTestContext & ctx)1092 void delete_framebuffers (NegativeTestContext& ctx)
1093 {
1094 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
1095 ctx.glDeleteFramebuffers(-1, 0);
1096 ctx.expectError(GL_INVALID_VALUE);
1097 ctx.endSection();
1098 }
1099
delete_renderbuffers(NegativeTestContext & ctx)1100 void delete_renderbuffers (NegativeTestContext& ctx)
1101 {;
1102 ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
1103 ctx.glDeleteRenderbuffers(-1, 0);
1104 ctx.expectError(GL_INVALID_VALUE);
1105 ctx.endSection();
1106 }
1107
framebuffer_renderbuffer(NegativeTestContext & ctx)1108 void framebuffer_renderbuffer (NegativeTestContext& ctx)
1109 {
1110 GLuint fbo = 0x1234;
1111 GLuint rbo = 0x1234;
1112 ctx.glGenFramebuffers(1, &fbo);
1113 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1114 ctx.glGenRenderbuffers(1, &rbo);
1115
1116 ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the accepted tokens.");
1117 ctx.glFramebufferRenderbuffer(-1, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, 0);
1118 ctx.expectError(GL_INVALID_ENUM);
1119 ctx.endSection();
1120
1121 ctx.beginSection("GL_INVALID_ENUM is generated if attachment is not one of the accepted tokens.");
1122 ctx.glFramebufferRenderbuffer(GL_FRAMEBUFFER, -1, GL_RENDERBUFFER, 0);
1123 ctx.expectError(GL_INVALID_ENUM);
1124 ctx.endSection();
1125
1126 ctx.beginSection("GL_INVALID_ENUM is generated if renderbuffertarget is not GL_RENDERBUFFER.");
1127 ctx.glBindRenderbuffer(GL_RENDERBUFFER, rbo);
1128 ctx.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, -1, rbo);
1129 ctx.expectError(GL_INVALID_ENUM);
1130 ctx.glBindRenderbuffer(GL_RENDERBUFFER, 0);
1131 ctx.endSection();
1132
1133 ctx.beginSection("GL_INVALID_OPERATION is generated if renderbuffer is neither 0 nor the name of an existing renderbuffer object.");
1134 ctx.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, -1);
1135 ctx.expectError(GL_INVALID_OPERATION);
1136 ctx.endSection();
1137
1138 ctx.beginSection("GL_INVALID_OPERATION is generated if zero is bound to target.");
1139 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1140 ctx.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, 0);
1141 ctx.expectError(GL_INVALID_OPERATION);
1142 ctx.endSection();
1143
1144 ctx.glDeleteRenderbuffers(1, &rbo);
1145 ctx.glDeleteFramebuffers(1, &fbo);
1146 }
1147
framebuffer_texture(NegativeTestContext & ctx)1148 void framebuffer_texture (NegativeTestContext& ctx)
1149 {
1150 if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
1151 {
1152 GLuint fbo = 0x1234;
1153 GLuint texture[] = {0x1234, 0x1234};
1154
1155 ctx.glGenFramebuffers(1, &fbo);
1156 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1157 ctx.glGenTextures(2, texture);
1158 ctx.glBindTexture(GL_TEXTURE_2D, texture[0]);
1159 ctx.glBindTexture(GL_TEXTURE_BUFFER, texture[1]);
1160 ctx.expectError(GL_NO_ERROR);
1161
1162 ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the accepted tokens.");
1163 ctx.glFramebufferTexture(-1, GL_COLOR_ATTACHMENT0, texture[0], 0);
1164 ctx.expectError(GL_INVALID_ENUM);
1165 ctx.endSection();
1166
1167 ctx.beginSection("GL_INVALID_ENUM is generated if attachment is not one of the accepted tokens.");
1168 ctx.glFramebufferTexture(GL_FRAMEBUFFER, -1, texture[0], 0);
1169 ctx.expectError(GL_INVALID_ENUM);
1170 ctx.endSection();
1171
1172 ctx.beginSection("GL_INVALID_OPERATION is generated if texture is neither 0 nor the name of an existing texture object.");
1173 ctx.glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, -1, 0);
1174 ctx.expectError(GL_INVALID_VALUE);
1175 ctx.endSection();
1176
1177 ctx.beginSection("GL_INVALID_OPERATION is generated if zero is bound to target.");
1178 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1179 ctx.glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 0, 0);
1180 ctx.expectError(GL_INVALID_OPERATION);
1181 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1182 ctx.endSection();
1183
1184 ctx.beginSection("GL_INVALID_OPERATION is generated by if texture is a buffer texture.");
1185 ctx.glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texture[1], 0);
1186 ctx.expectError(GL_INVALID_OPERATION);
1187 ctx.endSection();
1188
1189 ctx.glDeleteFramebuffers(1, &fbo);
1190 ctx.glDeleteBuffers(2, texture);
1191 }
1192 }
1193
framebuffer_texture2d(NegativeTestContext & ctx)1194 void framebuffer_texture2d (NegativeTestContext& ctx)
1195 {
1196 GLuint fbo = 0x1234;
1197 GLuint tex2D = 0x1234;
1198 GLuint texCube = 0x1234;
1199 GLuint tex2DMS = 0x1234;
1200 GLint maxTexSize = 0x1234;
1201 GLint maxTexCubeSize = 0x1234;
1202 int maxSize = 0x1234;
1203
1204 ctx.glGenFramebuffers(1, &fbo);
1205 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1206 ctx.glGenTextures(1, &tex2D);
1207 ctx.glBindTexture(GL_TEXTURE_2D, tex2D);
1208 ctx.glGenTextures(1, &texCube);
1209 ctx.glBindTexture(GL_TEXTURE_CUBE_MAP, texCube);
1210 ctx.glGenTextures(1, &tex2DMS);
1211 ctx.glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, tex2DMS);
1212 ctx.glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTexSize);
1213 ctx.glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &maxTexCubeSize);
1214 ctx.expectError(GL_NO_ERROR);
1215
1216 ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the accepted tokens.");
1217 ctx.glFramebufferTexture2D(-1, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
1218 ctx.expectError(GL_INVALID_ENUM);
1219 ctx.endSection();
1220
1221 ctx.beginSection("GL_INVALID_ENUM is generated if textarget is not an accepted texture target.");
1222 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, -1, tex2D, 0);
1223 ctx.expectError(GL_INVALID_ENUM);
1224 ctx.endSection();
1225
1226 ctx.beginSection("GL_INVALID_ENUM is generated if attachment is not an accepted token.");
1227 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, -1, GL_TEXTURE_2D, tex2D, 0);
1228 ctx.expectError(GL_INVALID_ENUM);
1229 ctx.endSection();
1230
1231 ctx.beginSection("GL_INVALID_VALUE is generated if level is less than 0 or larger than log_2 of maximum texture size.");
1232 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex2D, -1);
1233 ctx.expectError(GL_INVALID_VALUE);
1234 maxSize = deLog2Floor32(maxTexSize) + 1;
1235 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex2D, maxSize);
1236 ctx.expectError(GL_INVALID_VALUE);
1237 maxSize = deLog2Floor32(maxTexCubeSize) + 1;
1238 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X, texCube, maxSize);
1239 ctx.expectError(GL_INVALID_VALUE);
1240 ctx.endSection();
1241
1242 ctx.beginSection("GL_INVALID_VALUE is generated if level is larger than maximum texture size.");
1243 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex2D, maxTexSize + 1);
1244 ctx.expectError(GL_INVALID_VALUE);
1245 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex2D, -1);
1246 ctx.expectError(GL_INVALID_VALUE);
1247 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, texCube, maxTexCubeSize + 1);
1248 ctx.expectError(GL_INVALID_VALUE);
1249 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, texCube, -1);
1250 ctx.expectError(GL_INVALID_VALUE);
1251 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, tex2DMS, 1);
1252 ctx.expectError(GL_INVALID_VALUE);
1253 ctx.endSection();
1254
1255 ctx.beginSection("GL_INVALID_OPERATION is generated if texture is neither 0 nor the name of an existing texture object.");
1256 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, -1, 0);
1257 ctx.expectError(GL_INVALID_OPERATION);
1258 ctx.endSection();
1259
1260 ctx.beginSection("GL_INVALID_OPERATION is generated if textarget and texture are not compatible.");
1261 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X, tex2D, 0);
1262 ctx.expectError(GL_INVALID_OPERATION);
1263 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, tex2D, 0);
1264 ctx.expectError(GL_INVALID_OPERATION);
1265 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texCube, 0);
1266 ctx.expectError(GL_INVALID_OPERATION);
1267 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex2DMS, 0);
1268 ctx.expectError(GL_INVALID_OPERATION);
1269 ctx.glDeleteTextures(1, &tex2D);
1270 ctx.glDeleteTextures(1, &texCube);
1271 ctx.glDeleteTextures(1, &tex2DMS);
1272 ctx.endSection();
1273
1274 ctx.beginSection("GL_INVALID_OPERATION is generated if zero is bound to target.");
1275 ctx.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1276 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
1277 ctx.expectError(GL_INVALID_OPERATION);
1278 ctx.endSection();
1279
1280 if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
1281 {
1282 GLuint texBuf = 0x1234;
1283 ctx.beginSection("GL_INVALID_OPERATION error is generated if texture is the name of a buffer texture.");
1284 ctx.glGenTextures(1, &texBuf);
1285 ctx.glBindTexture(GL_TEXTURE_BUFFER, texBuf);
1286 ctx.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1287 ctx.expectError(GL_NO_ERROR);
1288 ctx.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texBuf, 0);
1289 ctx.expectError(GL_INVALID_OPERATION);
1290 ctx.endSection();
1291 }
1292
1293 ctx.glDeleteFramebuffers(1, &fbo);
1294 }
1295
renderbuffer_storage(NegativeTestContext & ctx)1296 void renderbuffer_storage (NegativeTestContext& ctx)
1297 {
1298 deUint32 rbo = 0x1234;
1299 GLint maxSize = 0x1234;
1300 bool isES = glu::isContextTypeES(ctx.getRenderContext().getType());
1301
1302 ctx.glGenRenderbuffers (1, &rbo);
1303 ctx.glBindRenderbuffer (GL_RENDERBUFFER, rbo);
1304
1305 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_RENDERBUFFER.");
1306 ctx.glRenderbufferStorage (-1, GL_RGBA4, 1, 1);
1307 ctx.expectError (GL_INVALID_ENUM);
1308 ctx.glRenderbufferStorage (GL_FRAMEBUFFER, GL_RGBA4, 1, 1);
1309 ctx.expectError (GL_INVALID_ENUM);
1310 ctx.endSection();
1311
1312 ctx.beginSection("GL_INVALID_ENUM is generated if internalformat is not a color-renderable, depth-renderable, or stencil-renderable format.");
1313 ctx.glRenderbufferStorage (GL_RENDERBUFFER, -1, 1, 1);
1314 ctx.expectError (GL_INVALID_ENUM);
1315
1316 if (!ctx.isExtensionSupported("GL_EXT_color_buffer_half_float")) // GL_EXT_color_buffer_half_float disables error
1317 {
1318 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGB16F, 1, 1);
1319 ctx.expectError (isES ? GL_INVALID_ENUM : GL_NO_ERROR);
1320 }
1321
1322 if (!ctx.isExtensionSupported("GL_EXT_render_snorm")) // GL_EXT_render_snorm disables error
1323 {
1324 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA8_SNORM, 1, 1);
1325 ctx.expectError (isES ? GL_INVALID_ENUM : GL_NO_ERROR);
1326 }
1327
1328 ctx.endSection();
1329
1330 ctx.beginSection("GL_INVALID_VALUE is generated if width or height is less than zero.");
1331 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, -1, 1);
1332 ctx.expectError (GL_INVALID_VALUE);
1333 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, 1, -1);
1334 ctx.expectError (GL_INVALID_VALUE);
1335 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, -1, -1);
1336 ctx.expectError (GL_INVALID_VALUE);
1337 ctx.endSection();
1338
1339 ctx.beginSection("GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_RENDERBUFFER_SIZE.");
1340 ctx.glGetIntegerv (GL_MAX_RENDERBUFFER_SIZE, &maxSize);
1341 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, 1, maxSize+1);
1342 ctx.expectError (GL_INVALID_VALUE);
1343 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, maxSize+1, 1);
1344 ctx.expectError (GL_INVALID_VALUE);
1345 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, maxSize+1, maxSize+1);
1346 ctx.expectError (GL_INVALID_VALUE);
1347 ctx.endSection();
1348
1349 ctx.glDeleteRenderbuffers(1, &rbo);
1350 }
1351
blit_framebuffer(NegativeTestContext & ctx)1352 void blit_framebuffer (NegativeTestContext& ctx)
1353 {
1354 deUint32 fbo[2];
1355 deUint32 rbo[2];
1356 deUint32 texture[2];
1357 deUint32 blankFrameBuffer;
1358
1359 ctx.glGenFramebuffers (1, &blankFrameBuffer);
1360 ctx.glGenFramebuffers (2, fbo);
1361 ctx.glGenTextures (2, texture);
1362 ctx.glGenRenderbuffers (2, rbo);
1363
1364 ctx.glBindTexture (GL_TEXTURE_2D, texture[0]);
1365 ctx.glBindRenderbuffer (GL_RENDERBUFFER, rbo[0]);
1366 ctx.glBindFramebuffer (GL_READ_FRAMEBUFFER, fbo[0]);
1367
1368 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1369 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 32, 32);
1370 ctx.glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0);
1371 ctx.glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo[0]);
1372 ctx.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER);
1373
1374 ctx.glBindTexture (GL_TEXTURE_2D, texture[1]);
1375 ctx.glBindRenderbuffer (GL_RENDERBUFFER, rbo[1]);
1376 ctx.glBindFramebuffer (GL_DRAW_FRAMEBUFFER, fbo[1]);
1377
1378 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1379 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 32, 32);
1380 ctx.glFramebufferTexture2D (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[1], 0);
1381 ctx.glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo[1]);
1382 ctx.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
1383 ctx.expectError (GL_NO_ERROR);
1384
1385 ctx.beginSection("GL_INVALID_VALUE is generated if mask contains any bits other than GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, or GL_STENCIL_BUFFER_BIT.");
1386 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, 1, GL_NEAREST);
1387 ctx.expectError (GL_INVALID_VALUE);
1388 ctx.endSection();
1389
1390 ctx.beginSection("GL_INVALID_ENUM is generated if filter is not GL_LINEAR or GL_NEAREST.");
1391 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, 0);
1392 ctx.expectError (GL_INVALID_ENUM);
1393 ctx.endSection();
1394
1395 ctx.beginSection("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.");
1396 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT, GL_LINEAR);
1397 ctx.expectError (GL_INVALID_OPERATION);
1398 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, GL_LINEAR);
1399 ctx.expectError (GL_INVALID_OPERATION);
1400 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT, GL_LINEAR);
1401 ctx.expectError (GL_INVALID_OPERATION);
1402 ctx.endSection();
1403
1404 ctx.beginSection("GL_INVALID_OPERATION is generated if mask contains GL_COLOR_BUFFER_BIT and read buffer format is incompatible with draw buffer format.");
1405 ctx.glBindTexture (GL_TEXTURE_2D, texture[0]);
1406
1407 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32UI, 32, 32, 0, GL_RGBA_INTEGER, GL_UNSIGNED_INT, NULL);
1408 ctx.glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0);
1409 ctx.getLog() << TestLog::Message << "// Read buffer: GL_RGBA32UI, draw buffer: GL_RGBA" << TestLog::EndMessage;
1410 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST);
1411 ctx.expectError (GL_INVALID_OPERATION);
1412
1413 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32I, 32, 32, 0, GL_RGBA_INTEGER, GL_INT, NULL);
1414 ctx.glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0);
1415 ctx.getLog() << TestLog::Message << "// Read buffer: GL_RGBA32I, draw buffer: GL_RGBA" << TestLog::EndMessage;
1416 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST);
1417 ctx.expectError (GL_INVALID_OPERATION);
1418
1419 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1420 ctx.glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0);
1421 ctx.glBindTexture (GL_TEXTURE_2D, texture[1]);
1422 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32I, 32, 32, 0, GL_RGBA_INTEGER, GL_INT, NULL);
1423 ctx.glFramebufferTexture2D (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[1], 0);
1424 ctx.getLog() << TestLog::Message << "// Read buffer: GL_RGBA8, draw buffer: GL_RGBA32I" << TestLog::EndMessage;
1425 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST);
1426 ctx.expectError (GL_INVALID_OPERATION);
1427 ctx.endSection();
1428
1429 ctx.beginSection("GL_INVALID_OPERATION is generated if filter is GL_LINEAR and the read buffer contains integer data.");
1430 ctx.glBindTexture (GL_TEXTURE_2D, texture[0]);
1431 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32UI, 32, 32, 0, GL_RGBA_INTEGER, GL_UNSIGNED_INT, NULL);
1432 ctx.glFramebufferTexture2D (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[0], 0);
1433 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1434 ctx.glFramebufferTexture2D (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture[1], 0);
1435 ctx.getLog() << TestLog::Message << "// Read buffer: GL_RGBA32I, draw buffer: GL_RGBA8" << TestLog::EndMessage;
1436 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_LINEAR);
1437 ctx.expectError (GL_INVALID_OPERATION);
1438 ctx.endSection();
1439
1440 ctx.beginSection("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.");
1441 ctx.glBindRenderbuffer (GL_RENDERBUFFER, rbo[0]);
1442 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH32F_STENCIL8, 32, 32);
1443 ctx.glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo[0]);
1444 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_DEPTH_BUFFER_BIT, GL_NEAREST);
1445 ctx.expectError (GL_INVALID_OPERATION);
1446 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_STENCIL_BUFFER_BIT, GL_NEAREST);
1447 ctx.expectError (GL_INVALID_OPERATION);
1448 ctx.endSection();
1449
1450 ctx.beginSection("GL_INVALID_FRAMEBUFFER_OPERATION is generated if the read or draw framebuffer is not framebuffer complete.");
1451 ctx.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER);
1452 ctx.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
1453 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, 0, GL_NEAREST);
1454 ctx.expectError (GL_NO_ERROR);
1455 ctx.getLog() << TestLog::Message << "// incomplete read framebuffer" << TestLog::EndMessage;
1456 ctx.glBindFramebuffer (GL_READ_FRAMEBUFFER, blankFrameBuffer);
1457 ctx.glBindFramebuffer (GL_DRAW_FRAMEBUFFER, fbo[1]);
1458 TCU_CHECK(ctx.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE);
1459 TCU_CHECK(ctx.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
1460 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, 0, GL_NEAREST);
1461 ctx.expectError (GL_INVALID_FRAMEBUFFER_OPERATION);
1462 ctx.getLog() << TestLog::Message << "// incomplete draw framebuffer" << TestLog::EndMessage;
1463 ctx.glBindFramebuffer (GL_READ_FRAMEBUFFER, fbo[1]);
1464 ctx.glBindFramebuffer (GL_DRAW_FRAMEBUFFER, blankFrameBuffer);
1465 TCU_CHECK(ctx.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
1466 TCU_CHECK(ctx.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE);
1467 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, 0, GL_NEAREST);
1468 ctx.expectError (GL_INVALID_FRAMEBUFFER_OPERATION);
1469 ctx.getLog() << TestLog::Message << "// incomplete read and draw framebuffer" << TestLog::EndMessage;
1470 ctx.glBindFramebuffer (GL_READ_FRAMEBUFFER, blankFrameBuffer);
1471 ctx.glBindFramebuffer (GL_DRAW_FRAMEBUFFER, blankFrameBuffer);
1472 TCU_CHECK(ctx.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE);
1473 TCU_CHECK(ctx.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE);
1474 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, 0, GL_NEAREST);
1475 ctx.expectError (GL_INVALID_FRAMEBUFFER_OPERATION);
1476 // restore
1477 ctx.glBindFramebuffer (GL_READ_FRAMEBUFFER, fbo[0]);
1478 ctx.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER);
1479 ctx.glBindFramebuffer (GL_DRAW_FRAMEBUFFER, fbo[1]);
1480 ctx.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
1481 ctx.endSection();
1482
1483 bool isES = glu::isContextTypeES(ctx.getRenderContext().getType());
1484 ctx.beginSection("GL_INVALID_OPERATION is generated if the source and destination buffers are identical.");
1485 ctx.glBindFramebuffer (GL_DRAW_FRAMEBUFFER, fbo[0]);
1486 ctx.expectError (GL_NO_ERROR);
1487 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_DEPTH_BUFFER_BIT, GL_NEAREST);
1488 ctx.expectError (isES ? GL_INVALID_OPERATION : GL_NO_ERROR);
1489 // restore
1490 ctx.glBindFramebuffer (GL_DRAW_FRAMEBUFFER, fbo[1]);
1491 ctx.endSection();
1492
1493 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0);
1494 ctx.glBindRenderbuffer (GL_RENDERBUFFER, 0);
1495 ctx.glDeleteFramebuffers (2, fbo);
1496 ctx.glDeleteFramebuffers (1, &blankFrameBuffer);
1497 ctx.glDeleteTextures (2, texture);
1498 ctx.glDeleteRenderbuffers (2, rbo);
1499 }
1500
blit_framebuffer_multisample(NegativeTestContext & ctx)1501 void blit_framebuffer_multisample (NegativeTestContext& ctx)
1502 {
1503 deUint32 fbo[2];
1504 deUint32 rbo[2];
1505
1506 ctx.glGenFramebuffers (2, fbo);
1507 ctx.glGenRenderbuffers (2, rbo);
1508
1509 ctx.glBindRenderbuffer (GL_RENDERBUFFER, rbo[0]);
1510 ctx.glBindFramebuffer (GL_READ_FRAMEBUFFER, fbo[0]);
1511 ctx.glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_RGBA8, 32, 32);
1512 ctx.glFramebufferRenderbuffer (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo[0]);
1513 ctx.glCheckFramebufferStatus (GL_READ_FRAMEBUFFER);
1514
1515 ctx.glBindRenderbuffer (GL_RENDERBUFFER, rbo[1]);
1516 ctx.glBindFramebuffer (GL_DRAW_FRAMEBUFFER, fbo[1]);
1517
1518 ctx.expectError (GL_NO_ERROR);
1519
1520 if (!ctx.isExtensionSupported("GL_NV_framebuffer_multisample"))
1521 {
1522 bool isES = glu::isContextTypeES(ctx.getRenderContext().getType());
1523
1524 ctx.beginSection("GL_INVALID_OPERATION is generated if the value of GL_SAMPLE_BUFFERS for the draw buffer is greater than zero.");
1525 ctx.glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_RGBA8, 32, 32);
1526 ctx.glFramebufferRenderbuffer (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo[1]);
1527 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST);
1528 ctx.expectError (isES ? GL_INVALID_OPERATION : GL_NO_ERROR);
1529 ctx.endSection();
1530
1531 ctx.beginSection("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.");
1532 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA4, 32, 32);
1533 ctx.glFramebufferRenderbuffer (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo[1]);
1534 ctx.glBlitFramebuffer (0, 0, 16, 16, 0, 0, 16, 16, GL_COLOR_BUFFER_BIT, GL_NEAREST);
1535 ctx.expectError (isES ? GL_INVALID_OPERATION : GL_NO_ERROR);
1536 ctx.endSection();
1537
1538 ctx.beginSection("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.");
1539 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA8, 32, 32);
1540 ctx.glFramebufferRenderbuffer (GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo[1]);
1541 ctx.glBlitFramebuffer (0, 0, 16, 16, 2, 2, 18, 18, GL_COLOR_BUFFER_BIT, GL_NEAREST);
1542 ctx.expectError (isES ? GL_INVALID_OPERATION : GL_NO_ERROR);
1543 ctx.endSection();
1544 }
1545
1546 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0);
1547 ctx.glDeleteRenderbuffers (2, rbo);
1548 ctx.glDeleteFramebuffers (2, fbo);
1549 }
1550
framebuffer_texture_layer(NegativeTestContext & ctx)1551 void framebuffer_texture_layer (NegativeTestContext& ctx)
1552 {
1553 deUint32 fbo = 0x1234;
1554 deUint32 tex3D = 0x1234;
1555 deUint32 tex2DArray = 0x1234;
1556 deUint32 tex2D = 0x1234;
1557 deUint32 tex2DMSArray = 0x1234;
1558 deUint32 texBuffer = 0x1234;
1559 int max3DTexSize = 0x1234;
1560 int maxTexSize = 0x1234;
1561 int maxArrayTexLayers = 0x1234;
1562 int log2Max3DTexSize = 0x1234;
1563 int log2MaxTexSize = 0x1234;
1564
1565 ctx.glGetIntegerv (GL_MAX_3D_TEXTURE_SIZE, &max3DTexSize);
1566 ctx.glGetIntegerv (GL_MAX_TEXTURE_SIZE, &maxTexSize);
1567 ctx.glGetIntegerv (GL_MAX_ARRAY_TEXTURE_LAYERS, &maxArrayTexLayers);
1568
1569 ctx.glGenFramebuffers (1, &fbo);
1570 ctx.glGenTextures (1, &tex3D);
1571 ctx.glGenTextures (1, &tex2DArray);
1572 ctx.glGenTextures (1, &tex2D);
1573 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo);
1574
1575 ctx.glBindTexture (GL_TEXTURE_3D, tex3D);
1576 ctx.glTexImage3D (GL_TEXTURE_3D, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1577 ctx.glBindTexture (GL_TEXTURE_2D_ARRAY, tex2DArray);
1578 ctx.glTexImage3D (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1579 ctx.glBindTexture (GL_TEXTURE_2D, tex2D);
1580 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1581
1582 ctx.expectError (GL_NO_ERROR);
1583
1584 ctx.beginSection("GL_INVALID_ENUM is generated if target is not one of the accepted tokens.");
1585 ctx.glFramebufferTextureLayer (-1, GL_COLOR_ATTACHMENT0, tex3D, 0, 1);
1586 ctx.expectError (GL_INVALID_ENUM);
1587 ctx.glFramebufferTextureLayer (GL_RENDERBUFFER, GL_COLOR_ATTACHMENT0, tex3D, 0, 1);
1588 ctx.expectError (GL_INVALID_ENUM);
1589 ctx.endSection();
1590
1591 ctx.beginSection("GL_INVALID_ENUM is generated if attachment is not one of the accepted tokens.");
1592 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, -1, tex3D, 0, 1);
1593 ctx.expectError (GL_INVALID_ENUM);
1594 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_BACK, tex3D, 0, 1);
1595 ctx.expectError (GL_INVALID_ENUM);
1596 ctx.endSection();
1597
1598 ctx.beginSection("GL_INVALID_OPERATION is generated if texture is non-zero and not the name of a 3D texture or 2D array texture, 2D multisample array texture or cube map array texture.");
1599 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, -1, 0, 0);
1600 ctx.expectError (GL_INVALID_OPERATION);
1601 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex2D, 0, 0);
1602 ctx.expectError (GL_INVALID_OPERATION);
1603 ctx.endSection();
1604
1605 ctx.beginSection("GL_INVALID_VALUE is generated if texture is not zero and layer is negative.");
1606 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex3D, 0, -1);
1607 ctx.expectError (GL_INVALID_VALUE);
1608 ctx.endSection();
1609
1610 ctx.beginSection("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.");
1611 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex3D, 0, max3DTexSize);
1612 ctx.expectError (GL_INVALID_VALUE);
1613 ctx.endSection();
1614
1615 ctx.beginSection("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.");
1616 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex2DArray, 0, maxArrayTexLayers);
1617 ctx.expectError (GL_INVALID_VALUE);
1618 ctx.endSection();
1619
1620 ctx.beginSection("GL_INVALID_OPERATION is generated if zero is bound to target.");
1621 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0);
1622 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex3D, 0, 1);
1623 ctx.expectError (GL_INVALID_OPERATION);
1624 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo);
1625 ctx.endSection();
1626
1627 ctx.beginSection("GL_INVALID_VALUE is generated if texture is a 3D texture and level is less than 0 or greater than log2 of the value of GL_MAX_3D_TEXTURE_SIZE.");
1628 log2Max3DTexSize = deLog2Floor32(max3DTexSize);
1629 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex3D, -1, max3DTexSize - 1);
1630 ctx.expectError (GL_INVALID_VALUE);
1631 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex3D, log2Max3DTexSize + 1, max3DTexSize - 1);
1632 ctx.expectError (GL_INVALID_VALUE);
1633 ctx.endSection();
1634
1635 ctx.beginSection("GL_INVALID_VALUE is generated if texture is a 2D array texture and level is less than 0 or greater than log2 of the value of GL_MAX_TEXTURE_SIZE.");
1636 log2MaxTexSize = deLog2Floor32(maxTexSize);
1637 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex2DArray, -1, maxArrayTexLayers - 1);
1638 ctx.expectError (GL_INVALID_VALUE);
1639 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex2DArray, log2MaxTexSize + 1, maxArrayTexLayers - 1);
1640 ctx.expectError (GL_INVALID_VALUE);
1641 ctx.endSection();
1642
1643 if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
1644 {
1645 deUint32 texCubeArray = 0x1234;
1646 int maxCubeTexSize = 0x1234;
1647 ctx.glGetIntegerv (GL_MAX_CUBE_MAP_TEXTURE_SIZE, &maxCubeTexSize);
1648 ctx.glGenTextures (1, &tex2DMSArray);
1649 ctx.glGenTextures (1, &texCubeArray);
1650 ctx.glGenTextures (1, &texBuffer);
1651 ctx.glBindTexture (GL_TEXTURE_2D_MULTISAMPLE_ARRAY, tex2DMSArray);
1652 ctx.glBindTexture (GL_TEXTURE_CUBE_MAP_ARRAY, texCubeArray);
1653 ctx.glBindTexture (GL_TEXTURE_BUFFER, texBuffer);
1654 ctx.expectError (GL_NO_ERROR);
1655
1656 ctx.beginSection("GL_INVALID_VALUE is generated if texture is a 2D multisample array texture and level is not 0.");
1657 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex2DMSArray, -1, 0);
1658 ctx.expectError (GL_INVALID_VALUE);
1659 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex2DMSArray, 1, 0);
1660 ctx.expectError (GL_INVALID_VALUE);
1661 ctx.endSection();
1662
1663 ctx.beginSection("GL_INVALID_VALUE is generated if texture is a cube map array texture and layer is larger than MAX_ARRAY_TEXTURE_LAYERS-1. (See Khronos bug 15968)");
1664 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texCubeArray, 0, maxArrayTexLayers);
1665 ctx.expectError (GL_INVALID_VALUE);
1666 ctx.endSection();
1667
1668 ctx.beginSection("GL_INVALID_OPERATION is generated if texture is the name of a buffer texture.");
1669 ctx.glFramebufferTextureLayer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texBuffer, 0, 0);
1670 ctx.expectError (GL_INVALID_OPERATION);
1671 ctx.endSection();
1672
1673 ctx.glDeleteTextures (1, &tex2DMSArray);
1674 ctx.glDeleteTextures (1, &texCubeArray);
1675 ctx.glDeleteTextures (1, &texBuffer);
1676 }
1677
1678 ctx.glDeleteTextures (1, &tex3D);
1679 ctx.glDeleteTextures (1, &tex2DArray);
1680 ctx.glDeleteTextures (1, &tex2D);
1681 ctx.glDeleteFramebuffers (1, &fbo);
1682 }
1683
invalidate_framebuffer(NegativeTestContext & ctx)1684 void invalidate_framebuffer (NegativeTestContext& ctx)
1685 {
1686 deUint32 attachments[3];
1687 deUint32 fbo = 0x1234;
1688 deUint32 texture = 0x1234;
1689 int maxColorAttachments = 0x1234;
1690
1691 ctx.glGetIntegerv (GL_MAX_COLOR_ATTACHMENTS, &maxColorAttachments);
1692 attachments[0] = GL_COLOR_ATTACHMENT0;
1693 attachments[1] = GL_COLOR_ATTACHMENT0 + maxColorAttachments;
1694 attachments[2] = GL_DEPTH_STENCIL_ATTACHMENT;
1695
1696 ctx.glGenFramebuffers (1, &fbo);
1697 ctx.glGenTextures (1, &texture);
1698 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo);
1699 ctx.glBindTexture (GL_TEXTURE_2D, texture);
1700 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1701 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
1702 ctx.glCheckFramebufferStatus (GL_FRAMEBUFFER);
1703 ctx.expectError (GL_NO_ERROR);
1704
1705 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_FRAMEBUFFER, GL_READ_FRAMEBUFFER or GL_DRAW_FRAMEBUFFER.");
1706 ctx.glInvalidateFramebuffer (-1, 1, &attachments[0]);
1707 ctx.expectError (GL_INVALID_ENUM);
1708 ctx.glInvalidateFramebuffer (GL_BACK, 1, &attachments[0]);
1709 ctx.expectError (GL_INVALID_ENUM);
1710 ctx.endSection();
1711
1712 ctx.beginSection("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.");
1713 ctx.glInvalidateFramebuffer (GL_FRAMEBUFFER, 1, &attachments[1]);
1714 ctx.expectError (GL_INVALID_OPERATION);
1715 ctx.endSection();
1716
1717 ctx.beginSection("GL_INVALID_VALUE is generated if numAttachments is negative.");
1718 ctx.glInvalidateFramebuffer (GL_FRAMEBUFFER, -1, &attachments[0]);
1719 ctx.expectError (GL_INVALID_VALUE);
1720 ctx.endSection();
1721
1722 ctx.beginSection("GL_INVALID_ENUM is generated if the default framebuffer is bound to target and any elements of attachments are not one of the accepted attachments.");
1723 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0);
1724 ctx.glInvalidateFramebuffer (GL_FRAMEBUFFER, 1, &attachments[2]);
1725 ctx.expectError (GL_INVALID_ENUM);
1726 ctx.endSection();
1727
1728
1729 ctx.glDeleteTextures (1, &texture);
1730 ctx.glDeleteFramebuffers (1, &fbo);
1731 }
1732
invalidate_sub_framebuffer(NegativeTestContext & ctx)1733 void invalidate_sub_framebuffer (NegativeTestContext& ctx)
1734 {
1735 deUint32 attachments[3];
1736 deUint32 fbo = 0x1234;
1737 deUint32 texture = 0x1234;
1738 int maxColorAttachments = 0x1234;
1739
1740 ctx.glGetIntegerv (GL_MAX_COLOR_ATTACHMENTS, &maxColorAttachments);
1741 attachments[0] = GL_COLOR_ATTACHMENT0;
1742 attachments[1] = GL_COLOR_ATTACHMENT0 + maxColorAttachments;
1743 attachments[2] = GL_DEPTH_STENCIL_ATTACHMENT;
1744
1745 ctx.glGenFramebuffers (1, &fbo);
1746 ctx.glGenTextures (1, &texture);
1747 ctx.glBindFramebuffer (GL_FRAMEBUFFER, fbo);
1748 ctx.glBindTexture (GL_TEXTURE_2D, texture);
1749 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1750 ctx.glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
1751 ctx.glCheckFramebufferStatus (GL_FRAMEBUFFER);
1752 ctx.expectError (GL_NO_ERROR);
1753
1754 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_FRAMEBUFFER, GL_READ_FRAMEBUFFER or GL_DRAW_FRAMEBUFFER.");
1755 ctx.glInvalidateSubFramebuffer (-1, 1, &attachments[0], 0, 0, 16, 16);
1756 ctx.expectError (GL_INVALID_ENUM);
1757 ctx.glInvalidateSubFramebuffer (GL_BACK, 1, &attachments[0], 0, 0, 16, 16);
1758 ctx.expectError (GL_INVALID_ENUM);
1759 ctx.endSection();
1760
1761 ctx.beginSection("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.");
1762 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, 1, &attachments[1], 0, 0, 16, 16);
1763 ctx.expectError (GL_INVALID_OPERATION);
1764 ctx.endSection();
1765
1766 ctx.beginSection("GL_INVALID_VALUE is generated if numAttachments, width, or heigh is negative.");
1767 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, -1, &attachments[0], 0, 0, 16, 16);
1768 ctx.expectError (GL_INVALID_VALUE);
1769 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, -1, &attachments[0], 0, 0, -1, 16);
1770 ctx.expectError (GL_INVALID_VALUE);
1771 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, -1, &attachments[0], 0, 0, 16, -1);
1772 ctx.expectError (GL_INVALID_VALUE);
1773 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, -1, &attachments[0], 0, 0, -1, -1);
1774 ctx.expectError (GL_INVALID_VALUE);
1775 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, 1, &attachments[0], 0, 0, -1, 16);
1776 ctx.expectError (GL_INVALID_VALUE);
1777 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, 1, &attachments[0], 0, 0, 16, -1);
1778 ctx.expectError (GL_INVALID_VALUE);
1779 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, 1, &attachments[0], 0, 0, -1, -1);
1780 ctx.expectError (GL_INVALID_VALUE);
1781 ctx.endSection();
1782
1783 ctx.beginSection("GL_INVALID_ENUM is generated if the default framebuffer is bound to target and any elements of attachments are not one of the accepted attachments.");
1784 ctx.glBindFramebuffer (GL_FRAMEBUFFER, 0);
1785 ctx.glInvalidateSubFramebuffer (GL_FRAMEBUFFER, 1, &attachments[2], 0, 0, 16, 16);
1786 ctx.expectError (GL_INVALID_ENUM);
1787 ctx.endSection();
1788
1789 ctx.glDeleteTextures (1, &texture);
1790 ctx.glDeleteFramebuffers (1, &fbo);
1791 }
1792
renderbuffer_storage_multisample(NegativeTestContext & ctx)1793 void renderbuffer_storage_multisample (NegativeTestContext& ctx)
1794 {
1795 deUint32 rbo = 0x1234;
1796 int maxSamplesSupportedRGBA4 = -1;
1797 int maxSamplesSupportedRGBA8UI = -1;
1798 GLint maxSize = 0x1234;
1799 bool isES = glu::isContextTypeES(ctx.getRenderContext().getType());
1800
1801 ctx.glGetInternalformativ (GL_RENDERBUFFER, GL_RGBA4, GL_SAMPLES, 1, &maxSamplesSupportedRGBA4);
1802 ctx.glGetInternalformativ (GL_RENDERBUFFER, GL_RGBA8UI, GL_SAMPLES, 1, &maxSamplesSupportedRGBA8UI);
1803
1804 ctx.glGenRenderbuffers (1, &rbo);
1805 ctx.glBindRenderbuffer (GL_RENDERBUFFER, rbo);
1806
1807 ctx.beginSection("GL_INVALID_ENUM is generated if target is not GL_RENDERBUFFER.");
1808 ctx.glRenderbufferStorageMultisample (-1, 2, GL_RGBA4, 1, 1);
1809 ctx.expectError (GL_INVALID_ENUM);
1810 ctx.glRenderbufferStorageMultisample (GL_FRAMEBUFFER, 2, GL_RGBA4, 1, 1);
1811 ctx.expectError (GL_INVALID_ENUM);
1812 ctx.endSection();
1813
1814 ctx.beginSection("GL_INVALID_OPERATION is generated if samples is greater than the maximum number of samples supported for internalformat.");
1815 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, maxSamplesSupportedRGBA4+1, GL_RGBA4, 1, 1);
1816 ctx.expectError (GL_INVALID_OPERATION);
1817 ctx.endSection();
1818
1819 ctx.beginSection("GL_INVALID_ENUM is generated if internalformat is not a color-renderable, depth-renderable, or stencil-renderable format.");
1820 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, -1, 1, 1);
1821 ctx.expectError (GL_INVALID_ENUM);
1822
1823 if (!ctx.isExtensionSupported("GL_EXT_color_buffer_half_float")) // GL_EXT_color_buffer_half_float disables error
1824 {
1825 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGB16F, 1, 1);
1826 ctx.expectError (isES ? GL_INVALID_ENUM : GL_NO_ERROR);
1827 }
1828
1829 if (!ctx.isExtensionSupported("GL_EXT_render_snorm")) // GL_EXT_render_snorm disables error
1830 {
1831 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGBA8_SNORM, 1, 1);
1832 ctx.expectError (isES ? GL_INVALID_ENUM : GL_NO_ERROR);
1833 }
1834
1835 ctx.endSection();
1836
1837 ctx.beginSection("GL_INVALID_OPERATION is generated if samples is greater than the maximum number of samples supported for internalformat. (Unsigned integer format)");
1838 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, maxSamplesSupportedRGBA8UI+1, GL_RGBA8UI, 1, 1);
1839 ctx.expectError (GL_INVALID_OPERATION);
1840 ctx.endSection();
1841
1842 ctx.beginSection("GL_INVALID_VALUE is generated if width or height is less than zero.");
1843 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGBA4, -1, 1);
1844 ctx.expectError (GL_INVALID_VALUE);
1845 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGBA4, 1, -1);
1846 ctx.expectError (GL_INVALID_VALUE);
1847 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 2, GL_RGBA4, -1, -1);
1848 ctx.expectError (GL_INVALID_VALUE);
1849 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, -1, GL_RGBA4, 1, 1);
1850 ctx.expectError (GL_INVALID_VALUE);
1851 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, -1, GL_RGBA4, -1, 1);
1852 ctx.expectError (GL_INVALID_VALUE);
1853 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, -1, GL_RGBA4, 1, -1);
1854 ctx.expectError (GL_INVALID_VALUE);
1855 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, -1, GL_RGBA4, -1, -1);
1856 ctx.expectError (GL_INVALID_VALUE);
1857 ctx.endSection();
1858
1859 ctx.beginSection("GL_INVALID_VALUE is generated if width or height is greater than GL_MAX_RENDERBUFFER_SIZE.");
1860 ctx.glGetIntegerv (GL_MAX_RENDERBUFFER_SIZE, &maxSize);
1861 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 4, GL_RGBA4, 1, maxSize+1);
1862 ctx.expectError (GL_INVALID_VALUE);
1863 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 4, GL_RGBA4, maxSize+1, 1);
1864 ctx.expectError (GL_INVALID_VALUE);
1865 ctx.glRenderbufferStorageMultisample (GL_RENDERBUFFER, 4, GL_RGBA4, maxSize+1, maxSize+1);
1866 ctx.expectError (GL_INVALID_VALUE);
1867 ctx.endSection();
1868
1869 ctx.glDeleteRenderbuffers(1, &rbo);
1870 }
1871
copy_image_sub_data(NegativeTestContext & ctx)1872 void copy_image_sub_data (NegativeTestContext& ctx)
1873 {
1874 if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
1875 {
1876 deUint32 texture[5];
1877 deUint32 rbo = 0x1234;
1878
1879 ctx.glGenTextures (5, texture);
1880 ctx.glGenRenderbuffers (1, &rbo);
1881 ctx.glBindRenderbuffer (GL_RENDERBUFFER, rbo);
1882
1883 ctx.glBindTexture (GL_TEXTURE_2D, texture[0]);
1884 ctx.glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1885 ctx.glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1886 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1887 ctx.glRenderbufferStorage (GL_RENDERBUFFER, GL_RGBA8, 32, 32);
1888 ctx.glBindTexture (GL_TEXTURE_2D, texture[1]);
1889 ctx.glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1890 ctx.glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1891 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1892 ctx.expectError (GL_NO_ERROR);
1893
1894 ctx.glBindTexture (GL_TEXTURE_3D, texture[2]);
1895 ctx.glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1896 ctx.glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1897 ctx.glTexImage3D (GL_TEXTURE_3D, 0, GL_RGBA8, 32, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1898 ctx.expectError (GL_NO_ERROR);
1899
1900 ctx.glBindTexture (GL_TEXTURE_3D, texture[3]);
1901 ctx.glTexImage3D (GL_TEXTURE_3D, 0, GL_RGBA8, 32, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1902 ctx.expectError (GL_NO_ERROR);
1903
1904 ctx.glBindTexture (GL_TEXTURE_2D, texture[4]);
1905 ctx.glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1906 ctx.glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1907 ctx.glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA32F, 32, 32, 0, GL_RGBA, GL_FLOAT, NULL);
1908 ctx.expectError (GL_NO_ERROR);
1909
1910 ctx.beginSection("GL_INVALID_VALUE is generated if srcWidth, srcHeight, or srcDepth is negative.");
1911 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, -1, 1, 1);
1912 ctx.expectError (GL_INVALID_VALUE);
1913 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 1, -1, 1);
1914 ctx.expectError (GL_INVALID_VALUE);
1915 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 1, 1, -1);
1916 ctx.expectError (GL_INVALID_VALUE);
1917 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, -1, -1, 1);
1918 ctx.expectError (GL_INVALID_VALUE);
1919 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, -1, 1, -1);
1920 ctx.expectError (GL_INVALID_VALUE);
1921 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 1, -1, -1);
1922 ctx.expectError (GL_INVALID_VALUE);
1923 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, -1, -1, -1);
1924 ctx.expectError (GL_INVALID_VALUE);
1925 ctx.endSection();
1926
1927 ctx.beginSection("GL_INVALID_VALUE is generated if srcLevel and dstLevel are not valid levels for the corresponding images.");
1928 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 1, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1);
1929 ctx.expectError (GL_INVALID_VALUE);
1930 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 1, 0, 0, 0, 0, 0, 1);
1931 ctx.expectError (GL_INVALID_VALUE);
1932 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 1, 0, 0, 0, texture[1], GL_TEXTURE_2D, 1, 0, 0, 0, 0, 0, 1);
1933 ctx.expectError (GL_INVALID_VALUE);
1934 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, -1, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1);
1935 ctx.expectError (GL_INVALID_VALUE);
1936 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, -1, 0, 0, 0, 0, 0, 1);
1937 ctx.expectError (GL_INVALID_VALUE);
1938 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, -1, 0, 0, 0, texture[1], GL_TEXTURE_2D, -1, 0, 0, 0, 0, 0, 1);
1939 ctx.expectError (GL_INVALID_VALUE);
1940 ctx.glCopyImageSubData (rbo, GL_RENDERBUFFER, -1, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1);
1941 ctx.expectError (GL_INVALID_VALUE);
1942 ctx.glCopyImageSubData (rbo, GL_RENDERBUFFER, 1, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1);
1943 ctx.expectError (GL_INVALID_VALUE);
1944 ctx.glCopyImageSubData (texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, rbo, GL_RENDERBUFFER, -1, 0, 0, 0, 0, 0, 1);
1945 ctx.expectError (GL_INVALID_VALUE);
1946 ctx.glCopyImageSubData (texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, rbo, GL_RENDERBUFFER, 1, 0, 0, 0, 0, 0, 1);
1947 ctx.expectError (GL_INVALID_VALUE);
1948 ctx.endSection();
1949
1950 ctx.beginSection("GL_INVALID_ENUM is generated if either target does not match the type of the object.");
1951 // \note: This could be either:
1952 // 1. GL_INVALID_ENUM is generated if either target does not match the type of the object.
1953 // 2. GL_INVALID_VALUE is generated if either name does not correspond to a valid renderbuffer or texture object according to the corresponding target parameter.
1954 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, 1);
1955 ctx.expectError (GL_INVALID_ENUM);
1956 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[2], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1);
1957 ctx.expectError (GL_INVALID_ENUM);
1958 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_3D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1);
1959 ctx.expectError (GL_INVALID_ENUM);
1960 ctx.glCopyImageSubData (texture[2], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1);
1961 ctx.expectError (GL_INVALID_ENUM);
1962 ctx.endSection();
1963
1964 ctx.beginSection("GL_INVALID_OPERATION is generated if either object is a texture and the texture is not complete.");
1965 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[3], GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, 1);
1966 ctx.expectError (GL_INVALID_OPERATION);
1967 ctx.glCopyImageSubData (texture[3], GL_TEXTURE_3D, 0, 0, 0, 0, texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1);
1968 ctx.expectError (GL_INVALID_OPERATION);
1969 ctx.glCopyImageSubData (texture[3], GL_TEXTURE_3D, 0, 0, 0, 0, texture[3], GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, 1);
1970 ctx.expectError (GL_INVALID_OPERATION);
1971 ctx.endSection();
1972
1973 ctx.beginSection("GL_INVALID_VALUE is generated if the dimensions of either subregion exceeds the boundaries of the corresponding image object.");
1974 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 33, 0, 1);
1975 ctx.expectError (GL_INVALID_VALUE);
1976 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[1], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 33, 1);
1977 ctx.expectError (GL_INVALID_VALUE);
1978 ctx.endSection();
1979
1980 ctx.beginSection("GL_INVALID_OPERATION error is generated if the source and destination internal formats are not compatible.");
1981 ctx.glCopyImageSubData (texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, texture[4], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1);
1982 ctx.expectError (GL_INVALID_OPERATION);
1983 ctx.glCopyImageSubData (texture[4], GL_TEXTURE_2D, 0, 0, 0, 0, texture[0], GL_TEXTURE_2D, 0, 0, 0, 0, 0, 0, 1);
1984 ctx.expectError (GL_INVALID_OPERATION);
1985 ctx.endSection();
1986
1987 ctx.glDeleteTextures (5, texture);
1988 ctx.glDeleteRenderbuffers (1, &rbo);
1989 }
1990 }
1991
getNegativeBufferApiTestFunctions()1992 std::vector<FunctionContainer> getNegativeBufferApiTestFunctions ()
1993 {
1994 const FunctionContainer funcs[] =
1995 {
1996 {bind_buffer, "bind_buffer", "Invalid glBindBuffer() usage" },
1997 {delete_buffers, "delete_buffers", "Invalid glDeleteBuffers() usage" },
1998 {gen_buffers, "gen_buffers", "Invalid glGenBuffers() usage" },
1999 {buffer_data, "buffer_data", "Invalid glBufferData() usage" },
2000 {buffer_sub_data, "buffer_sub_data", "Invalid glBufferSubData() usage" },
2001 {buffer_sub_data_size_offset, "buffer_sub_data_size_offset", "Invalid glBufferSubData() usage" },
2002 {clear, "clear", "Invalid glClear() usage" },
2003 {read_pixels, "read_pixels", "Invalid glReadPixels() usage" },
2004 {readn_pixels, "readn_pixels", "Invalid glReadPixels() usage" },
2005 {read_pixels_format_mismatch, "read_pixels_format_mismatch", "Invalid glReadPixels() usage" },
2006 {read_pixels_fbo_format_mismatch, "read_pixels_fbo_format_mismatch", "Invalid glReadPixels() usage" },
2007 {bind_buffer_range, "bind_buffer_range", "Invalid glBindBufferRange() usage" },
2008 {bind_buffer_base, "bind_buffer_base", "Invalid glBindBufferBase() usage" },
2009 {clear_bufferiv, "clear_bufferiv", "Invalid glClearBufferiv() usage" },
2010 {clear_bufferuiv, "clear_bufferuiv", "Invalid glClearBufferuiv() usage" },
2011 {clear_bufferfv, "clear_bufferfv", "Invalid glClearBufferfv() usage" },
2012 {clear_bufferfi, "clear_bufferfi", "Invalid glClearBufferfi() usage" },
2013 {copy_buffer_sub_data, "copy_buffer_sub_data", "Invalid glCopyBufferSubData() usage" },
2014 {draw_buffers, "draw_buffers", "Invalid glDrawBuffers() usage" },
2015 {flush_mapped_buffer_range, "flush_mapped_buffer_range", "Invalid glFlushMappedBufferRange() usage" },
2016 {map_buffer_range, "map_buffer_range", "Invalid glMapBufferRange() usage" },
2017 {read_buffer, "read_buffer", "Invalid glReadBuffer() usage" },
2018 {unmap_buffer, "unmap_buffer", "Invalid glUnmapBuffer() usage" },
2019 {bind_framebuffer, "bind_framebuffer", "Invalid glBindFramebuffer() usage" },
2020 {bind_renderbuffer, "bind_renderbuffer", "Invalid glBindRenderbuffer() usage" },
2021 {check_framebuffer_status, "check_framebuffer_status", "Invalid glCheckFramebufferStatus() usage" },
2022 {gen_framebuffers, "gen_framebuffers", "Invalid glGenFramebuffers() usage" },
2023 {gen_renderbuffers, "gen_renderbuffers", "Invalid glGenRenderbuffers() usage" },
2024 {delete_framebuffers, "delete_framebuffers", "Invalid glDeleteFramebuffers() usage" },
2025 {delete_renderbuffers, "delete_renderbuffers", "Invalid glDeleteRenderbuffers() usage" },
2026 {framebuffer_renderbuffer, "framebuffer_renderbuffer", "Invalid glFramebufferRenderbuffer() usage" },
2027 {framebuffer_texture, "framebuffer_texture", "Invalid glFramebufferTexture() usage" },
2028 {framebuffer_texture2d, "framebuffer_texture2d", "Invalid glFramebufferTexture2D() usage" },
2029 {renderbuffer_storage, "renderbuffer_storage", "Invalid glRenderbufferStorage() usage" },
2030 {blit_framebuffer, "blit_framebuffer", "Invalid glBlitFramebuffer() usage" },
2031 {blit_framebuffer_multisample, "blit_framebuffer_multisample", "Invalid glBlitFramebuffer() usage" },
2032 {framebuffer_texture_layer, "framebuffer_texture_layer", "Invalid glFramebufferTextureLayer() usage" },
2033 {invalidate_framebuffer, "invalidate_framebuffer", "Invalid glInvalidateFramebuffer() usage" },
2034 {invalidate_sub_framebuffer, "invalidate_sub_framebuffer", "Invalid glInvalidateSubFramebuffer() usage" },
2035 {renderbuffer_storage_multisample, "renderbuffer_storage_multisample", "Invalid glRenderbufferStorageMultisample() usage" },
2036 {copy_image_sub_data, "copy_image_sub_data", "Invalid glCopyImageSubData() usage" },
2037 };
2038
2039 return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
2040 }
2041
2042 } // NegativeTestShared
2043 } // Functional
2044 } // gles31
2045 } // deqp
2046