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