1 /*-------------------------------------------------------------------------
2 * OpenGL Conformance Test Suite
3 * -----------------------------
4 *
5 * Copyright (c) 2024 The Khronos Group Inc.
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
22 */ /*-------------------------------------------------------------------*/
23
24 /**
25 */ /*!
26 * \file glcApiCoverageTests.cpp
27 * \brief Conformance tests for OpenGL and OpenGL ES API coverage.
28 */ /*-------------------------------------------------------------------*/
29
30 #include "deMath.h"
31 #include "deUniquePtr.hpp"
32 #include "glcMisc.hpp"
33 #include "gluContextInfo.hpp"
34 #include "gluDefs.hpp"
35 #include "gluStateReset.hpp"
36 #include "gluShaderProgram.hpp"
37 #include "gluStrUtil.hpp"
38 #include "glw.h"
39 #include "glwFunctions.hpp"
40 #include "tcuResource.hpp"
41 #include "tcuStringTemplate.hpp"
42 #include "tcuTestLog.hpp"
43 #include "xeXMLParser.hpp"
44
45 #include "glcApiCoverageTests.hpp"
46
47 #include <algorithm>
48 #include <cstring>
49 #include <fstream>
50 #include <memory>
51 #include <sstream>
52 #include <set>
53
54 using namespace glw;
55 using namespace glu;
56
57 #define ENUM(name) \
58 { \
59 #name, name \
60 }
61
62 namespace
63 {
64
65 #define GTF_TEXTURE_FORMAT_IS_ETC(texfmt) \
66 ((texfmt) >= GL_COMPRESSED_R11_EAC && (texfmt) <= GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC)
67 #define GTF_TEXTURE_FORMAT_IS_RGTC(texfmt) \
68 ((texfmt) >= GL_COMPRESSED_RED_RGTC1 && (texfmt) <= GL_COMPRESSED_SIGNED_RG_RGTC2)
69
70 ///////////////////////////////////////////////////////////////
71 /// \brief getEnumNames
72 /// \param e
73 /// \param names
74 ///
75
getEnumNames(const GLenum e,std::set<std::string> & names)76 void getEnumNames(const GLenum e, std::set<std::string> &names)
77 {
78 // clang-format off
79 const char* (*func_ptrs[])(int) = {
80 glu::getErrorName,
81 glu::getTypeName,
82 glu::getParamQueryName,
83 glu::getProgramParamName,
84 glu::getUniformParamName,
85 glu::getFramebufferAttachmentName,
86 glu::getFramebufferAttachmentParameterName,
87 glu::getFramebufferTargetName,
88 glu::getFramebufferStatusName,
89 glu::getFramebufferAttachmentTypeName,
90 glu::getFramebufferColorEncodingName,
91 glu::getFramebufferParameterName,
92 glu::getRenderbufferParameterName,
93 glu::getPrimitiveTypeName,
94 glu::getBlendFactorName,
95 glu::getBlendEquationName,
96 glu::getBufferTargetName,
97 glu::getBufferBindingName,
98 glu::getUsageName,
99 glu::getBufferQueryName,
100 glu::getFaceName,
101 glu::getCompareFuncName,
102 glu::getEnableCapName,
103 glu::getIndexedEnableCapName,
104 glu::getWindingName,
105 glu::getHintModeName,
106 glu::getHintName,
107 glu::getStencilOpName,
108 glu::getShaderTypeName,
109 glu::getBufferName,
110 glu::getInvalidateAttachmentName,
111 glu::getDrawReadBufferName,
112 glu::getTextureTargetName,
113 glu::getTextureParameterName,
114 glu::getTextureLevelParameterName,
115 glu::getRepeatModeName,
116 glu::getTextureFilterName,
117 glu::getTextureWrapModeName,
118 glu::getTextureSwizzleName,
119 glu::getTextureCompareModeName,
120 glu::getCubeMapFaceName,
121 glu::getTextureDepthStencilModeName,
122 glu::getPixelStoreParameterName,
123 glu::getUncompressedTextureFormatName,
124 glu::getCompressedTextureFormatName,
125 glu::getShaderVarTypeName,
126 glu::getShaderParamName,
127 glu::getVertexAttribParameterNameName,
128 glu::getBooleanName,
129 glu::getGettableStateName,
130 glu::getGettableIndexedStateName,
131 glu::getGettableStringName,
132 glu::getGettablePackStateName,
133 glu::getPointerStateName,
134 glu::getInternalFormatParameterName,
135 glu::getInternalFormatTargetName,
136 glu::getMultisampleParameterName,
137 glu::getQueryTargetName,
138 glu::getQueryParamName,
139 glu::getQueryObjectParamName,
140 glu::getImageAccessName,
141 glu::getProgramInterfaceName,
142 glu::getProgramResourcePropertyName,
143 glu::getPrecisionFormatTypeName,
144 glu::getTransformFeedbackTargetName,
145 glu::getClampColorTargetName,
146 glu::getProvokingVertexName,
147 glu::getDebugMessageSourceName,
148 glu::getDebugMessageTypeName,
149 glu::getDebugMessageSeverityName,
150 glu::getPipelineParamName,
151 glu::getPatchParamName,
152 glu::getTextureFormatName,
153 glu::getGraphicsResetStatusName,
154 glu::getClipDistanceParamName,
155 glu::getConditionalRenderParamName,
156 glu::getWaitEnumName,
157 glu::getLogicOpParamsName,
158 glu::getPolygonModeName,
159 glu::getPrimSizeParamName,
160 glu::getActiveTextureParamName,
161 glu::getClipControlParamName,
162 glu::getUniformSubroutinesParamName
163 };
164 // clang-format on
165
166 for (size_t i = 0; i < sizeof(func_ptrs) / sizeof(func_ptrs[0]); i++)
167 if (func_ptrs[i](e) != nullptr)
168 names.insert(func_ptrs[i](e));
169 }
170
isNameWithinBitfield(const std::string & name,const GLenum e)171 bool isNameWithinBitfield(const std::string &name, const GLenum e)
172 {
173 tcu::Format::Bitfield<16> (*func_ptrs[])(int) = {
174 glu::getBufferMaskStr, glu::getBufferMapFlagsStr, glu::getMemoryBarrierFlagsStr, glu::getShaderTypeMaskStr,
175 glu::getContextMaskStr, glu::getClientWaitMaskStr, glu::getContextProfileMaskStr};
176
177 for (size_t i = 0; i < sizeof(func_ptrs) / sizeof(func_ptrs[0]); i++)
178 {
179 auto bitfield = func_ptrs[i](e);
180
181 std::ostringstream sstr;
182 bitfield.toStream(sstr);
183
184 if (sstr.str().find(name) != std::string::npos)
185 return true;
186 }
187
188 return false;
189 }
190
191 } // namespace
192
193 namespace glcts
194 {
195
196 /* Coverage test for glGetUniformIndices */
197 // default shaders
198 const GLchar *ApiCoverageTestCase::m_vert_shader =
199 R"(${VERSION}
200 out vec3 texCoords;
201 in vec2 inPosition;
202 in vec3 inTexCoord;
203 void main() {
204 gl_Position = vec4(inPosition.x, inPosition.y, 0.0,1.0);
205 texCoords = inTexCoord;
206 }
207 )";
208
209 const GLchar *ApiCoverageTestCase::m_frag_shader =
210 R"(${VERSION}
211 ${PRECISION}
212 uniform sampler2D tex0;
213 in vec3 texCoords;
214 out vec4 frag_color;
215 void main() {
216 frag_color = texture(tex0, texCoords.xy);
217 }
218 )";
219
220 std::vector<std::string> ApiCoverageTestCase::m_version_names;
221
222 /** Constructor.
223 *
224 * @param context Rendering context
225 */
ApiCoverageTestCase(deqp::Context & context)226 ApiCoverageTestCase::ApiCoverageTestCase(deqp::Context &context)
227 : TestCase(context, "coverage", "Test case verifies OpenGL API coverage functionality")
228 , m_is_context_ES(false)
229 , m_is_transform_feedback_obj_supported(false)
230 {
231 }
232
233 /** Stub deinit method. */
deinit()234 void ApiCoverageTestCase::deinit()
235 {
236 /* Left blank intentionally */
237 }
238
239 /** Stub init method */
init()240 void ApiCoverageTestCase::init()
241 {
242 glu::resetState(m_context.getRenderContext(), m_context.getContextInfo());
243
244 const glu::RenderContext &renderContext = m_context.getRenderContext();
245 m_is_context_ES = glu::isContextTypeES(renderContext.getType());
246 glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(renderContext.getType());
247 m_context_type = m_context.getRenderContext().getType();
248
249 m_is_transform_feedback_obj_supported =
250 (m_is_context_ES || glu::contextSupports(m_context_type, glu::ApiType::core(4, 0)) ||
251 m_context.getContextInfo().isExtensionSupported("GL_ARB_transform_feedback2"));
252
253 specialization_map["VERSION"] = glu::getGLSLVersionDeclaration(glslVersion);
254
255 if (m_is_context_ES)
256 {
257 specialization_map["EXTENSION"] = "#extension GL_EXT_clip_cull_distance : enable";
258 specialization_map["PRECISION"] = "precision highp float;";
259 if (glu::contextSupports(m_context_type, glu::ApiType::es(3, 0)))
260 {
261 m_config_name = "CoverageES30.test";
262 }
263 }
264 else
265 {
266 specialization_map["EXTENSION"] = "";
267 specialization_map["PRECISION"] = "";
268 if (glu::contextSupports(m_context_type, glu::ApiType::core(4, 3)))
269 {
270 m_config_name = "CoverageGL43.test";
271 }
272 else if (glu::contextSupports(m_context_type, glu::ApiType::core(4, 0)))
273 {
274 m_config_name = "CoverageGL40.test";
275 }
276 else if (glu::contextSupports(m_context_type, glu::ApiType::core(3, 3)))
277 {
278 m_config_name = "CoverageGL33.test";
279 }
280 else if (glu::contextSupports(m_context_type, glu::ApiType::core(3, 2)))
281 {
282 m_config_name = "CoverageGL32.test";
283 }
284 else if (glu::contextSupports(m_context_type, glu::ApiType::core(3, 1)))
285 {
286 m_config_name = "CoverageGL31.test";
287 }
288 else if (glu::contextSupports(m_context_type, glu::ApiType::core(3, 0)))
289 {
290 m_config_name = "CoverageGL30.test";
291 }
292 }
293
294 #ifdef GL_VERSION_1_1
295 m_version_names.push_back("GL_VERSION_1_1");
296 #endif
297 #ifdef GL_VERSION_1_2
298 m_version_names.push_back("GL_VERSION_1_2");
299 #endif
300 #ifdef GL_VERSION_1_3
301 m_version_names.push_back("GL_VERSION_1_3");
302 #endif
303 #ifdef GL_VERSION_1_4
304 m_version_names.push_back("GL_VERSION_1_4");
305 #endif
306 #ifdef GL_VERSION_1_5
307 m_version_names.push_back("GL_VERSION_1_5");
308 #endif
309 #ifdef GL_VERSION_2_0
310 m_version_names.push_back("GL_VERSION_2_0");
311 #endif
312 #ifdef GL_VERSION_2_1
313 m_version_names.push_back("GL_VERSION_2_1");
314 #endif
315 #ifdef GL_VERSION_3_0
316 m_version_names.push_back("GL_VERSION_3_0");
317 #endif
318 #ifdef GL_VERSION_3_1
319 m_version_names.push_back("GL_VERSION_3_1");
320 #endif
321 #ifdef GL_VERSION_3_2
322 m_version_names.push_back("GL_VERSION_3_2");
323 #endif
324 #ifdef GL_VERSION_3_3
325 m_version_names.push_back("GL_VERSION_3_3");
326 #endif
327 #ifdef GL_VERSION_4_0
328 m_version_names.push_back("GL_VERSION_4_0");
329 #endif
330 #ifdef GL_VERSION_4_1
331 m_version_names.push_back("GL_VERSION_4_1");
332 #endif
333 #ifdef GL_VERSION_4_2
334 m_version_names.push_back("GL_VERSION_4_2");
335 #endif
336 #ifdef GL_VERSION_4_3
337 m_version_names.push_back("GL_VERSION_4_3");
338 #endif
339 #ifdef GL_VERSION_4_4
340 m_version_names.push_back("GL_VERSION_4_4");
341 #endif
342 #ifdef GL_VERSION_4_5
343 m_version_names.push_back("GL_VERSION_4_5");
344 #endif
345 #ifdef GL_VERSION_4_6
346 m_version_names.push_back("GL_VERSION_4_6");
347 #endif
348 #ifdef GL_ES_VERSION_3_0
349 m_version_names.push_back("GL_ES_VERSION_3_0");
350 #endif
351
352 if (m_config_name.empty())
353 {
354 m_testCtx.getLog() << tcu::TestLog::Message << "API coverage test not supported.\n" << tcu::TestLog::EndMessage;
355 throw tcu::NotSupportedError("API coverage test not supported");
356 }
357
358 ea_BlendEquation = {ENUM(GL_FUNC_ADD), ENUM(GL_FUNC_SUBTRACT), ENUM(GL_FUNC_REVERSE_SUBTRACT), {"End of List", -1}};
359
360 ea_BlendEquationSeparate1 = {
361 ENUM(GL_FUNC_ADD), ENUM(GL_FUNC_SUBTRACT), ENUM(GL_FUNC_REVERSE_SUBTRACT), {"End of List", -1}};
362
363 ea_BlendEquationSeparate2 = {
364 ENUM(GL_FUNC_ADD), ENUM(GL_FUNC_SUBTRACT), ENUM(GL_FUNC_REVERSE_SUBTRACT), {"End of List", -1}};
365
366 ea_BlendFunc1 = {ENUM(GL_ZERO),
367 ENUM(GL_ONE),
368 ENUM(GL_SRC_COLOR),
369 ENUM(GL_ONE_MINUS_SRC_COLOR),
370 ENUM(GL_DST_COLOR),
371 ENUM(GL_ONE_MINUS_DST_COLOR),
372 ENUM(GL_SRC_ALPHA),
373 ENUM(GL_ONE_MINUS_SRC_ALPHA),
374 ENUM(GL_DST_ALPHA),
375 ENUM(GL_ONE_MINUS_DST_ALPHA),
376 ENUM(GL_CONSTANT_COLOR),
377 ENUM(GL_ONE_MINUS_CONSTANT_COLOR),
378 ENUM(GL_CONSTANT_ALPHA),
379 ENUM(GL_ONE_MINUS_CONSTANT_ALPHA),
380 ENUM(GL_SRC_ALPHA_SATURATE),
381 {"End of List", -1}};
382
383 ea_BlendFunc2 = {ENUM(GL_ZERO), ENUM(GL_ONE),
384 ENUM(GL_SRC_COLOR), ENUM(GL_ONE_MINUS_SRC_COLOR),
385 ENUM(GL_DST_COLOR), ENUM(GL_ONE_MINUS_DST_COLOR),
386 ENUM(GL_SRC_ALPHA), ENUM(GL_ONE_MINUS_SRC_ALPHA),
387 ENUM(GL_DST_ALPHA), ENUM(GL_ONE_MINUS_DST_ALPHA),
388 ENUM(GL_CONSTANT_COLOR), ENUM(GL_ONE_MINUS_CONSTANT_COLOR),
389 ENUM(GL_CONSTANT_ALPHA), ENUM(GL_ONE_MINUS_CONSTANT_ALPHA),
390 {"End of List", -1}};
391
392 ea_BlendFuncSeparate1 = {ENUM(GL_ZERO),
393 ENUM(GL_ONE),
394 ENUM(GL_SRC_COLOR),
395 ENUM(GL_ONE_MINUS_SRC_COLOR),
396 ENUM(GL_DST_COLOR),
397 ENUM(GL_ONE_MINUS_DST_COLOR),
398 ENUM(GL_SRC_ALPHA),
399 ENUM(GL_ONE_MINUS_SRC_ALPHA),
400 ENUM(GL_DST_ALPHA),
401 ENUM(GL_ONE_MINUS_DST_ALPHA),
402 ENUM(GL_CONSTANT_COLOR),
403 ENUM(GL_ONE_MINUS_CONSTANT_COLOR),
404 ENUM(GL_CONSTANT_ALPHA),
405 ENUM(GL_ONE_MINUS_CONSTANT_ALPHA),
406 ENUM(GL_SRC_ALPHA_SATURATE),
407 {"End of List", -1}};
408
409 ea_BlendFuncSeparate2 = {ENUM(GL_ZERO), ENUM(GL_ONE),
410 ENUM(GL_SRC_COLOR), ENUM(GL_ONE_MINUS_SRC_COLOR),
411 ENUM(GL_DST_COLOR), ENUM(GL_ONE_MINUS_DST_COLOR),
412 ENUM(GL_SRC_ALPHA), ENUM(GL_ONE_MINUS_SRC_ALPHA),
413 ENUM(GL_DST_ALPHA), ENUM(GL_ONE_MINUS_DST_ALPHA),
414 ENUM(GL_CONSTANT_COLOR), ENUM(GL_ONE_MINUS_CONSTANT_COLOR),
415 ENUM(GL_CONSTANT_ALPHA), ENUM(GL_ONE_MINUS_CONSTANT_ALPHA),
416 {"End of List", -1}};
417
418 ea_BlendFuncSeparate3 = {ENUM(GL_ZERO),
419 ENUM(GL_ONE),
420 ENUM(GL_SRC_COLOR),
421 ENUM(GL_ONE_MINUS_SRC_COLOR),
422 ENUM(GL_DST_COLOR),
423 ENUM(GL_ONE_MINUS_DST_COLOR),
424 ENUM(GL_SRC_ALPHA),
425 ENUM(GL_ONE_MINUS_SRC_ALPHA),
426 ENUM(GL_DST_ALPHA),
427 ENUM(GL_ONE_MINUS_DST_ALPHA),
428 ENUM(GL_CONSTANT_COLOR),
429 ENUM(GL_ONE_MINUS_CONSTANT_COLOR),
430 ENUM(GL_CONSTANT_ALPHA),
431 ENUM(GL_ONE_MINUS_CONSTANT_ALPHA),
432 ENUM(GL_SRC_ALPHA_SATURATE),
433 {"End of List", -1}};
434
435 ea_BlendFuncSeparate4 = {ENUM(GL_ZERO), ENUM(GL_ONE),
436 ENUM(GL_SRC_COLOR), ENUM(GL_ONE_MINUS_SRC_COLOR),
437 ENUM(GL_DST_COLOR), ENUM(GL_ONE_MINUS_DST_COLOR),
438 ENUM(GL_SRC_ALPHA), ENUM(GL_ONE_MINUS_SRC_ALPHA),
439 ENUM(GL_DST_ALPHA), ENUM(GL_ONE_MINUS_DST_ALPHA),
440 ENUM(GL_CONSTANT_COLOR), ENUM(GL_ONE_MINUS_CONSTANT_COLOR),
441 ENUM(GL_CONSTANT_ALPHA), ENUM(GL_ONE_MINUS_CONSTANT_ALPHA),
442 {"End of List", -1}};
443
444 ea_BufferObjectTargets = {ENUM(GL_ARRAY_BUFFER), ENUM(GL_ELEMENT_ARRAY_BUFFER), {"End of List", -1}};
445
446 ea_BufferObjectUsages = {ENUM(GL_STATIC_DRAW), ENUM(GL_DYNAMIC_DRAW), ENUM(GL_STREAM_DRAW), {"End of List", -1}};
447
448 ea_ClearBufferMask = {
449 ENUM(GL_DEPTH_BUFFER_BIT), ENUM(GL_STENCIL_BUFFER_BIT), ENUM(GL_COLOR_BUFFER_BIT), {"End of List", -1}};
450
451 ea_CompressedTextureFormats = {{"End of List", -1}};
452
453 ea_ShaderTypes = {ENUM(GL_VERTEX_SHADER), ENUM(GL_FRAGMENT_SHADER), {"End of List", -1}};
454
455 ea_CullFaceMode = {ENUM(GL_FRONT), ENUM(GL_BACK), ENUM(GL_FRONT_AND_BACK), {"End of List", -1}};
456
457 ea_DepthFunction = {ENUM(GL_NEVER), ENUM(GL_LESS), ENUM(GL_EQUAL), ENUM(GL_LEQUAL), ENUM(GL_GREATER),
458 ENUM(GL_NOTEQUAL), ENUM(GL_GEQUAL), ENUM(GL_ALWAYS), {"End of List", -1}};
459
460 ea_Enable = {ENUM(GL_CULL_FACE),
461 ENUM(GL_BLEND),
462 ENUM(GL_DITHER),
463 ENUM(GL_STENCIL_TEST),
464 ENUM(GL_DEPTH_TEST),
465 ENUM(GL_SAMPLE_COVERAGE),
466 ENUM(GL_SAMPLE_ALPHA_TO_COVERAGE),
467 ENUM(GL_SCISSOR_TEST),
468 ENUM(GL_POLYGON_OFFSET_FILL),
469 {"End of List", -1}};
470
471 ea_Primitives = {ENUM(GL_LINE_LOOP), ENUM(GL_LINE_STRIP), ENUM(GL_LINES), ENUM(GL_POINTS),
472 ENUM(GL_TRIANGLE_STRIP), ENUM(GL_TRIANGLE_FAN), ENUM(GL_TRIANGLES), {"End of List", -1}};
473
474 ea_Face = {ENUM(GL_FRONT), ENUM(GL_BACK), ENUM(GL_FRONT_AND_BACK), {"End of List", -1}};
475
476 ea_FrameBufferTargets = {ENUM(GL_FRAMEBUFFER), {"End of List", -1}};
477
478 ea_FrameBufferAttachments = {
479 ENUM(GL_COLOR_ATTACHMENT0), ENUM(GL_DEPTH_ATTACHMENT), ENUM(GL_STENCIL_ATTACHMENT), {"End of List", -1}};
480
481 ea_FrontFaceDirection = {ENUM(GL_CW), ENUM(GL_CCW), {"End of List", -1}};
482
483 ea_GetBoolean = {
484 ENUM(GL_SAMPLE_COVERAGE_INVERT), ENUM(GL_COLOR_WRITEMASK), ENUM(GL_DEPTH_WRITEMASK), {"End of List", -1}};
485
486 ea_GetBufferParameter = {ENUM(GL_BUFFER_SIZE), ENUM(GL_BUFFER_USAGE), {"End of List", -1}};
487
488 ea_GetBufferParameter_OES_mapbuffer = {{"End of List", -1}};
489
490 ea_GetFloat = {ENUM(GL_DEPTH_RANGE),
491 ENUM(GL_LINE_WIDTH),
492 ENUM(GL_POLYGON_OFFSET_FACTOR),
493 ENUM(GL_POLYGON_OFFSET_UNITS),
494 ENUM(GL_SAMPLE_COVERAGE_VALUE),
495 ENUM(GL_COLOR_CLEAR_VALUE),
496 ENUM(GL_BLEND_COLOR),
497 ENUM(GL_ALIASED_LINE_WIDTH_RANGE),
498 {"End of List", -1}};
499
500 ea_GetFramebufferAttachmentParameter = {ENUM(GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE),
501 ENUM(GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME),
502 ENUM(GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL),
503 ENUM(GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE),
504 {"End of List", -1}};
505
506 ea_GetInteger = {ENUM(GL_ARRAY_BUFFER_BINDING),
507 ENUM(GL_ELEMENT_ARRAY_BUFFER_BINDING),
508 ENUM(GL_VIEWPORT),
509 ENUM(GL_CULL_FACE_MODE),
510 ENUM(GL_FRONT_FACE),
511 ENUM(GL_TEXTURE_BINDING_2D),
512 ENUM(GL_TEXTURE_BINDING_CUBE_MAP),
513 ENUM(GL_ACTIVE_TEXTURE),
514 ENUM(GL_STENCIL_WRITEMASK),
515 ENUM(GL_DEPTH_CLEAR_VALUE),
516 ENUM(GL_STENCIL_CLEAR_VALUE),
517 ENUM(GL_SCISSOR_BOX),
518 ENUM(GL_STENCIL_FUNC),
519 ENUM(GL_STENCIL_VALUE_MASK),
520 ENUM(GL_STENCIL_REF),
521 ENUM(GL_STENCIL_FAIL),
522 ENUM(GL_STENCIL_PASS_DEPTH_FAIL),
523 ENUM(GL_STENCIL_PASS_DEPTH_PASS),
524 ENUM(GL_STENCIL_BACK_FUNC),
525 ENUM(GL_STENCIL_BACK_VALUE_MASK),
526 ENUM(GL_STENCIL_BACK_REF),
527 ENUM(GL_STENCIL_BACK_FAIL),
528 ENUM(GL_STENCIL_PASS_DEPTH_FAIL),
529 ENUM(GL_STENCIL_PASS_DEPTH_PASS),
530 ENUM(GL_DEPTH_FUNC),
531 ENUM(GL_BLEND_SRC_RGB),
532 ENUM(GL_BLEND_SRC_ALPHA),
533 ENUM(GL_BLEND_DST_RGB),
534 ENUM(GL_BLEND_DST_ALPHA),
535 ENUM(GL_BLEND_EQUATION_RGB),
536 ENUM(GL_BLEND_EQUATION_ALPHA),
537 ENUM(GL_UNPACK_ALIGNMENT),
538 ENUM(GL_PACK_ALIGNMENT),
539 ENUM(GL_CURRENT_PROGRAM),
540 ENUM(GL_SUBPIXEL_BITS),
541 ENUM(GL_MAX_TEXTURE_SIZE),
542 ENUM(GL_MAX_CUBE_MAP_TEXTURE_SIZE),
543 ENUM(GL_MAX_VIEWPORT_DIMS),
544 ENUM(GL_SAMPLE_BUFFERS),
545 ENUM(GL_SAMPLES),
546 ENUM(GL_COMPRESSED_TEXTURE_FORMATS),
547 ENUM(GL_NUM_COMPRESSED_TEXTURE_FORMATS),
548 ENUM(GL_MAX_VERTEX_ATTRIBS),
549 ENUM(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS),
550 ENUM(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS),
551 ENUM(GL_MAX_TEXTURE_IMAGE_UNITS),
552 {"End of List", -1}};
553
554 ea_GetInteger_OES_Texture_3D = {{"End of List", -1}};
555
556 ea_GetPointer = {ENUM(GL_VERTEX_ATTRIB_ARRAY_POINTER), {"End of List", -1}};
557
558 ea_HintTarget_OES_fragment_shader_derivative = {{"End of List", -1}};
559
560 ea_InvalidRenderBufferFormats = {{"End of List", -1}};
561
562 ea_RenderBufferFormats_OES_rgb8_rgba8 = {{"End of List", -1}};
563
564 ea_RenderBufferFormats_OES_depth_component24 = {{"End of List", -1}};
565
566 ea_RenderBufferFormats_OES_depth_component32 = {{"End of List", -1}};
567
568 ea_RenderBufferFormats_OES_stencil1 = {{"End of List", -1}};
569
570 ea_RenderBufferFormats_OES_stencil4 = {{"End of List", -1}};
571
572 ea_ShaderPrecision = {{"End of List", -1}};
573
574 ea_GetIntegerES3 = {{"End of List", -1}};
575
576 ea_GetProgram = {ENUM(GL_DELETE_STATUS),
577 ENUM(GL_LINK_STATUS),
578 ENUM(GL_VALIDATE_STATUS),
579 ENUM(GL_ATTACHED_SHADERS),
580 ENUM(GL_INFO_LOG_LENGTH),
581 ENUM(GL_ACTIVE_UNIFORMS),
582 ENUM(GL_ACTIVE_UNIFORM_MAX_LENGTH),
583 ENUM(GL_ACTIVE_ATTRIBUTES),
584 ENUM(GL_ACTIVE_ATTRIBUTE_MAX_LENGTH),
585 {"End of List", -1}};
586
587 ea_GetRenderBufferParameter = {ENUM(GL_RENDERBUFFER_WIDTH),
588 ENUM(GL_RENDERBUFFER_HEIGHT),
589 ENUM(GL_RENDERBUFFER_INTERNAL_FORMAT),
590 {"End of List", -1}};
591
592 ea_GetShaderStatus = {ENUM(GL_SHADER_TYPE), ENUM(GL_DELETE_STATUS), ENUM(GL_COMPILE_STATUS),
593 ENUM(GL_INFO_LOG_LENGTH), ENUM(GL_SHADER_SOURCE_LENGTH), {"End of List", -1}};
594
595 ea_GetString = {
596 ENUM(GL_RENDERER), ENUM(GL_SHADING_LANGUAGE_VERSION), ENUM(GL_VENDOR), ENUM(GL_VERSION), {"End of List", -1}};
597
598 ea_GetTexParameter = {ENUM(GL_TEXTURE_MIN_FILTER),
599 ENUM(GL_TEXTURE_MAG_FILTER),
600 ENUM(GL_TEXTURE_WRAP_S),
601 ENUM(GL_TEXTURE_WRAP_T),
602 {"End of List", -1}};
603
604 ea_GetVertexAttrib = {ENUM(GL_VERTEX_ATTRIB_ARRAY_ENABLED), ENUM(GL_VERTEX_ATTRIB_ARRAY_SIZE),
605 ENUM(GL_VERTEX_ATTRIB_ARRAY_STRIDE), ENUM(GL_VERTEX_ATTRIB_ARRAY_TYPE),
606 ENUM(GL_VERTEX_ATTRIB_ARRAY_NORMALIZED), {"End of List", -1}};
607
608 ea_GetVertexAttribPointer = {ENUM(GL_VERTEX_ATTRIB_ARRAY_POINTER), {"End of List", -1}};
609
610 ea_HintMode = {ENUM(GL_FASTEST), ENUM(GL_NICEST), ENUM(GL_DONT_CARE), {"End of List", -1}};
611
612 ea_HintTarget = {{"End of List", -1}};
613
614 ea_PixelStore = {ENUM(GL_PACK_ALIGNMENT), ENUM(GL_UNPACK_ALIGNMENT), {"End of List", -1}};
615
616 ea_RenderBufferFormats = {
617 ENUM(GL_RGBA4), ENUM(GL_RGB5_A1), ENUM(GL_DEPTH_COMPONENT16), ENUM(GL_STENCIL_INDEX8), {"End of List", -1}};
618
619 ea_RenderBufferTargets = {ENUM(GL_RENDERBUFFER), {"End of List", -1}};
620
621 ea_RenderBufferInvalidTargets = {ENUM(GL_RENDERBUFFER + 1), {"End of List", -1}};
622
623 ea_StencilFunction = {ENUM(GL_NEVER), ENUM(GL_LESS), ENUM(GL_EQUAL), ENUM(GL_LEQUAL), ENUM(GL_GREATER),
624 ENUM(GL_NOTEQUAL), ENUM(GL_GEQUAL), ENUM(GL_ALWAYS), {"End of List", -1}};
625
626 ea_StencilOp = {ENUM(GL_ZERO), ENUM(GL_KEEP), ENUM(GL_REPLACE), ENUM(GL_INCR), ENUM(GL_DECR),
627 ENUM(GL_INVERT), ENUM(GL_INCR_WRAP), ENUM(GL_DECR_WRAP), {"End of List", -1}};
628
629 ea_TextureFormat = {{"End of List", -1}};
630
631 ea_TextureMagFilter = {ENUM(GL_NEAREST), ENUM(GL_LINEAR), {"End of List", -1}};
632
633 ea_TextureMinFilter = {ENUM(GL_NEAREST),
634 ENUM(GL_LINEAR),
635 ENUM(GL_NEAREST_MIPMAP_NEAREST),
636 ENUM(GL_LINEAR_MIPMAP_NEAREST),
637 ENUM(GL_NEAREST_MIPMAP_LINEAR),
638 ENUM(GL_LINEAR_MIPMAP_LINEAR),
639 {"End of List", -1}};
640
641 ea_TextureTarget = {ENUM(GL_TEXTURE_2D), {"End of List", -1}};
642
643 ea_TextureType = {ENUM(GL_UNSIGNED_BYTE), ENUM(GL_UNSIGNED_BYTE), ENUM(GL_UNSIGNED_SHORT_5_6_5),
644 ENUM(GL_UNSIGNED_BYTE), ENUM(GL_UNSIGNED_SHORT_4_4_4_4), ENUM(GL_UNSIGNED_SHORT_5_5_5_1),
645 ENUM(GL_UNSIGNED_BYTE), ENUM(GL_UNSIGNED_BYTE), {"End of List", -1}};
646
647 ea_TextureWrapMode = {ENUM(GL_CLAMP_TO_EDGE), ENUM(GL_REPEAT), {"End of List", -1}};
648
649 ea_GetBufferParameteri64v = {ENUM(GL_BUFFER_MAP_LENGTH), ENUM(GL_BUFFER_MAP_OFFSET), ENUM(GL_BUFFER_MAPPED),
650 ENUM(GL_BUFFER_ACCESS_FLAGS), ENUM(GL_BUFFER_USAGE), ENUM(GL_BUFFER_SIZE),
651 {"End of List", -1}};
652
653 ea_ReadBuffer = {ENUM(GL_NONE),
654 ENUM(GL_BACK),
655 ENUM(GL_COLOR_ATTACHMENT0),
656 ENUM(GL_COLOR_ATTACHMENT1),
657 ENUM(GL_COLOR_ATTACHMENT2),
658 ENUM(GL_COLOR_ATTACHMENT3),
659 {"End of List", -1}};
660
661 ea_Texture3DTarget = {ENUM(GL_TEXTURE_3D), ENUM(GL_TEXTURE_2D_ARRAY), {"End of List", -1}};
662
663 ea_CompressedTexture3DTarget = {ENUM(GL_TEXTURE_2D_ARRAY), {"End of List", -1}};
664
665 ea_CompressedTextureFormat = {/* RGTC */
666 ENUM(GL_COMPRESSED_RED_RGTC1),
667 ENUM(GL_COMPRESSED_SIGNED_RED_RGTC1),
668 ENUM(GL_COMPRESSED_RG_RGTC2),
669 ENUM(GL_COMPRESSED_SIGNED_RG_RGTC2),
670 /* ETC2/EAC */
671 ENUM(GL_COMPRESSED_R11_EAC),
672 ENUM(GL_COMPRESSED_RG11_EAC),
673 ENUM(GL_COMPRESSED_SIGNED_R11_EAC),
674 ENUM(GL_COMPRESSED_SIGNED_RG11_EAC),
675 ENUM(GL_COMPRESSED_RGB8_ETC2),
676 ENUM(GL_COMPRESSED_SRGB8_ETC2),
677 ENUM(GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2),
678 ENUM(GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2),
679 ENUM(GL_COMPRESSED_RGBA8_ETC2_EAC),
680 ENUM(GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC),
681 {"End of List", -1}};
682 CompressedTextureSize = {8, 8, 16, 16, /* RGTC */
683 8, 16, 8, 16, 8, 8, 8, 8, 16, 16 /* ETC2/EAC */};
684
685 ea_DrawBuffers = {ENUM(GL_COLOR_ATTACHMENT0),
686 ENUM(GL_COLOR_ATTACHMENT1),
687 ENUM(GL_COLOR_ATTACHMENT2),
688 ENUM(GL_COLOR_ATTACHMENT3),
689 {"End of List", -1}};
690
691 ea_GetInteger64v = {ENUM(GL_MAX_ELEMENT_INDEX),
692 ENUM(GL_MAX_SERVER_WAIT_TIMEOUT),
693 ENUM(GL_MAX_UNIFORM_BLOCK_SIZE),
694 ENUM(GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS),
695 ENUM(GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS),
696 {"End of List", -1}};
697
698 ea_GetSynciv = {
699 ENUM(GL_OBJECT_TYPE), ENUM(GL_SYNC_STATUS), ENUM(GL_SYNC_CONDITION), ENUM(GL_SYNC_FLAGS), {"End of List", -1}};
700
701 ea_InvalidateFramebuffer = {{"End of List", -1}};
702
703 if (m_is_context_ES)
704 {
705 ea_CompressedTextureFormats = {ENUM(GL_PALETTE4_RGB8_OES),
706 ENUM(GL_PALETTE4_RGBA8_OES),
707 ENUM(GL_PALETTE4_R5_G6_B5_OES),
708 ENUM(GL_PALETTE4_RGBA4_OES),
709 ENUM(GL_PALETTE4_RGB5_A1_OES),
710 ENUM(GL_PALETTE8_RGB8_OES),
711 ENUM(GL_PALETTE8_RGBA8_OES),
712 ENUM(GL_PALETTE8_R5_G6_B5_OES),
713 ENUM(GL_PALETTE8_RGBA4_OES),
714 ENUM(GL_PALETTE8_RGB5_A1_OES),
715 {"End of List", -1}};
716
717 ea_GetBufferParameter_OES_mapbuffer = {
718 ENUM(GL_BUFFER_ACCESS_OES), ENUM(GL_BUFFER_MAPPED_OES), {"End of List", -1}};
719
720 ea_GetFloat.insert(ea_GetFloat.begin(), ENUM(GL_ALIASED_POINT_SIZE_RANGE));
721
722 ea_GetInteger.insert(ea_GetInteger.begin(), ENUM(GL_GENERATE_MIPMAP_HINT));
723 ea_GetInteger.insert(ea_GetInteger.begin(), ENUM(GL_MAX_VERTEX_UNIFORM_VECTORS));
724 ea_GetInteger.insert(ea_GetInteger.begin(), ENUM(GL_MAX_VARYING_VECTORS));
725 ea_GetInteger.insert(ea_GetInteger.begin(), ENUM(GL_MAX_FRAGMENT_UNIFORM_VECTORS));
726 ea_GetInteger.insert(ea_GetInteger.begin(), ENUM(GL_RED_BITS));
727 ea_GetInteger.insert(ea_GetInteger.begin(), ENUM(GL_GREEN_BITS));
728 ea_GetInteger.insert(ea_GetInteger.begin(), ENUM(GL_BLUE_BITS));
729 ea_GetInteger.insert(ea_GetInteger.begin(), ENUM(GL_ALPHA_BITS));
730 ea_GetInteger.insert(ea_GetInteger.begin(), ENUM(GL_DEPTH_BITS));
731 ea_GetInteger.insert(ea_GetInteger.begin(), ENUM(GL_STENCIL_BITS));
732 ea_GetInteger.insert(ea_GetInteger.begin(), ENUM(GL_IMPLEMENTATION_COLOR_READ_TYPE));
733 ea_GetInteger.insert(ea_GetInteger.begin(), ENUM(GL_IMPLEMENTATION_COLOR_READ_FORMAT));
734
735 ea_GetInteger_OES_Texture_3D = {
736 ENUM(GL_TEXTURE_BINDING_3D_OES), ENUM(GL_MAX_3D_TEXTURE_SIZE_OES), {"End of List", -1}};
737
738 ea_GetPointer = {ENUM(GL_VERTEX_ATTRIB_ARRAY_POINTER), ENUM(GL_BUFFER_MAP_POINTER_OES), {"End of List", -1}};
739
740 ea_HintTarget_OES_fragment_shader_derivative = {ENUM(GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES),
741 {"End of List", -1}};
742
743 ea_InvalidRenderBufferFormats = {ENUM(GL_RGB), ENUM(GL_RGBA), {"End of List", -1}};
744
745 ea_RenderBufferFormats_OES_rgb8_rgba8 = {ENUM(GL_RGB8_OES), ENUM(GL_RGBA8_OES), {"End of List", -1}};
746
747 ea_RenderBufferFormats_OES_depth_component24 = {ENUM(GL_DEPTH_COMPONENT24_OES), {"End of List", -1}};
748
749 ea_RenderBufferFormats_OES_depth_component32 = {ENUM(GL_DEPTH_COMPONENT32_OES), {"End of List", -1}};
750
751 ea_RenderBufferFormats_OES_stencil1 = {ENUM(GL_STENCIL_INDEX1_OES), {"End of List", -1}};
752
753 ea_RenderBufferFormats_OES_stencil4 = {ENUM(GL_STENCIL_INDEX4_OES), {"End of List", -1}};
754
755 ea_ShaderPrecision = {ENUM(GL_LOW_FLOAT), ENUM(GL_MEDIUM_FLOAT), ENUM(GL_HIGH_FLOAT), ENUM(GL_LOW_INT),
756 ENUM(GL_MEDIUM_INT), ENUM(GL_HIGH_INT), {"End of List", -1}};
757
758 ea_GetString = {ENUM(GL_EXTENSIONS), ENUM(GL_RENDERER), ENUM(GL_SHADING_LANGUAGE_VERSION),
759 ENUM(GL_VENDOR), ENUM(GL_VERSION), {"End of List", -1}};
760
761 ea_HintTarget.insert(ea_HintTarget.begin(), ENUM(GL_GENERATE_MIPMAP_HINT));
762
763 ea_RenderBufferFormats.insert(ea_RenderBufferFormats.begin(), ENUM(GL_RGB565));
764
765 ea_TextureFormat = {ENUM(GL_ALPHA), ENUM(GL_RGB), ENUM(GL_RGB), ENUM(GL_RGBA),
766 ENUM(GL_RGBA), ENUM(GL_RGBA), ENUM(GL_LUMINANCE), ENUM(GL_LUMINANCE_ALPHA),
767 {"End of List", -1}};
768
769 if (glu::contextSupports(m_context_type, glu::ApiType::es(3, 0)))
770 {
771 ea_GetIntegerES3 = {ENUM(GL_MAX_VARYING_COMPONENTS), {"End of List", -1}};
772
773 ea_GetVertexAttrib = {ENUM(GL_VERTEX_ATTRIB_ARRAY_ENABLED),
774 ENUM(GL_VERTEX_ATTRIB_ARRAY_SIZE),
775 ENUM(GL_VERTEX_ATTRIB_ARRAY_STRIDE),
776 ENUM(GL_VERTEX_ATTRIB_ARRAY_TYPE),
777 ENUM(GL_VERTEX_ATTRIB_ARRAY_NORMALIZED),
778 ENUM(GL_VERTEX_ATTRIB_ARRAY_INTEGER),
779 {"End of List", -1}};
780
781 ea_HintTarget.insert(ea_HintTarget.begin(), ENUM(GL_FRAGMENT_SHADER_DERIVATIVE_HINT));
782
783 ea_CompressedTextureFormat = {ENUM(GL_COMPRESSED_R11_EAC),
784 ENUM(GL_COMPRESSED_RG11_EAC),
785 ENUM(GL_COMPRESSED_SIGNED_R11_EAC),
786 ENUM(GL_COMPRESSED_SIGNED_RG11_EAC),
787 ENUM(GL_COMPRESSED_RGB8_ETC2),
788 ENUM(GL_COMPRESSED_SRGB8_ETC2),
789 ENUM(GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2),
790 ENUM(GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2),
791 ENUM(GL_COMPRESSED_RGBA8_ETC2_EAC),
792 ENUM(GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC),
793 {"End of List", -1}};
794 CompressedTextureSize = {8, 16, 8, 16, 8, 8, 8, 8, 16, 16};
795
796 ea_InvalidateFramebuffer = {
797 ENUM(GL_FRAMEBUFFER), ENUM(GL_DRAW_FRAMEBUFFER), ENUM(GL_READ_FRAMEBUFFER), {"End of List", -1}};
798
799 // clang-format off
800 funcs_map.insert({ "glReadBuffer", &ApiCoverageTestCase::TestCoverageGLCallReadBuffer });
801 funcs_map.insert({ "glDrawRangeElements", &ApiCoverageTestCase::TestCoverageGLCallDrawRangeElements });
802 funcs_map.insert({ "glTexImage3D", &ApiCoverageTestCase::TestCoverageGLCallTexImage3D });
803 funcs_map.insert({ "glTexSubImage3D", &ApiCoverageTestCase::TestCoverageGLCallTexSubImage3D });
804 funcs_map.insert({ "glCompressedTexImage3D", &ApiCoverageTestCase::TestCoverageGLCallCompressedTexImage3D });
805 funcs_map.insert({ "glCompressedTexSubImage3D", &ApiCoverageTestCase::TestCoverageGLCallCompressedTexSubImage3D });
806 funcs_map.insert({ "glGenQueries", &ApiCoverageTestCase::TestCoverageGLCallGenQueries });
807 funcs_map.insert({ "glDeleteQueries", &ApiCoverageTestCase::TestCoverageGLCallDeleteQueries });
808 funcs_map.insert({ "glIsQuery", &ApiCoverageTestCase::TestCoverageGLCallIsQuery });
809 funcs_map.insert({ "glBeginQuery", &ApiCoverageTestCase::TestCoverageGLCallBeginQuery });
810 funcs_map.insert({ "glEndQuery", &ApiCoverageTestCase::TestCoverageGLCallEndQuery });
811 funcs_map.insert({ "glGetQueryiv", &ApiCoverageTestCase::TestCoverageGLCallGetQueryiv });
812 funcs_map.insert({ "glGetQueryObjectuiv", &ApiCoverageTestCase::TestCoverageGLCallGetQueryObjectuiv });
813 funcs_map.insert({ "glMapBufferRange", &ApiCoverageTestCase::TestCoverageGLCallMapBufferRange });
814 funcs_map.insert({ "glUnmapBuffer", &ApiCoverageTestCase::TestCoverageGLCallUnmapBuffer });
815 funcs_map.insert({ "glGetBufferPointerv", &ApiCoverageTestCase::TestCoverageGLCallGetBufferPointerv });
816 funcs_map.insert({ "glFlushMappedBufferRange", &ApiCoverageTestCase::TestCoverageGLCallFlushMappedBufferRange });
817 funcs_map.insert({ "glDrawBuffers", &ApiCoverageTestCase::TestCoverageGLCallDrawBuffers });
818 funcs_map.insert({ "glUniformMatrix2x4fv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix2x4fv });
819 funcs_map.insert({ "glBeginTransformFeedback", &ApiCoverageTestCase::TestCoverageGLCallBeginTransformFeedback });
820 funcs_map.insert({ "glEndTransformFeedback", &ApiCoverageTestCase::TestCoverageGLCallEndTransformFeedback });
821 funcs_map.insert({ "glBindBufferRange", &ApiCoverageTestCase::TestCoverageGLCallBindBufferRange });
822 funcs_map.insert({ "glBindBufferBase", &ApiCoverageTestCase::TestCoverageGLCallBindBufferBase });
823 funcs_map.insert({ "glTransformFeedbackVaryings", &ApiCoverageTestCase::TestCoverageGLCallTransformFeedbackVaryings });
824 funcs_map.insert({ "glGetTransformFeedbackVarying", &ApiCoverageTestCase::TestCoverageGLCallGetTransformFeedbackVarying });
825 funcs_map.insert({ "glVertexAttribIPointer", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribIPointer });
826 funcs_map.insert({ "glGetVertexAttribIiv", &ApiCoverageTestCase::TestCoverageGLCallGetVertexAttribIiv });
827 funcs_map.insert({ "glGetVertexAttribIuiv", &ApiCoverageTestCase::TestCoverageGLCallGetVertexAttribIuiv });
828 funcs_map.insert({ "glVertexAttribI4i", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4i });
829 funcs_map.insert({ "glVertexAttribI4ui", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4ui });
830 funcs_map.insert({ "glVertexAttribI4iv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4iv });
831 funcs_map.insert({ "glVertexAttribI4uiv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4uiv });
832 funcs_map.insert({ "glGetUniformuiv", &ApiCoverageTestCase::TestCoverageGLCallGetUniformuiv });
833 funcs_map.insert({ "glGetFragDataLocation", &ApiCoverageTestCase::TestCoverageGLCallGetFragDataLocation });
834 funcs_map.insert({ "glUniform2ui", &ApiCoverageTestCase::TestCoverageGLCallUniform2ui });
835 funcs_map.insert({ "glUniform2uiv", &ApiCoverageTestCase::TestCoverageGLCallUniform2uiv });
836 funcs_map.insert({ "glClearBufferiv", &ApiCoverageTestCase::TestCoverageGLCallClearBufferiv });
837 funcs_map.insert({ "glClearBufferuiv", &ApiCoverageTestCase::TestCoverageGLCallClearBufferuiv });
838 funcs_map.insert({ "glClearBufferfv", &ApiCoverageTestCase::TestCoverageGLCallClearBufferfv });
839 funcs_map.insert({ "glClearBufferfi", &ApiCoverageTestCase::TestCoverageGLCallClearBufferfi });
840 funcs_map.insert({ "glGetStringi", &ApiCoverageTestCase::TestCoverageGLCallGetStringi });
841 funcs_map.insert({ "glBlitFramebuffer", &ApiCoverageTestCase::TestCoverageGLCallBlitFramebuffer });
842 funcs_map.insert({ "glRenderbufferStorageMultisample", &ApiCoverageTestCase::TestCoverageGLCallRenderbufferStorageMultisample });
843 funcs_map.insert({ "glBindVertexArray", &ApiCoverageTestCase::TestCoverageGLCallBindVertexArray });
844 funcs_map.insert({ "glDeleteVertexArrays", &ApiCoverageTestCase::TestCoverageGLCallDeleteVertexArrays });
845 funcs_map.insert({ "glGenVertexArrays", &ApiCoverageTestCase::TestCoverageGLCallGenVertexArrays });
846 funcs_map.insert({ "glIsVertexArray", &ApiCoverageTestCase::TestCoverageGLCallIsVertexArray });
847 funcs_map.insert({ "glDrawArraysInstanced", &ApiCoverageTestCase::TestCoverageGLCallDrawArraysInstanced });
848 funcs_map.insert({ "glDrawElementsInstanced", &ApiCoverageTestCase::TestCoverageGLCallDrawElementsInstanced });
849 funcs_map.insert({ "glCopyBufferSubData", &ApiCoverageTestCase::TestCoverageGLCallCopyBufferSubData });
850 funcs_map.insert({ "glGetUniformIndices", &ApiCoverageTestCase::TestCoverageGLCallGetUniformIndices });
851 funcs_map.insert({ "glGetActiveUniformsiv", &ApiCoverageTestCase::TestCoverageGLCallGetActiveUniformsiv });
852 funcs_map.insert({ "glGetUniformBlockIndex", &ApiCoverageTestCase::TestCoverageGLCallGetUniformBlockIndex });
853 funcs_map.insert({ "glGetActiveUniformBlockiv", &ApiCoverageTestCase::TestCoverageGLCallGetActiveUniformBlockiv });
854 funcs_map.insert({ "glGetActiveUniformBlockName", &ApiCoverageTestCase::TestCoverageGLCallGetActiveUniformBlockName });
855 funcs_map.insert({ "glUniformBlockBinding", &ApiCoverageTestCase::TestCoverageGLCallUniformBlockBinding });
856 funcs_map.insert({ "glGetBufferParameteri64v", &ApiCoverageTestCase::TestCoverageGLCallGetBufferParameteri64v });
857 funcs_map.insert({ "glProgramParameteri", &ApiCoverageTestCase::TestCoverageGLCallProgramParameteri });
858 funcs_map.insert({ "glFenceSync", &ApiCoverageTestCase::TestCoverageGLCallFenceSync });
859 funcs_map.insert({ "glIsSync", &ApiCoverageTestCase::TestCoverageGLCallIsSync });
860 funcs_map.insert({ "glDeleteSync", &ApiCoverageTestCase::TestCoverageGLCallDeleteSync });
861 funcs_map.insert({ "glClientWaitSync", &ApiCoverageTestCase::TestCoverageGLCallClientWaitSync });
862 funcs_map.insert({ "glWaitSync", &ApiCoverageTestCase::TestCoverageGLCallWaitSync });
863 funcs_map.insert({ "glGetInteger64v", &ApiCoverageTestCase::TestCoverageGLCallGetInteger64v });
864 funcs_map.insert({ "glGetSynciv", &ApiCoverageTestCase::TestCoverageGLCallGetSynciv });
865 funcs_map.insert({ "glGenSamplers", &ApiCoverageTestCase::TestCoverageGLCallGenSamplers });
866 funcs_map.insert({ "glDeleteSamplers", &ApiCoverageTestCase::TestCoverageGLCallDeleteSamplers });
867 funcs_map.insert({ "glIsSampler", &ApiCoverageTestCase::TestCoverageGLCallIsSampler });
868 funcs_map.insert({ "glBindSampler", &ApiCoverageTestCase::TestCoverageGLCallBindSampler });
869 funcs_map.insert({ "glSamplerParameteri", &ApiCoverageTestCase::TestCoverageGLCallSamplerParameteri });
870 funcs_map.insert({ "glSamplerParameteriv", &ApiCoverageTestCase::TestCoverageGLCallSamplerParameteriv });
871 funcs_map.insert({ "glSamplerParameterf", &ApiCoverageTestCase::TestCoverageGLCallSamplerParameterf });
872 funcs_map.insert({ "glSamplerParameterfv", &ApiCoverageTestCase::TestCoverageGLCallSamplerParameterfv });
873 funcs_map.insert({ "glGetSamplerParameteriv", &ApiCoverageTestCase::TestCoverageGLCallGetSamplerParameteriv });
874 funcs_map.insert({ "glGetSamplerParameterfv", &ApiCoverageTestCase::TestCoverageGLCallGetSamplerParameterfv });
875 funcs_map.insert({ "glBindTransformFeedback", &ApiCoverageTestCase::TestCoverageGLCallBindTransformFeedback });
876 funcs_map.insert({ "glDeleteTransformFeedbacks", &ApiCoverageTestCase::TestCoverageGLCallDeleteTransformFeedbacks });
877 funcs_map.insert({ "glGenTransformFeedbacks", &ApiCoverageTestCase::TestCoverageGLCallGenTransformFeedbacks });
878 funcs_map.insert({ "glIsTransformFeedback", &ApiCoverageTestCase::TestCoverageGLCallIsTransformFeedback });
879 funcs_map.insert({ "glPauseTransformFeedback", &ApiCoverageTestCase::TestCoverageGLCallPauseTransformFeedback });
880 funcs_map.insert({ "glResumeTransformFeedback", &ApiCoverageTestCase::TestCoverageGLCallResumeTransformFeedback });
881 funcs_map.insert({ "glInvalidateFramebuffer", &ApiCoverageTestCase::TestCoverageGLCallInvalidateFramebuffer });
882 funcs_map.insert({ "glInvalidateSubFramebuffer", &ApiCoverageTestCase::TestCoverageGLCallInvalidateSubFramebuffer });
883 // clang-format on
884 }
885
886 if (glu::contextSupports(m_context_type, glu::ApiType::es(2, 0)))
887 {
888 // clang-format off
889 funcs_map.insert({ "glActiveTexture", &ApiCoverageTestCase::TestCoverageGLCallActiveTexture });
890 funcs_map.insert({ "glAttachShader", &ApiCoverageTestCase::TestCoverageGLCallAttachShader });
891 funcs_map.insert({ "glBindAttribLocation", &ApiCoverageTestCase::TestCoverageGLCallBindAttribLocation });
892 funcs_map.insert({ "glBindBuffer", &ApiCoverageTestCase::TestCoverageGLCallBindBuffer });
893 funcs_map.insert({ "glBindTexture", &ApiCoverageTestCase::TestCoverageGLCallBindTexture });
894 funcs_map.insert({ "glBlendColor", &ApiCoverageTestCase::TestCoverageGLCallBlendColor });
895 funcs_map.insert({ "glBlendEquation", &ApiCoverageTestCase::TestCoverageGLCallBlendEquation });
896 funcs_map.insert({ "glBlendEquationSeparate", &ApiCoverageTestCase::TestCoverageGLCallBlendEquationSeparate });
897 funcs_map.insert({ "glBlendFunc", &ApiCoverageTestCase::TestCoverageGLCallBlendFunc });
898 funcs_map.insert({ "glBlendFuncSeparate", &ApiCoverageTestCase::TestCoverageGLCallBlendFuncSeparate });
899 funcs_map.insert({ "glBufferData", &ApiCoverageTestCase::TestCoverageGLCallBufferData });
900 funcs_map.insert({ "glBufferSubData", &ApiCoverageTestCase::TestCoverageGLCallBufferSubData });
901 funcs_map.insert({ "glClear", &ApiCoverageTestCase::TestCoverageGLCallClear });
902 funcs_map.insert({ "glClearColor", &ApiCoverageTestCase::TestCoverageGLCallClearColor });
903 funcs_map.insert({ "glClearStencil", &ApiCoverageTestCase::TestCoverageGLCallClearStencil });
904 funcs_map.insert({ "glColorMask", &ApiCoverageTestCase::TestCoverageGLCallColorMask });
905 funcs_map.insert({ "glCompressedTexImage2D", &ApiCoverageTestCase::TestCoverageGLCallCompressedTexImage2D });
906 funcs_map.insert({ "glCompressedTexSubImage2D", &ApiCoverageTestCase::TestCoverageGLCallCompressedTexSubImage2D });
907 funcs_map.insert({ "glCopyTexImage2D", &ApiCoverageTestCase::TestCoverageGLCallCopyTexImage2D });
908 funcs_map.insert({ "glCopyTexSubImage2D", &ApiCoverageTestCase::TestCoverageGLCallCopyTexSubImage2D });
909 funcs_map.insert({ "glCreateProgram", &ApiCoverageTestCase::TestCoverageGLCallCreateProgram });
910 funcs_map.insert({ "glCreateShader", &ApiCoverageTestCase::TestCoverageGLCallCreateShader });
911 funcs_map.insert({ "glCullFace", &ApiCoverageTestCase::TestCoverageGLCallCullFace });
912 funcs_map.insert({ "glDeleteBuffers", &ApiCoverageTestCase::TestCoverageGLCallDeleteBuffers });
913 funcs_map.insert({ "glDeleteTextures", &ApiCoverageTestCase::TestCoverageGLCallDeleteTextures });
914 funcs_map.insert({ "glDeleteProgram", &ApiCoverageTestCase::TestCoverageGLCallDeleteProgram });
915 funcs_map.insert({ "glDeleteShader", &ApiCoverageTestCase::TestCoverageGLCallDeleteShader });
916 funcs_map.insert({ "glDetachShader", &ApiCoverageTestCase::TestCoverageGLCallDetachShader });
917 funcs_map.insert({ "glDepthFunc", &ApiCoverageTestCase::TestCoverageGLCallDepthFunc });
918 funcs_map.insert({ "glDepthMask", &ApiCoverageTestCase::TestCoverageGLCallDepthMask });
919 funcs_map.insert({ "glDisable", &ApiCoverageTestCase::TestCoverageGLCallDisable });
920 funcs_map.insert({ "glDisableVertexAttribArray", &ApiCoverageTestCase::TestCoverageGLCallDisableVertexAttribArray });
921 funcs_map.insert({ "glDrawArrays", &ApiCoverageTestCase::TestCoverageGLCallDrawArrays });
922 funcs_map.insert({ "glDrawElements", &ApiCoverageTestCase::TestCoverageGLCallDrawElements });
923 funcs_map.insert({ "glEnable", &ApiCoverageTestCase::TestCoverageGLCallEnable });
924 funcs_map.insert({ "glEnableVertexAttribArray", &ApiCoverageTestCase::TestCoverageGLCallEnableVertexAttribArray });
925 funcs_map.insert({ "glFinish", &ApiCoverageTestCase::TestCoverageGLCallFinish });
926 funcs_map.insert({ "glFlush", &ApiCoverageTestCase::TestCoverageGLCallFlush });
927 funcs_map.insert({ "glFrontFace", &ApiCoverageTestCase::TestCoverageGLCallFrontFace });
928 funcs_map.insert({ "glGetActiveAttrib", &ApiCoverageTestCase::TestCoverageGLCallGetActiveAttrib });
929 funcs_map.insert({ "glGetActiveUniform", &ApiCoverageTestCase::TestCoverageGLCallGetActiveUniform });
930 funcs_map.insert({ "glGetAttachedShaders", &ApiCoverageTestCase::TestCoverageGLCallGetAttachedShaders });
931 funcs_map.insert({ "glGetAttribLocation", &ApiCoverageTestCase::TestCoverageGLCallGetAttribLocation });
932 funcs_map.insert({ "glGetBooleanv", &ApiCoverageTestCase::TestCoverageGLCallGetBooleanv });
933 funcs_map.insert({ "glGetBufferParameteriv", &ApiCoverageTestCase::TestCoverageGLCallGetBufferParameteriv });
934 funcs_map.insert({ "glGenBuffers", &ApiCoverageTestCase::TestCoverageGLCallGenBuffers });
935 funcs_map.insert({ "glGenTextures", &ApiCoverageTestCase::TestCoverageGLCallGenTextures });
936 funcs_map.insert({ "gl.getError", &ApiCoverageTestCase::TestCoverageGLCallGetError });
937 funcs_map.insert({ "glGetFloatv", &ApiCoverageTestCase::TestCoverageGLCallGetFloatv });
938 funcs_map.insert({ "glGetIntegerv", &ApiCoverageTestCase::TestCoverageGLCallGetIntegerv });
939 funcs_map.insert({ "glGetProgramiv", &ApiCoverageTestCase::TestCoverageGLCallGetProgramiv });
940 funcs_map.insert({ "glGetProgramInfoLog", &ApiCoverageTestCase::TestCoverageGLCallGetProgramInfoLog });
941 funcs_map.insert({ "glGetString", &ApiCoverageTestCase::TestCoverageGLCallGetString });
942 funcs_map.insert({ "glGetTexParameteriv", &ApiCoverageTestCase::TestCoverageGLCallGetTexParameteriv });
943 funcs_map.insert({ "glGetTexParameterfv", &ApiCoverageTestCase::TestCoverageGLCallGetTexParameterfv });
944 funcs_map.insert({ "glGetUniformfv", &ApiCoverageTestCase::TestCoverageGLCallGetUniformfv });
945 funcs_map.insert({ "glGetUniformiv", &ApiCoverageTestCase::TestCoverageGLCallGetUniformiv });
946 funcs_map.insert({ "glGetUniformLocation", &ApiCoverageTestCase::TestCoverageGLCallGetUniformLocation });
947 funcs_map.insert({ "glGetVertexAttribfv", &ApiCoverageTestCase::TestCoverageGLCallGetVertexAttribfv });
948 funcs_map.insert({ "glGetVertexAttribiv", &ApiCoverageTestCase::TestCoverageGLCallGetVertexAttribiv });
949 funcs_map.insert({ "glGetVertexAttribPointerv", &ApiCoverageTestCase::TestCoverageGLCallGetVertexAttribPointerv });
950 funcs_map.insert({ "glHint", &ApiCoverageTestCase::TestCoverageGLCallHint });
951 funcs_map.insert({ "glIsBuffer", &ApiCoverageTestCase::TestCoverageGLCallIsBuffer });
952 funcs_map.insert({ "glIsEnabled", &ApiCoverageTestCase::TestCoverageGLCallIsEnabled });
953 funcs_map.insert({ "glIsProgram", &ApiCoverageTestCase::TestCoverageGLCallIsProgram });
954 funcs_map.insert({ "glIsShader", &ApiCoverageTestCase::TestCoverageGLCallIsShader });
955 funcs_map.insert({ "glIsTexture", &ApiCoverageTestCase::TestCoverageGLCallIsTexture });
956 funcs_map.insert({ "glLineWidth", &ApiCoverageTestCase::TestCoverageGLCallLineWidth });
957 funcs_map.insert({ "glLinkProgram", &ApiCoverageTestCase::TestCoverageGLCallLinkProgram });
958 funcs_map.insert({ "glPixelStorei", &ApiCoverageTestCase::TestCoverageGLCallPixelStorei });
959 funcs_map.insert({ "glPolygonOffset", &ApiCoverageTestCase::TestCoverageGLCallPolygonOffset });
960 funcs_map.insert({ "glReadPixels", &ApiCoverageTestCase::TestCoverageGLCallReadPixels });
961 funcs_map.insert({ "glSampleCoverage", &ApiCoverageTestCase::TestCoverageGLCallSampleCoverage });
962 funcs_map.insert({ "glScissor", &ApiCoverageTestCase::TestCoverageGLCallScissor });
963 funcs_map.insert({ "glStencilFunc", &ApiCoverageTestCase::TestCoverageGLCallStencilFunc });
964 funcs_map.insert({ "glStencilFuncSeparate", &ApiCoverageTestCase::TestCoverageGLCallStencilFuncSeparate });
965 funcs_map.insert({ "glStencilMask", &ApiCoverageTestCase::TestCoverageGLCallStencilMask });
966 funcs_map.insert({ "glStencilMaskSeparate", &ApiCoverageTestCase::TestCoverageGLCallStencilMaskSeparate });
967 funcs_map.insert({ "glStencilOp", &ApiCoverageTestCase::TestCoverageGLCallStencilOp });
968 funcs_map.insert({ "glStencilOpSeparate", &ApiCoverageTestCase::TestCoverageGLCallStencilOpSeparate });
969 funcs_map.insert({ "glTexImage2D", &ApiCoverageTestCase::TestCoverageGLCallTexImage2D });
970 funcs_map.insert({ "glTexParameteri", &ApiCoverageTestCase::TestCoverageGLCallTexParameteri });
971 funcs_map.insert({ "glTexParameterf", &ApiCoverageTestCase::TestCoverageGLCallTexParameterf });
972 funcs_map.insert({ "glTexParameteriv", &ApiCoverageTestCase::TestCoverageGLCallTexParameteriv });
973 funcs_map.insert({ "glTexParameterfv", &ApiCoverageTestCase::TestCoverageGLCallTexParameterfv });
974 funcs_map.insert({ "glTexSubImage2D", &ApiCoverageTestCase::TestCoverageGLCallTexSubImage2D });
975 funcs_map.insert({ "glUniform1i", &ApiCoverageTestCase::TestCoverageGLCallUniform1i });
976 funcs_map.insert({ "glUniform2i", &ApiCoverageTestCase::TestCoverageGLCallUniform2i });
977 funcs_map.insert({ "glUniform3i", &ApiCoverageTestCase::TestCoverageGLCallUniform3i });
978 funcs_map.insert({ "glUniform4i", &ApiCoverageTestCase::TestCoverageGLCallUniform4i });
979 funcs_map.insert({ "glUniform1f", &ApiCoverageTestCase::TestCoverageGLCallUniform1f });
980 funcs_map.insert({ "glUniform2f", &ApiCoverageTestCase::TestCoverageGLCallUniform2f });
981 funcs_map.insert({ "glUniform3f", &ApiCoverageTestCase::TestCoverageGLCallUniform3f });
982 funcs_map.insert({ "glUniform4f", &ApiCoverageTestCase::TestCoverageGLCallUniform4f });
983 funcs_map.insert({ "glUniform1iv", &ApiCoverageTestCase::TestCoverageGLCallUniform1iv });
984 funcs_map.insert({ "glUniform2iv", &ApiCoverageTestCase::TestCoverageGLCallUniform2iv });
985 funcs_map.insert({ "glUniform3iv", &ApiCoverageTestCase::TestCoverageGLCallUniform3iv });
986 funcs_map.insert({ "glUniform4iv", &ApiCoverageTestCase::TestCoverageGLCallUniform4iv });
987 funcs_map.insert({ "glUniform1fv", &ApiCoverageTestCase::TestCoverageGLCallUniform1fv });
988 funcs_map.insert({ "glUniform2fv", &ApiCoverageTestCase::TestCoverageGLCallUniform2fv });
989 funcs_map.insert({ "glUniform3fv", &ApiCoverageTestCase::TestCoverageGLCallUniform3fv });
990 funcs_map.insert({ "glUniform4fv", &ApiCoverageTestCase::TestCoverageGLCallUniform4fv });
991 funcs_map.insert({ "glUniformMatrix2fv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix2fv });
992 funcs_map.insert({ "glUniformMatrix3fv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix3fv });
993 funcs_map.insert({ "glUniformMatrix4fv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix4fv });
994 funcs_map.insert({ "glUseProgram", &ApiCoverageTestCase::TestCoverageGLCallUseProgram });
995 funcs_map.insert({ "glValidateProgram", &ApiCoverageTestCase::TestCoverageGLCallValidateProgram });
996 funcs_map.insert({ "glVertexAttrib1f", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib1f });
997 funcs_map.insert({ "glVertexAttrib2f", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib2f });
998 funcs_map.insert({ "glVertexAttrib3f", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib3f });
999 funcs_map.insert({ "glVertexAttrib4f", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4f });
1000 funcs_map.insert({ "glVertexAttrib1fv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib1fv });
1001 funcs_map.insert({ "glVertexAttrib2fv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib2fv });
1002 funcs_map.insert({ "glVertexAttrib3fv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib3fv });
1003 funcs_map.insert({ "glVertexAttrib4fv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4fv });
1004 funcs_map.insert({ "glVertexAttribPointer", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribPointer });
1005 funcs_map.insert({ "glViewport", &ApiCoverageTestCase::TestCoverageGLCallViewport });
1006 funcs_map.insert({ "glIsRenderbuffer", &ApiCoverageTestCase::TestCoverageGLCallIsRenderbuffer });
1007 funcs_map.insert({ "glBindRenderbuffer", &ApiCoverageTestCase::TestCoverageGLCallBindRenderbuffer });
1008 funcs_map.insert({ "glDeleteRenderbuffers", &ApiCoverageTestCase::TestCoverageGLCallDeleteRenderbuffers });
1009 funcs_map.insert({ "glGenRenderbuffers", &ApiCoverageTestCase::TestCoverageGLCallGenRenderbuffers });
1010 funcs_map.insert({ "glRenderbufferStorage", &ApiCoverageTestCase::TestCoverageGLCallRenderbufferStorage });
1011 funcs_map.insert({ "glGetRenderbufferParameteriv", &ApiCoverageTestCase::TestCoverageGLCallGetRenderbufferParameteriv });
1012 funcs_map.insert({ "glIsFramebuffer", &ApiCoverageTestCase::TestCoverageGLCallIsFramebuffer });
1013 funcs_map.insert({ "glBindFramebuffer", &ApiCoverageTestCase::TestCoverageGLCallBindFramebuffer });
1014 funcs_map.insert({ "glDeleteFramebuffers", &ApiCoverageTestCase::TestCoverageGLCallDeleteFramebuffers });
1015 funcs_map.insert({ "glGenFramebuffers", &ApiCoverageTestCase::TestCoverageGLCallGenFramebuffers });
1016 funcs_map.insert({ "glCheckFramebufferStatus", &ApiCoverageTestCase::TestCoverageGLCallCheckFramebufferStatus });
1017 funcs_map.insert({ "glFramebufferTexture2D", &ApiCoverageTestCase::TestCoverageGLCallFramebufferTexture2D });
1018 funcs_map.insert({ "glFramebufferRenderbuffer", &ApiCoverageTestCase::TestCoverageGLCallFramebufferRenderbuffer });
1019 funcs_map.insert({ "glGetFramebufferAttachmentParameteriv", &ApiCoverageTestCase::TestCoverageGLCallGetFramebufferAttachmentParameteriv });
1020 funcs_map.insert({ "glGenerateMipmap", &ApiCoverageTestCase::TestCoverageGLCallGenerateMipmap });
1021 funcs_map.insert({ "glCompileShader", &ApiCoverageTestCase::TestCoverageGLCallCompileShader });
1022 funcs_map.insert({ "glGetShaderiv", &ApiCoverageTestCase::TestCoverageGLCallGetShaderiv });
1023 funcs_map.insert({ "glGetShaderInfoLog", &ApiCoverageTestCase::TestCoverageGLCallGetShaderInfoLog });
1024 funcs_map.insert({ "glGetShaderSource", &ApiCoverageTestCase::TestCoverageGLCallGetShaderSource });
1025 funcs_map.insert({ "glShaderSource", &ApiCoverageTestCase::TestCoverageGLCallShaderSource });
1026 /* Remaining entries are OpenGL ES-specific tests */
1027 funcs_map.insert({ "glClearDepthf", &ApiCoverageTestCase::TestCoverageGLCallClearDepthf });
1028 funcs_map.insert({ "glDepthRangef", &ApiCoverageTestCase::TestCoverageGLCallDepthRangef });
1029 funcs_map.insert({ "glFramebufferTexture3D", &ApiCoverageTestCase::TestCoverageGLCallFramebufferTexture3DOES });
1030 funcs_map.insert({ "glMapBufferOES", &ApiCoverageTestCase::TestCoverageGLCallMapBufferOES });
1031 funcs_map.insert({ "glTexImage3DOES", &ApiCoverageTestCase::TestCoverageGLCallTexImage3DOES });
1032 funcs_map.insert({ "glTexSubImage3DOES", &ApiCoverageTestCase::TestCoverageGLCallTexSubImage3DOES });
1033 funcs_map.insert({ "glCompressedTexImage3DOES", &ApiCoverageTestCase::TestCoverageGLCallCompressedTexImage3DOES });
1034 funcs_map.insert({ "glCompressedTexSubImage3DOES", &ApiCoverageTestCase::TestCoverageGLCallCompressedTexSubImage3DOES });
1035 funcs_map.insert({ "glShaderBinary", &ApiCoverageTestCase::TestCoverageGLCallShaderBinary });
1036 funcs_map.insert({ "glReleaseShaderCompiler", &ApiCoverageTestCase::TestCoverageGLCallReleaseShaderCompiler });
1037 funcs_map.insert({ "glGetShaderPrecisionFormat", &ApiCoverageTestCase::TestCoverageGLCallGetShaderPrecisionFormat });
1038 // clang-format on
1039 }
1040 }
1041 else
1042 {
1043 ea_HintTarget = {ENUM(GL_LINE_SMOOTH_HINT),
1044 ENUM(GL_POLYGON_SMOOTH_HINT),
1045 ENUM(GL_TEXTURE_COMPRESSION_HINT),
1046 ENUM(GL_FRAGMENT_SHADER_DERIVATIVE_HINT),
1047 {"End of List", -1}};
1048
1049 ea_TextureFormat = {ENUM(GL_RED), ENUM(GL_RG), ENUM(GL_RGB), ENUM(GL_RGB),
1050 ENUM(GL_RGBA), ENUM(GL_RGBA), ENUM(GL_RGBA), {"End of List", -1}};
1051
1052 ea_InvalidateFramebuffer = {
1053 ENUM(GL_FRAMEBUFFER), ENUM(GL_DRAW_FRAMEBUFFER), ENUM(GL_READ_FRAMEBUFFER), {"End of List", -1}};
1054
1055 // clang-format off
1056 if (glu::contextSupports(m_context_type, glu::ApiType::core(4, 3)))
1057 {
1058 /* OpenGL 4.3 entry points */
1059 /* incomplete */
1060 funcs_map.insert({ "glInvalidateFramebuffer", &ApiCoverageTestCase::TestCoverageGLCallInvalidateFramebuffer });
1061 funcs_map.insert({ "glInvalidateSubFramebuffer", &ApiCoverageTestCase::TestCoverageGLCallInvalidateSubFramebuffer });
1062 }
1063
1064 if (glu::contextSupports(m_context_type, glu::ApiType::core(4, 2)))
1065 {
1066 /* OpenGL 4.2 entry points */
1067 /* not implemented, yet */
1068 }
1069
1070 if (glu::contextSupports(m_context_type, glu::ApiType::core(4, 1)))
1071 {
1072 /* OpenGL 4.1 entry points */
1073 /* not implemented, yet */
1074 }
1075
1076 if (glu::contextSupports(m_context_type, glu::ApiType::core(4, 0)))
1077 {
1078 /* OpenGL 4.0 entry points */
1079 funcs_map.insert({ "glDrawArraysIndirect", &ApiCoverageTestCase::TestCoverageGLCallDrawArraysIndirect });
1080 funcs_map.insert({ "glDrawElementsIndirect", &ApiCoverageTestCase::TestCoverageGLCallDrawElementsIndirect });
1081 funcs_map.insert({ "glUniform1d", &ApiCoverageTestCase::TestCoverageGLCallUniform1d });
1082 funcs_map.insert({ "glUniform2d", &ApiCoverageTestCase::TestCoverageGLCallUniform2d });
1083 funcs_map.insert({ "glUniform3d", &ApiCoverageTestCase::TestCoverageGLCallUniform3d });
1084 funcs_map.insert({ "glUniform4d", &ApiCoverageTestCase::TestCoverageGLCallUniform4d });
1085 funcs_map.insert({ "glUniform1dv", &ApiCoverageTestCase::TestCoverageGLCallUniform1dv });
1086 funcs_map.insert({ "glUniform2dv", &ApiCoverageTestCase::TestCoverageGLCallUniform2dv });
1087 funcs_map.insert({ "glUniform3dv", &ApiCoverageTestCase::TestCoverageGLCallUniform3dv });
1088 funcs_map.insert({ "glUniform4dv", &ApiCoverageTestCase::TestCoverageGLCallUniform4dv });
1089 funcs_map.insert({ "glUniformMatrix2dv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix2dv });
1090 funcs_map.insert({ "glUniformMatrix3dv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix3dv });
1091 funcs_map.insert({ "glUniformMatrix4dv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix4dv });
1092 funcs_map.insert({ "glUniformMatrix2x3dv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix2x3dv });
1093 funcs_map.insert({ "glUniformMatrix2x4dv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix2x4dv });
1094 funcs_map.insert({ "glUniformMatrix3x2dv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix3x2dv });
1095 funcs_map.insert({ "glUniformMatrix3x4dv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix3x4dv });
1096 funcs_map.insert({ "glUniformMatrix4x2dv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix4x2dv });
1097 funcs_map.insert({ "glUniformMatrix4x3dv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix4x3dv });
1098 funcs_map.insert({ "glGetUniformdv", &ApiCoverageTestCase::TestCoverageGLCallGetUniformdv });
1099 funcs_map.insert({ "glProgramUniform1dEXT", &ApiCoverageTestCase::TestCoverageGLCallProgramUniform1dEXT });
1100 funcs_map.insert({ "glProgramUniform2dEXT", &ApiCoverageTestCase::TestCoverageGLCallProgramUniform2dEXT });
1101 funcs_map.insert({ "glProgramUniform3dEXT", &ApiCoverageTestCase::TestCoverageGLCallProgramUniform3dEXT });
1102 funcs_map.insert({ "glProgramUniform4dEXT", &ApiCoverageTestCase::TestCoverageGLCallProgramUniform4dEXT });
1103 funcs_map.insert({ "glProgramUniform1dvEXT", &ApiCoverageTestCase::TestCoverageGLCallProgramUniform1dvEXT });
1104 funcs_map.insert({ "glProgramUniform2dvEXT", &ApiCoverageTestCase::TestCoverageGLCallProgramUniform2dvEXT });
1105 funcs_map.insert({ "glProgramUniform3dvEXT", &ApiCoverageTestCase::TestCoverageGLCallProgramUniform3dvEXT });
1106 funcs_map.insert({ "glProgramUniform4dvEXT", &ApiCoverageTestCase::TestCoverageGLCallProgramUniform4dvEXT });
1107 funcs_map.insert({ "glProgramUniformMatrix2dvEXT", &ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix2dvEXT });
1108 funcs_map.insert({ "glProgramUniformMatrix3dvEXT", &ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix3dvEXT });
1109 funcs_map.insert({ "glProgramUniformMatrix4dvEXT", &ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix4dvEXT });
1110 funcs_map.insert({ "glProgramUniformMatrix2x3dvEXT", &ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix2x3dvEXT });
1111 funcs_map.insert({ "glProgramUniformMatrix2x4dvEXT", &ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix2x4dvEXT });
1112 funcs_map.insert({ "glProgramUniformMatrix3x2dvEXT", &ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix3x2dvEXT });
1113 funcs_map.insert({ "glProgramUniformMatrix3x4dvEXT", &ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix3x4dvEXT });
1114 funcs_map.insert({ "glProgramUniformMatrix4x2dvEXT", &ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix4x2dvEXT });
1115 funcs_map.insert({ "glProgramUniformMatrix4x3dvEXT", &ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix4x3dvEXT });
1116 funcs_map.insert({ "glGetSubroutineUniformLocation", &ApiCoverageTestCase::TestCoverageGLCallGetSubroutineUniformLocation });
1117 funcs_map.insert({ "glGetSubroutineIndex", &ApiCoverageTestCase::TestCoverageGLCallGetSubroutineIndex });
1118 funcs_map.insert({ "glGetActiveSubroutineUniformiv", &ApiCoverageTestCase::TestCoverageGLCallGetActiveSubroutineUniformiv });
1119 funcs_map.insert({ "glGetActiveSubroutineUniformName", &ApiCoverageTestCase::TestCoverageGLCallGetActiveSubroutineUniformName });
1120 funcs_map.insert({ "glGetActiveSubroutineName", &ApiCoverageTestCase::TestCoverageGLCallGetActiveSubroutineName });
1121 funcs_map.insert({ "glUniformSubroutinesuiv", &ApiCoverageTestCase::TestCoverageGLCallUniformSubroutinesuiv });
1122 funcs_map.insert({ "glGetUniformSubroutineuiv", &ApiCoverageTestCase::TestCoverageGLCallGetUniformSubroutineuiv });
1123 funcs_map.insert({ "glGetProgramStageiv", &ApiCoverageTestCase::TestCoverageGLCallGetProgramStageiv });
1124 funcs_map.insert({ "glPatchParameteri", &ApiCoverageTestCase::TestCoverageGLCallPatchParameteri });
1125 funcs_map.insert({ "glPatchParameterfv", &ApiCoverageTestCase::TestCoverageGLCallPatchParameterfv });
1126 funcs_map.insert({ "glBindTransformFeedback", &ApiCoverageTestCase::TestCoverageGLCallBindTransformFeedback }); /* Shared with OpenGL ES */
1127 funcs_map.insert({ "glDeleteTransformFeedbacks", &ApiCoverageTestCase::TestCoverageGLCallDeleteTransformFeedbacks }); /* Shared with OpenGL ES */
1128 funcs_map.insert({ "glGenTransformFeedbacks", &ApiCoverageTestCase::TestCoverageGLCallGenTransformFeedbacks }); /* Shared with OpenGL ES */
1129 funcs_map.insert({ "glIsTransformFeedback", &ApiCoverageTestCase::TestCoverageGLCallIsTransformFeedback }); /* Shared with OpenGL ES */
1130 funcs_map.insert({ "glPauseTransformFeedback", &ApiCoverageTestCase::TestCoverageGLCallPauseTransformFeedback }); /* Shared with OpenGL ES */
1131 funcs_map.insert({ "glResumeTransformFeedback", &ApiCoverageTestCase::TestCoverageGLCallResumeTransformFeedback }); /* Shared with OpenGL ES */
1132 funcs_map.insert({ "glDrawTransformFeedback", &ApiCoverageTestCase::TestCoverageGLCallDrawTransformFeedback });
1133 funcs_map.insert({ "glDrawTransformFeedbackStream", &ApiCoverageTestCase::TestCoverageGLCallDrawTransformFeedbackStream });
1134 funcs_map.insert({ "glBeginQueryIndexed", &ApiCoverageTestCase::TestCoverageGLCallBeginQueryIndexed });
1135 funcs_map.insert({ "glEndQueryIndexed", &ApiCoverageTestCase::TestCoverageGLCallEndQueryIndexed });
1136 funcs_map.insert({ "glGetQueryIndexediv", &ApiCoverageTestCase::TestCoverageGLCallGetQueryIndexediv });
1137 }
1138
1139 if (glu::contextSupports(m_context_type, glu::ApiType::core(3, 3)))
1140 {
1141 /* OpenGL 3.3 entry points */
1142 funcs_map.insert({ "glBindFragDataLocationIndexed", &ApiCoverageTestCase::TestCoverageGLCallBindFragDataLocationIndexed });
1143 funcs_map.insert({ "glGetFragDataIndex", &ApiCoverageTestCase::TestCoverageGLCallGetFragDataIndex });
1144 funcs_map.insert({ "glGenSamplers", &ApiCoverageTestCase::TestCoverageGLCallGenSamplers }); /* Shared with OpenGL ES */
1145 funcs_map.insert({ "glDeleteSamplers", &ApiCoverageTestCase::TestCoverageGLCallDeleteSamplers }); /* Shared with OpenGL ES */
1146 funcs_map.insert({ "glIsSampler", &ApiCoverageTestCase::TestCoverageGLCallIsSampler }); /* Shared with OpenGL ES */
1147 funcs_map.insert({ "glBindSampler", &ApiCoverageTestCase::TestCoverageGLCallBindSampler }); /* Shared with OpenGL ES */
1148 funcs_map.insert({ "glSamplerParameteri", &ApiCoverageTestCase::TestCoverageGLCallSamplerParameteri }); /* Shared with OpenGL ES */
1149 funcs_map.insert({ "glSamplerParameteriv", &ApiCoverageTestCase::TestCoverageGLCallSamplerParameteriv }); /* Shared with OpenGL ES */
1150 funcs_map.insert({ "glSamplerParameterf", &ApiCoverageTestCase::TestCoverageGLCallSamplerParameterf }); /* Shared with OpenGL ES */
1151 funcs_map.insert({ "glSamplerParameterfv", &ApiCoverageTestCase::TestCoverageGLCallSamplerParameterfv }); /* Shared with OpenGL ES */
1152 funcs_map.insert({ "glSamplerParameterIiv", &ApiCoverageTestCase::TestCoverageGLCallSamplerParameterIiv });
1153 funcs_map.insert({ "glSamplerParameterIuiv", &ApiCoverageTestCase::TestCoverageGLCallSamplerParameterIuiv });
1154 funcs_map.insert({ "glGetSamplerParameteriv", &ApiCoverageTestCase::TestCoverageGLCallGetSamplerParameteriv }); /* Shared with OpenGL ES */
1155 funcs_map.insert({ "glGetSamplerParameterIiv", &ApiCoverageTestCase::TestCoverageGLCallGetSamplerParameterIiv });
1156 funcs_map.insert({ "glGetSamplerParameterfv", &ApiCoverageTestCase::TestCoverageGLCallGetSamplerParameterfv }); /* Shared with OpenGL ES */
1157 funcs_map.insert({ "glGetSamplerParameterIfv", &ApiCoverageTestCase::TestCoverageGLCallGetSamplerParameterIfv });
1158 funcs_map.insert({ "glQueryCounter", &ApiCoverageTestCase::TestCoverageGLCallQueryCounter });
1159 funcs_map.insert({ "glGetQueryObjecti64v", &ApiCoverageTestCase::TestCoverageGLCallGetQueryObjecti64v });
1160 funcs_map.insert({ "glGetQueryObjectui64v", &ApiCoverageTestCase::TestCoverageGLCallGetQueryObjectui64v });
1161 funcs_map.insert({ "glVertexP2ui", &ApiCoverageTestCase::TestCoverageGLCallVertexP2ui });
1162 funcs_map.insert({ "glVertexP2uiv", &ApiCoverageTestCase::TestCoverageGLCallVertexP2uiv });
1163 funcs_map.insert({ "glVertexP3ui", &ApiCoverageTestCase::TestCoverageGLCallVertexP3ui });
1164 funcs_map.insert({ "glVertexP3uiv", &ApiCoverageTestCase::TestCoverageGLCallVertexP3uiv });
1165 funcs_map.insert({ "glVertexP4ui", &ApiCoverageTestCase::TestCoverageGLCallVertexP4ui });
1166 funcs_map.insert({ "glVertexP4uiv", &ApiCoverageTestCase::TestCoverageGLCallVertexP4uiv });
1167 funcs_map.insert({ "glTexCoordP1ui", &ApiCoverageTestCase::TestCoverageGLCallTexCoordP1ui });
1168 funcs_map.insert({ "glTexCoordP1uiv", &ApiCoverageTestCase::TestCoverageGLCallTexCoordP1uiv });
1169 funcs_map.insert({ "glTexCoordP2ui", &ApiCoverageTestCase::TestCoverageGLCallTexCoordP2ui });
1170 funcs_map.insert({ "glTexCoordP2uiv", &ApiCoverageTestCase::TestCoverageGLCallTexCoordP2uiv });
1171 funcs_map.insert({ "glTexCoordP3ui", &ApiCoverageTestCase::TestCoverageGLCallTexCoordP3ui });
1172 funcs_map.insert({ "glTexCoordP3uiv", &ApiCoverageTestCase::TestCoverageGLCallTexCoordP3uiv });
1173 funcs_map.insert({ "glTexCoordP4ui", &ApiCoverageTestCase::TestCoverageGLCallTexCoordP4ui });
1174 funcs_map.insert({ "glTexCoordP4uiv", &ApiCoverageTestCase::TestCoverageGLCallTexCoordP4uiv });
1175 funcs_map.insert({ "glMultiTexCoordP1ui", &ApiCoverageTestCase::TestCoverageGLCallMultiTexCoordP1ui });
1176 funcs_map.insert({ "glMultiTexCoordP1uiv", &ApiCoverageTestCase::TestCoverageGLCallMultiTexCoordP1uiv });
1177 funcs_map.insert({ "glMultiTexCoordP2ui", &ApiCoverageTestCase::TestCoverageGLCallMultiTexCoordP2ui });
1178 funcs_map.insert({ "glMultiTexCoordP2uiv", &ApiCoverageTestCase::TestCoverageGLCallMultiTexCoordP2uiv });
1179 funcs_map.insert({ "glMultiTexCoordP3ui", &ApiCoverageTestCase::TestCoverageGLCallMultiTexCoordP3ui });
1180 funcs_map.insert({ "glMultiTexCoordP3uiv", &ApiCoverageTestCase::TestCoverageGLCallMultiTexCoordP3uiv });
1181 funcs_map.insert({ "glMultiTexCoordP4ui", &ApiCoverageTestCase::TestCoverageGLCallMultiTexCoordP4ui });
1182 funcs_map.insert({ "glMultiTexCoordP4uiv", &ApiCoverageTestCase::TestCoverageGLCallMultiTexCoordP4uiv });
1183 funcs_map.insert({ "glNormalP3ui", &ApiCoverageTestCase::TestCoverageGLCallNormalP3ui });
1184 funcs_map.insert({ "glNormalP3uiv", &ApiCoverageTestCase::TestCoverageGLCallNormalP3uiv });
1185 funcs_map.insert({ "glColorP3ui", &ApiCoverageTestCase::TestCoverageGLCallColorP3ui });
1186 funcs_map.insert({ "glColorP3uiv", &ApiCoverageTestCase::TestCoverageGLCallColorP3uiv });
1187 funcs_map.insert({ "glColorP4ui", &ApiCoverageTestCase::TestCoverageGLCallColorP4ui });
1188 funcs_map.insert({ "glColorP4uiv", &ApiCoverageTestCase::TestCoverageGLCallColorP4uiv });
1189 funcs_map.insert({ "glSecondaryColorP3ui", &ApiCoverageTestCase::TestCoverageGLCallSecondaryColorP3ui });
1190 funcs_map.insert({ "glSecondaryColorP3uiv", &ApiCoverageTestCase::TestCoverageGLCallSecondaryColorP3uiv });
1191 funcs_map.insert({ "glVertexAttribP1ui", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribP1ui });
1192 funcs_map.insert({ "glVertexAttribP1uiv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribP1uiv });
1193 funcs_map.insert({ "glVertexAttribP2ui", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribP2ui });
1194 funcs_map.insert({ "glVertexAttribP2uiv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribP2uiv });
1195 funcs_map.insert({ "glVertexAttribP3ui", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribP3ui });
1196 funcs_map.insert({ "glVertexAttribP3uiv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribP3uiv });
1197 funcs_map.insert({ "glVertexAttribP4ui", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribP4ui });
1198 funcs_map.insert({ "glVertexAttribP4uiv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribP4uiv });
1199 }
1200
1201 if (glu::contextSupports(m_context_type, glu::ApiType::core(3, 2)))
1202 {
1203 /* OpenGL 3.2 entry points */
1204 funcs_map.insert({ "glGetInteger64i_v", &ApiCoverageTestCase::TestCoverageGLCallGetInteger64i_v });
1205 funcs_map.insert({ "glGetBufferParameteri64v", &ApiCoverageTestCase::TestCoverageGLCallGetBufferParameteri64v }); /* Shared with OpenGL ES */
1206 funcs_map.insert({ "glProgramParameteri", &ApiCoverageTestCase::TestCoverageGLCallProgramParameteri }); /* Shared with OpenGL ES */
1207 funcs_map.insert({ "glFramebufferTexture", &ApiCoverageTestCase::TestCoverageGLCallFramebufferTexture });
1208 funcs_map.insert({ "glDrawElementsBaseVertex", &ApiCoverageTestCase::TestCoverageGLCallDrawElementsBaseVertex });
1209 funcs_map.insert({ "glDrawRangeElementsBaseVertex", &ApiCoverageTestCase::TestCoverageGLCallDrawRangeElementsBaseVertex });
1210 funcs_map.insert({ "glDrawElementsInstancedBaseVertex", &ApiCoverageTestCase::TestCoverageGLCallDrawElementsInstancedBaseVertex });
1211 funcs_map.insert({ "glMultiDrawElementsBaseVertex", &ApiCoverageTestCase::TestCoverageGLCallMultiDrawElementsBaseVertex });
1212 funcs_map.insert({ "glProvokingVertex", &ApiCoverageTestCase::TestCoverageGLCallProvokingVertex });
1213 funcs_map.insert({ "glFenceSync", &ApiCoverageTestCase::TestCoverageGLCallFenceSync }); /* Shared with OpenGL ES */
1214 funcs_map.insert({ "glIsSync", &ApiCoverageTestCase::TestCoverageGLCallIsSync }); /* Shared with OpenGL ES */
1215 funcs_map.insert({ "glDeleteSync", &ApiCoverageTestCase::TestCoverageGLCallDeleteSync }); /* Shared with OpenGL ES */
1216 funcs_map.insert({ "glClientWaitSync", &ApiCoverageTestCase::TestCoverageGLCallClientWaitSync }); /* Shared with OpenGL ES */
1217 funcs_map.insert({ "glWaitSync", &ApiCoverageTestCase::TestCoverageGLCallWaitSync }); /* Shared with OpenGL ES */
1218 funcs_map.insert({ "glGetInteger64v", &ApiCoverageTestCase::TestCoverageGLCallGetInteger64v }); /* Shared with OpenGL ES */
1219 funcs_map.insert({ "glGetSynciv", &ApiCoverageTestCase::TestCoverageGLCallGetSynciv }); /* Shared with OpenGL ES */
1220 funcs_map.insert({ "glTexImage2DMultisample", &ApiCoverageTestCase::TestCoverageGLCallTexImage2DMultisample });
1221 funcs_map.insert({ "glTexImage3DMultisample", &ApiCoverageTestCase::TestCoverageGLCallTexImage3DMultisample });
1222 funcs_map.insert({ "glGetMultisamplefv", &ApiCoverageTestCase::TestCoverageGLCallGetMultisamplefv });
1223 funcs_map.insert({ "glSampleMaski", &ApiCoverageTestCase::TestCoverageGLCallSampleMaski });
1224 }
1225
1226 if (glu::contextSupports(m_context_type, glu::ApiType::core(3, 1)))
1227 {
1228 /* OpenGL 3.1 entry points */
1229 funcs_map.insert({ "glDrawArraysInstanced", &ApiCoverageTestCase::TestCoverageGLCallDrawArraysInstanced }); /* Shared with OpenGL ES */
1230 funcs_map.insert({ "glDrawElementsInstanced", &ApiCoverageTestCase::TestCoverageGLCallDrawElementsInstanced }); /* Shared with OpenGL ES */
1231 funcs_map.insert({ "glTexBuffer", &ApiCoverageTestCase::TestCoverageGLCallTexBuffer });
1232 funcs_map.insert({ "glPrimitiveRestartIndex", &ApiCoverageTestCase::TestCoverageGLCallPrimitiveRestartIndex });
1233 funcs_map.insert({ "glCopyBufferSubData", &ApiCoverageTestCase::TestCoverageGLCallCopyBufferSubData }); /* Shared with OpenGL ES */
1234 funcs_map.insert({ "glGetUniformIndices", &ApiCoverageTestCase::TestCoverageGLCallGetUniformIndices }); /* Shared with OpenGL ES */
1235 funcs_map.insert({ "glGetActiveUniformsiv", &ApiCoverageTestCase::TestCoverageGLCallGetActiveUniformsiv }); /* Shared with OpenGL ES */
1236 funcs_map.insert({ "glGetActiveUniformName", &ApiCoverageTestCase::TestCoverageGLCallGetActiveUniformName });
1237 funcs_map.insert({ "glGetUniformBlockIndex", &ApiCoverageTestCase::TestCoverageGLCallGetUniformBlockIndex }); /* Shared with OpenGL ES */
1238 funcs_map.insert({ "glGetActiveUniformBlockiv", &ApiCoverageTestCase::TestCoverageGLCallGetActiveUniformBlockiv }); /* Shared with OpenGL ES */
1239 funcs_map.insert({ "glGetActiveUniformBlockName", &ApiCoverageTestCase::TestCoverageGLCallGetActiveUniformBlockName }); /* Shared with OpenGL ES */
1240 funcs_map.insert({ "glUniformBlockBinding", &ApiCoverageTestCase::TestCoverageGLCallUniformBlockBinding }); /* Shared with OpenGL ES */
1241 }
1242
1243 if (glu::contextSupports(m_context_type, glu::ApiType::core(3, 0)))
1244 {
1245 /* OpenGL 3.0 entry points */
1246 funcs_map.insert({ "glColorMaski", &ApiCoverageTestCase::TestCoverageGLCallColorMaski });
1247 funcs_map.insert({ "glGetBooleani_v", &ApiCoverageTestCase::TestCoverageGLCallGetBooleani_v });
1248 funcs_map.insert({ "glGetIntegeri_v", &ApiCoverageTestCase::TestCoverageGLCallGetIntegeri_v });
1249 funcs_map.insert({ "glEnablei", &ApiCoverageTestCase::TestCoverageGLCallEnablei });
1250 funcs_map.insert({ "glDisablei", &ApiCoverageTestCase::TestCoverageGLCallDisablei });
1251 funcs_map.insert({ "glIsEnabledi", &ApiCoverageTestCase::TestCoverageGLCallIsEnabledi });
1252 funcs_map.insert({ "glBeginTransformFeedback", &ApiCoverageTestCase::TestCoverageGLCallBeginTransformFeedback }); /* Shared with OpenGL ES */
1253 funcs_map.insert({ "glEndTransformFeedback", &ApiCoverageTestCase::TestCoverageGLCallEndTransformFeedback }); /* Shared with OpenGL ES */
1254 funcs_map.insert({ "glBindBufferRange", &ApiCoverageTestCase::TestCoverageGLCallBindBufferRange }); /* Shared with OpenGL ES */
1255 funcs_map.insert({ "glBindBufferBase", &ApiCoverageTestCase::TestCoverageGLCallBindBufferBase }); /* Shared with OpenGL ES */
1256 funcs_map.insert({ "glTransformFeedbackVaryings", &ApiCoverageTestCase::TestCoverageGLCallTransformFeedbackVaryings }); /* Shared with OpenGL ES */
1257 funcs_map.insert({ "glGetTransformFeedbackVarying", &ApiCoverageTestCase::TestCoverageGLCallGetTransformFeedbackVarying }); /* Shared with OpenGL ES */
1258 funcs_map.insert({ "glClampColor", &ApiCoverageTestCase::TestCoverageGLCallClampColor });
1259 funcs_map.insert({ "glBeginConditionalRender", &ApiCoverageTestCase::TestCoverageGLCallBeginConditionalRender });
1260 funcs_map.insert({ "glEndConditionalRender", &ApiCoverageTestCase::TestCoverageGLCallEndConditionalRender });
1261 funcs_map.insert({ "glVertexAttribIPointer", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribIPointer }); /* Shared with OpenGL ES */
1262 funcs_map.insert({ "glGetVertexAttribIiv", &ApiCoverageTestCase::TestCoverageGLCallGetVertexAttribIiv }); /* Shared with OpenGL ES */
1263 funcs_map.insert({ "glGetVertexAttribIuiv", &ApiCoverageTestCase::TestCoverageGLCallGetVertexAttribIuiv }); /* Shared with OpenGL ES */
1264 funcs_map.insert({ "glVertexAttribI1i", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI1i });
1265 funcs_map.insert({ "glVertexAttribI2i", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI2i });
1266 funcs_map.insert({ "glVertexAttribI3i", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI3i });
1267 funcs_map.insert({ "glVertexAttribI4i", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4i }); /* Shared with OpenGL ES */
1268 funcs_map.insert({ "glVertexAttribI1ui", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI1ui });
1269 funcs_map.insert({ "glVertexAttribI2ui", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI2ui });
1270 funcs_map.insert({ "glVertexAttribI3ui", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI3ui });
1271 funcs_map.insert({ "glVertexAttribI4ui", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4ui }); /* Shared with OpenGL ES */
1272 funcs_map.insert({ "glVertexAttribI1iv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI1iv });
1273 funcs_map.insert({ "glVertexAttribI2iv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI2iv });
1274 funcs_map.insert({ "glVertexAttribI3iv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI3iv });
1275 funcs_map.insert({ "glVertexAttribI4iv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4iv }); /* Shared with OpenGL ES */
1276 funcs_map.insert({ "glVertexAttribI1uiv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI1uiv });
1277 funcs_map.insert({ "glVertexAttribI2uiv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI2uiv });
1278 funcs_map.insert({ "glVertexAttribI3uiv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI3uiv });
1279 funcs_map.insert({ "glVertexAttribI4uiv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4uiv }); /* Shared with OpenGL ES */
1280 funcs_map.insert({ "glVertexAttribI4bv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4bv });
1281 funcs_map.insert({ "glVertexAttribI4sv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4sv });
1282 funcs_map.insert({ "glVertexAttribI4ubv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4ubv });
1283 funcs_map.insert({ "glVertexAttribI4usv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4usv });
1284 funcs_map.insert({ "glGetUniformuiv", &ApiCoverageTestCase::TestCoverageGLCallGetUniformuiv }); /* Shared with OpenGL ES */
1285 funcs_map.insert({ "glBindFragDataLocation", &ApiCoverageTestCase::TestCoverageGLCallBindFragDataLocation });
1286 funcs_map.insert({ "glGetFragDataLocation", &ApiCoverageTestCase::TestCoverageGLCallGetFragDataLocation }); /* Shared with OpenGL ES */
1287 funcs_map.insert({ "glUniform1ui", &ApiCoverageTestCase::TestCoverageGLCallUniform1ui });
1288 funcs_map.insert({ "glUniform2ui", &ApiCoverageTestCase::TestCoverageGLCallUniform2ui }); /* Shared with OpenGL ES */
1289 funcs_map.insert({ "glUniform3ui", &ApiCoverageTestCase::TestCoverageGLCallUniform3ui });
1290 funcs_map.insert({ "glUniform4ui", &ApiCoverageTestCase::TestCoverageGLCallUniform4ui });
1291 funcs_map.insert({ "glUniform1uiv", &ApiCoverageTestCase::TestCoverageGLCallUniform1uiv });
1292 funcs_map.insert({ "glUniform2uiv", &ApiCoverageTestCase::TestCoverageGLCallUniform2uiv }); /* Shared with OpenGL ES */
1293 funcs_map.insert({ "glUniform3uiv", &ApiCoverageTestCase::TestCoverageGLCallUniform3uiv });
1294 funcs_map.insert({ "glUniform4uiv", &ApiCoverageTestCase::TestCoverageGLCallUniform4uiv });
1295 funcs_map.insert({ "glTexParameterIiv", &ApiCoverageTestCase::TestCoverageGLCallTexParameterIiv });
1296 funcs_map.insert({ "glTexParameterIuiv", &ApiCoverageTestCase::TestCoverageGLCallTexParameterIuiv });
1297 funcs_map.insert({ "glGetTexParameterIiv", &ApiCoverageTestCase::TestCoverageGLCallGetTexParameterIiv });
1298 funcs_map.insert({ "glGetTexParameterIuiv", &ApiCoverageTestCase::TestCoverageGLCallGetTexParameterIuiv });
1299 funcs_map.insert({ "glClearBufferiv", &ApiCoverageTestCase::TestCoverageGLCallClearBufferiv }); /* Shared with OpenGL ES */
1300 funcs_map.insert({ "glClearBufferuiv", &ApiCoverageTestCase::TestCoverageGLCallClearBufferuiv }); /* Shared with OpenGL ES */
1301 funcs_map.insert({ "glClearBufferfv", &ApiCoverageTestCase::TestCoverageGLCallClearBufferfv }); /* Shared with OpenGL ES */
1302 funcs_map.insert({ "glClearBufferfi", &ApiCoverageTestCase::TestCoverageGLCallClearBufferfi }); /* Shared with OpenGL ES */
1303 funcs_map.insert({ "glGetStringi", &ApiCoverageTestCase::TestCoverageGLCallGetStringi }); /* Shared with OpenGL ES */
1304 funcs_map.insert({ "glIsRenderbuffer", &ApiCoverageTestCase::TestCoverageGLCallIsRenderbuffer }); /* Shared with OpenGL ES */
1305 funcs_map.insert({ "glBindRenderbuffer", &ApiCoverageTestCase::TestCoverageGLCallBindRenderbuffer }); /* Shared with OpenGL ES */
1306 funcs_map.insert({ "glDeleteRenderbuffers", &ApiCoverageTestCase::TestCoverageGLCallDeleteRenderbuffers }); /* Shared with OpenGL ES */
1307 funcs_map.insert({ "glGenRenderbuffers", &ApiCoverageTestCase::TestCoverageGLCallGenRenderbuffers }); /* Shared with OpenGL ES */
1308 funcs_map.insert({ "glRenderbufferStorage", &ApiCoverageTestCase::TestCoverageGLCallRenderbufferStorage }); /* Shared with OpenGL ES */
1309 funcs_map.insert({ "glGetRenderbufferParameteriv", &ApiCoverageTestCase::TestCoverageGLCallGetRenderbufferParameteriv }); /* Shared with OpenGL ES */
1310 funcs_map.insert({ "glIsFramebuffer", &ApiCoverageTestCase::TestCoverageGLCallIsFramebuffer }); /* Shared with OpenGL ES */
1311 funcs_map.insert({ "glBindFramebuffer", &ApiCoverageTestCase::TestCoverageGLCallBindFramebuffer }); /* Shared with OpenGL ES */
1312 funcs_map.insert({ "glDeleteFramebuffers", &ApiCoverageTestCase::TestCoverageGLCallDeleteFramebuffers }); /* Shared with OpenGL ES */
1313 funcs_map.insert({ "glGenFramebuffers", &ApiCoverageTestCase::TestCoverageGLCallGenFramebuffers }); /* Shared with OpenGL ES */
1314 funcs_map.insert({ "glCheckFramebufferStatus", &ApiCoverageTestCase::TestCoverageGLCallCheckFramebufferStatus }); /* Shared with OpenGL ES */
1315 funcs_map.insert({ "glFramebufferTexture1D", &ApiCoverageTestCase::TestCoverageGLCallFramebufferTexture1D });
1316 funcs_map.insert({ "glFramebufferTexture2D", &ApiCoverageTestCase::TestCoverageGLCallFramebufferTexture2D }); /* Shared with OpenGL ES */
1317 funcs_map.insert({ "glFramebufferTexture3D", &ApiCoverageTestCase::TestCoverageGLCallFramebufferTexture3D });
1318 funcs_map.insert({ "glFramebufferRenderbuffer", &ApiCoverageTestCase::TestCoverageGLCallFramebufferRenderbuffer }); /* Shared with OpenGL ES */
1319 funcs_map.insert({ "glGetFramebufferAttachmentParameteriv", &ApiCoverageTestCase::TestCoverageGLCallGetFramebufferAttachmentParameteriv }); /* Shared with OpenGL ES */
1320 funcs_map.insert({ "glGenerateMipmap", &ApiCoverageTestCase::TestCoverageGLCallGenerateMipmap }); /* Shared with OpenGL ES */
1321 funcs_map.insert({ "glBlitFramebuffer", &ApiCoverageTestCase::TestCoverageGLCallBlitFramebuffer }); /* Shared with OpenGL ES */
1322 funcs_map.insert({ "glRenderbufferStorageMultisample", &ApiCoverageTestCase::TestCoverageGLCallRenderbufferStorageMultisample }); /* Shared with OpenGL ES */
1323 funcs_map.insert({ "glFramebufferTextureLayer", &ApiCoverageTestCase::TestCoverageGLCallFramebufferTextureLayer });
1324 funcs_map.insert({ "glMapBufferRange", &ApiCoverageTestCase::TestCoverageGLCallMapBufferRange }); /* Shared with OpenGL ES */
1325 funcs_map.insert({ "glFlushMappedBufferRange", &ApiCoverageTestCase::TestCoverageGLCallFlushMappedBufferRange }); /* Shared with OpenGL ES */
1326 funcs_map.insert({ "glBindVertexArray", &ApiCoverageTestCase::TestCoverageGLCallBindVertexArray }); /* Shared with OpenGL ES */
1327 funcs_map.insert({ "glDeleteVertexArrays", &ApiCoverageTestCase::TestCoverageGLCallDeleteVertexArrays }); /* Shared with OpenGL ES */
1328 funcs_map.insert({ "glGenVertexArrays", &ApiCoverageTestCase::TestCoverageGLCallGenVertexArrays }); /* Shared with OpenGL ES */
1329 funcs_map.insert({ "glIsVertexArray", &ApiCoverageTestCase::TestCoverageGLCallIsVertexArray }); /* Shared with OpenGL ES */
1330 /* OpenGL 1.0-2.1 entry points */
1331 funcs_map.insert({ "glCullFace", &ApiCoverageTestCase::TestCoverageGLCallCullFace }); /* Shared with OpenGL ES */
1332 funcs_map.insert({ "glFrontFace", &ApiCoverageTestCase::TestCoverageGLCallFrontFace }); /* Shared with OpenGL ES */
1333 funcs_map.insert({ "glHint", &ApiCoverageTestCase::TestCoverageGLCallHint }); /* Shared with OpenGL ES */
1334 funcs_map.insert({ "glLineWidth", &ApiCoverageTestCase::TestCoverageGLCallLineWidth }); /* Shared with OpenGL ES */
1335 funcs_map.insert({ "glPointSize", &ApiCoverageTestCase::TestCoverageGLCallPointSize });
1336 funcs_map.insert({ "glPolygonMode", &ApiCoverageTestCase::TestCoverageGLCallPolygonMode });
1337 funcs_map.insert({ "glScissor", &ApiCoverageTestCase::TestCoverageGLCallScissor }); /* Shared with OpenGL ES */
1338 funcs_map.insert({ "glTexParameterf", &ApiCoverageTestCase::TestCoverageGLCallTexParameterf }); /* Shared with OpenGL ES */
1339 funcs_map.insert({ "glTexParameterfv", &ApiCoverageTestCase::TestCoverageGLCallTexParameterfv }); /* Shared with OpenGL ES */
1340 funcs_map.insert({ "glTexParameteri", &ApiCoverageTestCase::TestCoverageGLCallTexParameteri }); /* Shared with OpenGL ES */
1341 funcs_map.insert({ "glTexParameteriv", &ApiCoverageTestCase::TestCoverageGLCallTexParameteriv }); /* Shared with OpenGL ES */
1342 funcs_map.insert({ "glTexImage1D", &ApiCoverageTestCase::TestCoverageGLCallTexImage1D });
1343 funcs_map.insert({ "glTexImage2D", &ApiCoverageTestCase::TestCoverageGLCallTexImage2D }); /* Shared with OpenGL ES */
1344 funcs_map.insert({ "glDrawBuffer", &ApiCoverageTestCase::TestCoverageGLCallDrawBuffer });
1345 funcs_map.insert({ "glClear", &ApiCoverageTestCase::TestCoverageGLCallClear }); /* Shared with OpenGL ES */
1346 funcs_map.insert({ "glClearColor", &ApiCoverageTestCase::TestCoverageGLCallClearColor }); /* Shared with OpenGL ES */
1347 funcs_map.insert({ "glClearStencil", &ApiCoverageTestCase::TestCoverageGLCallClearStencil }); /* Shared with OpenGL ES */
1348 funcs_map.insert({ "glClearDepth", &ApiCoverageTestCase::TestCoverageGLCallClearDepth });
1349 funcs_map.insert({ "glStencilMask", &ApiCoverageTestCase::TestCoverageGLCallStencilMask }); /* Shared with OpenGL ES */
1350 funcs_map.insert({ "glColorMask", &ApiCoverageTestCase::TestCoverageGLCallColorMask }); /* Shared with OpenGL ES */
1351 funcs_map.insert({ "glDepthMask", &ApiCoverageTestCase::TestCoverageGLCallDepthMask }); /* Shared with OpenGL ES */
1352 funcs_map.insert({ "glDisable", &ApiCoverageTestCase::TestCoverageGLCallDisable }); /* Shared with OpenGL ES */
1353 funcs_map.insert({ "glEnable", &ApiCoverageTestCase::TestCoverageGLCallEnable }); /* Shared with OpenGL ES */
1354 funcs_map.insert({ "glFinish", &ApiCoverageTestCase::TestCoverageGLCallFinish }); /* Shared with OpenGL ES */
1355 funcs_map.insert({ "glFlush", &ApiCoverageTestCase::TestCoverageGLCallFlush }); /* Shared with OpenGL ES */
1356 funcs_map.insert({ "glBlendFunc", &ApiCoverageTestCase::TestCoverageGLCallBlendFunc }); /* Shared with OpenGL ES */
1357 funcs_map.insert({ "glLogicOp", &ApiCoverageTestCase::TestCoverageGLCallLogicOp });
1358 funcs_map.insert({ "glStencilFunc", &ApiCoverageTestCase::TestCoverageGLCallStencilFunc }); /* Shared with OpenGL ES */
1359 funcs_map.insert({ "glStencilOp", &ApiCoverageTestCase::TestCoverageGLCallStencilOp }); /* Shared with OpenGL ES */
1360 funcs_map.insert({ "glDepthFunc", &ApiCoverageTestCase::TestCoverageGLCallDepthFunc }); /* Shared with OpenGL ES */
1361 funcs_map.insert({ "glPixelStoref", &ApiCoverageTestCase::TestCoverageGLCallPixelStoref });
1362 funcs_map.insert({ "glPixelStorei", &ApiCoverageTestCase::TestCoverageGLCallPixelStorei }); /* Shared with OpenGL ES */
1363 funcs_map.insert({ "glReadBuffer", &ApiCoverageTestCase::TestCoverageGLCallReadBuffer }); /* Shared with OpenGL ES */
1364 funcs_map.insert({ "glReadPixels", &ApiCoverageTestCase::TestCoverageGLCallReadPixels }); /* Shared with OpenGL ES */
1365 funcs_map.insert({ "glGetBooleanv", &ApiCoverageTestCase::TestCoverageGLCallGetBooleanv }); /* Shared with OpenGL ES */
1366 funcs_map.insert({ "glGetDoublev", &ApiCoverageTestCase::TestCoverageGLCallGetDoublev });
1367 funcs_map.insert({ "gl.getError", &ApiCoverageTestCase::TestCoverageGLCallGetError }); /* Shared with OpenGL ES */
1368 funcs_map.insert({ "glGetFloatv", &ApiCoverageTestCase::TestCoverageGLCallGetFloatv }); /* Shared with OpenGL ES */
1369 funcs_map.insert({ "glGetIntegerv", &ApiCoverageTestCase::TestCoverageGLCallGetIntegerv }); /* Shared with OpenGL ES */
1370 funcs_map.insert({ "glGetString", &ApiCoverageTestCase::TestCoverageGLCallGetString }); /* Shared with OpenGL ES */
1371 funcs_map.insert({ "glGetTexImage", &ApiCoverageTestCase::TestCoverageGLCallGetTexImage });
1372 funcs_map.insert({ "glGetTexParameterfv", &ApiCoverageTestCase::TestCoverageGLCallGetTexParameterfv }); /* Shared with OpenGL ES */
1373 funcs_map.insert({ "glGetTexParameteriv", &ApiCoverageTestCase::TestCoverageGLCallGetTexParameteriv }); /* Shared with OpenGL ES */
1374 funcs_map.insert({ "glGetTexLevelParameterfv", &ApiCoverageTestCase::TestCoverageGLCallGetTexLevelParameterfv });
1375 funcs_map.insert({ "glGetTexLevelParameteriv", &ApiCoverageTestCase::TestCoverageGLCallGetTexLevelParameteriv });
1376 funcs_map.insert({ "glIsEnabled", &ApiCoverageTestCase::TestCoverageGLCallIsEnabled }); /* Shared with OpenGL ES */
1377 funcs_map.insert({ "glIsProgram", &ApiCoverageTestCase::TestCoverageGLCallIsProgram });
1378 funcs_map.insert({ "glIsShader", &ApiCoverageTestCase::TestCoverageGLCallIsShader });
1379 funcs_map.insert({ "glLinkProgram", &ApiCoverageTestCase::TestCoverageGLCallLinkProgram });
1380 funcs_map.insert({ "glShaderSource", &ApiCoverageTestCase::TestCoverageGLCallShaderSource });
1381 funcs_map.insert({ "glDepthRange", &ApiCoverageTestCase::TestCoverageGLCallDepthRange });
1382 funcs_map.insert({ "glViewport", &ApiCoverageTestCase::TestCoverageGLCallViewport }); /* Shared with OpenGL ES */
1383 funcs_map.insert({ "glDrawArrays", &ApiCoverageTestCase::TestCoverageGLCallDrawArrays }); /* Shared with OpenGL ES */
1384 funcs_map.insert({ "glDrawElements", &ApiCoverageTestCase::TestCoverageGLCallDrawElements }); /* Shared with OpenGL ES */
1385 funcs_map.insert({ "glGetPointerv", &ApiCoverageTestCase::TestCoverageGLCallGetPointerv });
1386 funcs_map.insert({ "glPolygonOffset", &ApiCoverageTestCase::TestCoverageGLCallPolygonOffset }); /* Shared with OpenGL ES */
1387 funcs_map.insert({ "glCopyTexImage1D", &ApiCoverageTestCase::TestCoverageGLCallCopyTexImage1D });
1388 funcs_map.insert({ "glCopyTexImage2D", &ApiCoverageTestCase::TestCoverageGLCallCopyTexImage2D }); /* Shared with OpenGL ES */
1389 funcs_map.insert({ "glCopyTexSubImage1D", &ApiCoverageTestCase::TestCoverageGLCallCopyTexSubImage1D });
1390 funcs_map.insert({ "glCopyTexSubImage2D", &ApiCoverageTestCase::TestCoverageGLCallCopyTexSubImage2D }); /* Shared with OpenGL ES */
1391 funcs_map.insert({ "glTexSubImage1D", &ApiCoverageTestCase::TestCoverageGLCallTexSubImage1D });
1392 funcs_map.insert({ "glTexSubImage2D", &ApiCoverageTestCase::TestCoverageGLCallTexSubImage2D }); /* Shared with OpenGL ES */
1393 funcs_map.insert({ "glBindTexture", &ApiCoverageTestCase::TestCoverageGLCallBindTexture }); /* Shared with OpenGL ES */
1394 funcs_map.insert({ "glDeleteTextures", &ApiCoverageTestCase::TestCoverageGLCallDeleteTextures }); /* Shared with OpenGL ES */
1395 funcs_map.insert({ "glGenTextures", &ApiCoverageTestCase::TestCoverageGLCallGenTextures }); /* Shared with OpenGL ES */
1396 funcs_map.insert({ "glIsTexture", &ApiCoverageTestCase::TestCoverageGLCallIsTexture }); /* Shared with OpenGL ES */
1397 funcs_map.insert({ "glBlendColor", &ApiCoverageTestCase::TestCoverageGLCallBlendColor }); /* Shared with OpenGL ES */
1398 funcs_map.insert({ "glBlendEquation", &ApiCoverageTestCase::TestCoverageGLCallBlendEquation }); /* Shared with OpenGL ES */
1399 funcs_map.insert({ "glDrawRangeElements", &ApiCoverageTestCase::TestCoverageGLCallDrawRangeElements }); /* Shared with OpenGL ES */
1400 funcs_map.insert({ "glTexImage3D", &ApiCoverageTestCase::TestCoverageGLCallTexImage3D }); /* Shared with OpenGL ES */
1401 funcs_map.insert({ "glTexSubImage3D", &ApiCoverageTestCase::TestCoverageGLCallTexSubImage3D }); /* Shared with OpenGL ES */
1402 funcs_map.insert({ "glCopyTexSubImage3D", &ApiCoverageTestCase::TestCoverageGLCallCopyTexSubImage3D }); /* Shared with OpenGL ES */
1403 funcs_map.insert({ "glActiveTexture", &ApiCoverageTestCase::TestCoverageGLCallActiveTexture }); /* Shared with OpenGL ES */
1404 funcs_map.insert({ "glSampleCoverage", &ApiCoverageTestCase::TestCoverageGLCallSampleCoverage }); /* Shared with OpenGL ES */
1405 funcs_map.insert({ "glCompressedTexImage3D", &ApiCoverageTestCase::TestCoverageGLCallCompressedTexImage3D }); /* Shared with OpenGL ES */
1406 funcs_map.insert({ "glCompressedTexImage2D", &ApiCoverageTestCase::TestCoverageGLCallCompressedTexImage2D }); /* Shared with OpenGL ES */
1407 funcs_map.insert({ "glCompressedTexImage1D", &ApiCoverageTestCase::TestCoverageGLCallCompressedTexImage1D });
1408 funcs_map.insert({ "glCompressedTexSubImage3D", &ApiCoverageTestCase::TestCoverageGLCallCompressedTexSubImage3D }); /* Shared with OpenGL ES */
1409 funcs_map.insert({ "glCompressedTexSubImage2D", &ApiCoverageTestCase::TestCoverageGLCallCompressedTexSubImage2D }); /* Shared with OpenGL ES */
1410 funcs_map.insert({ "glCompressedTexSubImage1D", &ApiCoverageTestCase::TestCoverageGLCallCompressedTexSubImage1D });
1411 funcs_map.insert({ "glGetCompressedTexImage", &ApiCoverageTestCase::TestCoverageGLCallGetCompressedTexImage });
1412 funcs_map.insert({ "glBlendFuncSeparate", &ApiCoverageTestCase::TestCoverageGLCallBlendFuncSeparate }); /* Shared with OpenGL ES */
1413 funcs_map.insert({ "glMultiDrawArrays", &ApiCoverageTestCase::TestCoverageGLCallMultiDrawArrays });
1414 funcs_map.insert({ "glMultiDrawElements", &ApiCoverageTestCase::TestCoverageGLCallMultiDrawElements });
1415 funcs_map.insert({ "glPointParameterf", &ApiCoverageTestCase::TestCoverageGLCallPointParameterf });
1416 funcs_map.insert({ "glPointParameterfv", &ApiCoverageTestCase::TestCoverageGLCallPointParameterfv });
1417 funcs_map.insert({ "glPointParameteri", &ApiCoverageTestCase::TestCoverageGLCallPointParameteri });
1418 funcs_map.insert({ "glPointParameteriv", &ApiCoverageTestCase::TestCoverageGLCallPointParameteriv });
1419 funcs_map.insert({ "glGenQueries", &ApiCoverageTestCase::TestCoverageGLCallGenQueries }); /* Shared with OpenGL ES */
1420 funcs_map.insert({ "glDeleteQueries", &ApiCoverageTestCase::TestCoverageGLCallDeleteQueries }); /* Shared with OpenGL ES */
1421 funcs_map.insert({ "glIsQuery", &ApiCoverageTestCase::TestCoverageGLCallIsQuery }); /* Shared with OpenGL ES */
1422 funcs_map.insert({ "glBeginQuery", &ApiCoverageTestCase::TestCoverageGLCallBeginQuery }); /* Shared with OpenGL ES */
1423 funcs_map.insert({ "glEndQuery", &ApiCoverageTestCase::TestCoverageGLCallEndQuery }); /* Shared with OpenGL ES */
1424 funcs_map.insert({ "glGetQueryiv", &ApiCoverageTestCase::TestCoverageGLCallGetQueryiv }); /* Shared with OpenGL ES */
1425 funcs_map.insert({ "glGetQueryObjectiv", &ApiCoverageTestCase::TestCoverageGLCallGetQueryObjectiv });
1426 funcs_map.insert({ "glGetQueryObjectuiv", &ApiCoverageTestCase::TestCoverageGLCallGetQueryObjectuiv }); /* Shared with OpenGL ES */
1427 funcs_map.insert({ "glBindBuffer", &ApiCoverageTestCase::TestCoverageGLCallBindBuffer }); /* Shared with OpenGL ES */
1428 funcs_map.insert({ "glDeleteBuffers", &ApiCoverageTestCase::TestCoverageGLCallDeleteBuffers }); /* Shared with OpenGL ES */
1429 funcs_map.insert({ "glGenBuffers", &ApiCoverageTestCase::TestCoverageGLCallGenBuffers }); /* Shared with OpenGL ES */
1430 funcs_map.insert({ "glIsBuffer", &ApiCoverageTestCase::TestCoverageGLCallIsBuffer }); /* Shared with OpenGL ES */
1431 funcs_map.insert({ "glBufferData", &ApiCoverageTestCase::TestCoverageGLCallBufferData }); /* Shared with OpenGL ES */
1432 funcs_map.insert({ "glBufferSubData", &ApiCoverageTestCase::TestCoverageGLCallBufferSubData }); /* Shared with OpenGL ES */
1433 funcs_map.insert({ "glGetBufferSubData", &ApiCoverageTestCase::TestCoverageGLCallGetBufferSubData }); /* Shared with OpenGL ES */
1434 funcs_map.insert({ "glMapBuffer", &ApiCoverageTestCase::TestCoverageGLCallMapBuffer });
1435 funcs_map.insert({ "glUnmapBuffer", &ApiCoverageTestCase::TestCoverageGLCallUnmapBuffer }); /* Shared with OpenGL ES */
1436 funcs_map.insert({ "glGetBufferParameteriv", &ApiCoverageTestCase::TestCoverageGLCallGetBufferParameteriv }); /* Shared with OpenGL ES */
1437 funcs_map.insert({ "glGetBufferPointerv", &ApiCoverageTestCase::TestCoverageGLCallGetBufferPointerv }); /* Shared with OpenGL ES */
1438 funcs_map.insert({ "glBlendEquationSeparate", &ApiCoverageTestCase::TestCoverageGLCallBlendEquationSeparate }); /* Shared with OpenGL ES */
1439 funcs_map.insert({ "glDrawBuffers", &ApiCoverageTestCase::TestCoverageGLCallDrawBuffers }); /* Shared with OpenGL ES */
1440 funcs_map.insert({ "glStencilOpSeparate", &ApiCoverageTestCase::TestCoverageGLCallStencilOpSeparate }); /* Shared with OpenGL ES */
1441 funcs_map.insert({ "glStencilFuncSeparate", &ApiCoverageTestCase::TestCoverageGLCallStencilFuncSeparate }); /* Shared with OpenGL ES */
1442 funcs_map.insert({ "glStencilMaskSeparate", &ApiCoverageTestCase::TestCoverageGLCallStencilMaskSeparate }); /* Shared with OpenGL ES */
1443 funcs_map.insert({ "glAttachShader", &ApiCoverageTestCase::TestCoverageGLCallAttachShader }); /* Shared with OpenGL ES */
1444 funcs_map.insert({ "glBindAttribLocation", &ApiCoverageTestCase::TestCoverageGLCallBindAttribLocation }); /* Shared with OpenGL ES */
1445 funcs_map.insert({ "glCompileShader", &ApiCoverageTestCase::TestCoverageGLCallCompileShader }); /* Shared with OpenGL ES */
1446 funcs_map.insert({ "glCreateProgram", &ApiCoverageTestCase::TestCoverageGLCallCreateProgram }); /* Shared with OpenGL ES */
1447 funcs_map.insert({ "glCreateShader", &ApiCoverageTestCase::TestCoverageGLCallCreateShader }); /* Shared with OpenGL ES */
1448 funcs_map.insert({ "glDeleteProgram", &ApiCoverageTestCase::TestCoverageGLCallDeleteProgram }); /* Shared with OpenGL ES */
1449 funcs_map.insert({ "glDeleteShader", &ApiCoverageTestCase::TestCoverageGLCallDeleteShader }); /* Shared with OpenGL ES */
1450 funcs_map.insert({ "glDetachShader", &ApiCoverageTestCase::TestCoverageGLCallDetachShader }); /* Shared with OpenGL ES */
1451 funcs_map.insert({ "glDisableVertexAttribArray", &ApiCoverageTestCase::TestCoverageGLCallDisableVertexAttribArray }); /* Shared with OpenGL ES */
1452 funcs_map.insert({ "glEnableVertexAttribArray", &ApiCoverageTestCase::TestCoverageGLCallEnableVertexAttribArray }); /* Shared with OpenGL ES */
1453 funcs_map.insert({ "glGetActiveAttrib", &ApiCoverageTestCase::TestCoverageGLCallGetActiveAttrib }); /* Shared with OpenGL ES */
1454 funcs_map.insert({ "glGetActiveUniform", &ApiCoverageTestCase::TestCoverageGLCallGetActiveUniform }); /* Shared with OpenGL ES */
1455 funcs_map.insert({ "glGetAttachedShaders", &ApiCoverageTestCase::TestCoverageGLCallGetAttachedShaders }); /* Shared with OpenGL ES */
1456 funcs_map.insert({ "glGetAttribLocation", &ApiCoverageTestCase::TestCoverageGLCallGetAttribLocation }); /* Shared with OpenGL ES */
1457 funcs_map.insert({ "glGetProgramiv", &ApiCoverageTestCase::TestCoverageGLCallGetProgramiv }); /* Shared with OpenGL ES */
1458 funcs_map.insert({ "glGetProgramInfoLog", &ApiCoverageTestCase::TestCoverageGLCallGetProgramInfoLog }); /* Shared with OpenGL ES */
1459 funcs_map.insert({ "glGetShaderiv", &ApiCoverageTestCase::TestCoverageGLCallGetShaderiv }); /* Shared with OpenGL ES */
1460 funcs_map.insert({ "glGetShaderInfoLog", &ApiCoverageTestCase::TestCoverageGLCallGetShaderInfoLog }); /* Shared with OpenGL ES */
1461 funcs_map.insert({ "glGetShaderSource", &ApiCoverageTestCase::TestCoverageGLCallGetShaderSource }); /* Shared with OpenGL ES */
1462 funcs_map.insert({ "glGetUniformLocation", &ApiCoverageTestCase::TestCoverageGLCallGetUniformLocation }); /* Shared with OpenGL ES */
1463 funcs_map.insert({ "glGetUniformfv", &ApiCoverageTestCase::TestCoverageGLCallGetUniformfv }); /* Shared with OpenGL ES */
1464 funcs_map.insert({ "glGetUniformiv", &ApiCoverageTestCase::TestCoverageGLCallGetUniformiv }); /* Shared with OpenGL ES */
1465 funcs_map.insert({ "glGetVertexAttribdv", &ApiCoverageTestCase::TestCoverageGLCallGetVertexAttribdv });
1466 funcs_map.insert({ "glGetVertexAttribfv", &ApiCoverageTestCase::TestCoverageGLCallGetVertexAttribfv }); /* Shared with OpenGL ES */
1467 funcs_map.insert({ "glGetVertexAttribiv", &ApiCoverageTestCase::TestCoverageGLCallGetVertexAttribiv }); /* Shared with OpenGL ES */
1468 funcs_map.insert({ "glGetVertexAttribPointerv", &ApiCoverageTestCase::TestCoverageGLCallGetVertexAttribPointerv }); /* Shared with OpenGL ES */
1469 funcs_map.insert({ "glUseProgram", &ApiCoverageTestCase::TestCoverageGLCallUseProgram }); /* Shared with OpenGL ES */
1470 funcs_map.insert({ "glUniform1f", &ApiCoverageTestCase::TestCoverageGLCallUniform1f }); /* Shared with OpenGL ES */
1471 funcs_map.insert({ "glUniform2f", &ApiCoverageTestCase::TestCoverageGLCallUniform2f }); /* Shared with OpenGL ES */
1472 funcs_map.insert({ "glUniform3f", &ApiCoverageTestCase::TestCoverageGLCallUniform3f }); /* Shared with OpenGL ES */
1473 funcs_map.insert({ "glUniform4f", &ApiCoverageTestCase::TestCoverageGLCallUniform4f }); /* Shared with OpenGL ES */
1474 funcs_map.insert({ "glUniform1i", &ApiCoverageTestCase::TestCoverageGLCallUniform1i }); /* Shared with OpenGL ES */
1475 funcs_map.insert({ "glUniform2i", &ApiCoverageTestCase::TestCoverageGLCallUniform2i }); /* Shared with OpenGL ES */
1476 funcs_map.insert({ "glUniform3i", &ApiCoverageTestCase::TestCoverageGLCallUniform3i }); /* Shared with OpenGL ES */
1477 funcs_map.insert({ "glUniform4i", &ApiCoverageTestCase::TestCoverageGLCallUniform4i }); /* Shared with OpenGL ES */
1478 funcs_map.insert({ "glUniform1fv", &ApiCoverageTestCase::TestCoverageGLCallUniform1fv }); /* Shared with OpenGL ES */
1479 funcs_map.insert({ "glUniform2fv", &ApiCoverageTestCase::TestCoverageGLCallUniform2fv }); /* Shared with OpenGL ES */
1480 funcs_map.insert({ "glUniform3fv", &ApiCoverageTestCase::TestCoverageGLCallUniform3fv }); /* Shared with OpenGL ES */
1481 funcs_map.insert({ "glUniform4fv", &ApiCoverageTestCase::TestCoverageGLCallUniform4fv }); /* Shared with OpenGL ES */
1482 funcs_map.insert({ "glUniform1iv", &ApiCoverageTestCase::TestCoverageGLCallUniform1iv }); /* Shared with OpenGL ES */
1483 funcs_map.insert({ "glUniform2iv", &ApiCoverageTestCase::TestCoverageGLCallUniform2iv }); /* Shared with OpenGL ES */
1484 funcs_map.insert({ "glUniform3iv", &ApiCoverageTestCase::TestCoverageGLCallUniform3iv }); /* Shared with OpenGL ES */
1485 funcs_map.insert({ "glUniform4iv", &ApiCoverageTestCase::TestCoverageGLCallUniform4iv }); /* Shared with OpenGL ES */
1486 funcs_map.insert({ "glUniformMatrix2fv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix2fv }); /* Shared with OpenGL ES */
1487 funcs_map.insert({ "glUniformMatrix3fv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix3fv }); /* Shared with OpenGL ES */
1488 funcs_map.insert({ "glUniformMatrix4fv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix4fv }); /* Shared with OpenGL ES */
1489 funcs_map.insert({ "glValidateProgram", &ApiCoverageTestCase::TestCoverageGLCallValidateProgram }); /* Shared with OpenGL ES */
1490 funcs_map.insert({ "glVertexAttrib1d", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib1d });
1491 funcs_map.insert({ "glVertexAttrib1dv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib1dv });
1492 funcs_map.insert({ "glVertexAttrib1f", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib1f }); /* Shared with OpenGL ES */
1493 funcs_map.insert({ "glVertexAttrib1fv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib1fv }); /* Shared with OpenGL ES */
1494 funcs_map.insert({ "glVertexAttrib1s", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib1s });
1495 funcs_map.insert({ "glVertexAttrib1sv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib1sv });
1496 funcs_map.insert({ "glVertexAttrib2d", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib2d });
1497 funcs_map.insert({ "glVertexAttrib2dv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib2dv });
1498 funcs_map.insert({ "glVertexAttrib2f", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib2f }); /* Shared with OpenGL ES */
1499 funcs_map.insert({ "glVertexAttrib2fv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib2fv }); /* Shared with OpenGL ES */
1500 funcs_map.insert({ "glVertexAttrib2s", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib2s });
1501 funcs_map.insert({ "glVertexAttrib2sv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib2sv });
1502 funcs_map.insert({ "glVertexAttrib3d", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib3d });
1503 funcs_map.insert({ "glVertexAttrib3dv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib3dv });
1504 funcs_map.insert({ "glVertexAttrib3f", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib3f }); /* Shared with OpenGL ES */
1505 funcs_map.insert({ "glVertexAttrib3fv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib3fv }); /* Shared with OpenGL ES */
1506 funcs_map.insert({ "glVertexAttrib3s", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib3s });
1507 funcs_map.insert({ "glVertexAttrib3sv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib3sv });
1508 funcs_map.insert({ "glVertexAttrib4Nbv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4Nbv });
1509 funcs_map.insert({ "glVertexAttrib4Niv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4Niv });
1510 funcs_map.insert({ "glVertexAttrib4Nsv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4Nsv });
1511 funcs_map.insert({ "glVertexAttrib4Nub", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4Nub });
1512 funcs_map.insert({ "glVertexAttrib4Nubv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4Nubv });
1513 funcs_map.insert({ "glVertexAttrib4Nuiv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4Nuiv });
1514 funcs_map.insert({ "glVertexAttrib4Nusv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4Nusv });
1515 funcs_map.insert({ "glVertexAttrib4bv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4bv });
1516 funcs_map.insert({ "glVertexAttrib4d", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4d });
1517 funcs_map.insert({ "glVertexAttrib4dv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4dv });
1518 funcs_map.insert({ "glVertexAttrib4f", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4f }); /* Shared with OpenGL ES */
1519 funcs_map.insert({ "glVertexAttrib4fv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4fv }); /* Shared with OpenGL ES */
1520 funcs_map.insert({ "glVertexAttrib4iv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4iv });
1521 funcs_map.insert({ "glVertexAttrib4s", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4s });
1522 funcs_map.insert({ "glVertexAttrib4sv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4sv });
1523 funcs_map.insert({ "glVertexAttrib4ubv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4ubv });
1524 funcs_map.insert({ "glVertexAttrib4uiv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4uiv });
1525 funcs_map.insert({ "glVertexAttrib4usv", &ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4usv });
1526 funcs_map.insert({ "glVertexAttribPointer", &ApiCoverageTestCase::TestCoverageGLCallVertexAttribPointer }); /* Shared with OpenGL ES */
1527 funcs_map.insert({ "glUniformMatrix2x3fv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix2x3fv });
1528 funcs_map.insert({ "glUniformMatrix3x2fv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix3x2fv });
1529 funcs_map.insert({ "glUniformMatrix2x4fv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix2x4fv }); /* Shared with OpenGL ES */
1530 funcs_map.insert({ "glUniformMatrix4x2fv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix4x2fv });
1531 funcs_map.insert({ "glUniformMatrix3x4fv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix3x4fv });
1532 funcs_map.insert({ "glUniformMatrix4x3fv", &ApiCoverageTestCase::TestCoverageGLCallUniformMatrix4x3fv });
1533 }
1534 // clang-format on
1535 }
1536 }
1537
verifyEnum(const std::string & name,const std::string & value)1538 bool ApiCoverageTestCase::verifyEnum(const std::string &name, const std::string &value)
1539 {
1540 GLenum enumExpected = ~0;
1541 GLboolean compare_value = false;
1542
1543 if (value.find("GL_") != std::string::npos)
1544 {
1545 // special cases for set of enums holding the same value
1546 if (value == "GL_DRAW_FRAMEBUFFER_BINDING")
1547 enumExpected = GL_DRAW_FRAMEBUFFER_BINDING;
1548 else if (value == "GL_MAX_VARYING_COMPONENTS")
1549 enumExpected = GL_MAX_VARYING_COMPONENTS;
1550 else if (value == "GL_VERTEX_PROGRAM_POINT_SIZE")
1551 enumExpected = GL_VERTEX_PROGRAM_POINT_SIZE;
1552 compare_value = true;
1553 }
1554 else
1555 sscanf(value.c_str(), "%x", &enumExpected);
1556
1557 if (name.substr(std::max(0, (int)name.size() - 4)) == "_BIT")
1558 {
1559 return isNameWithinBitfield(name, enumExpected);
1560 }
1561 else
1562 {
1563 // special case here
1564 if (name == "GL_INVALID_INDEX")
1565 return enumExpected == GL_INVALID_INDEX;
1566 else if (name == "GL_TIMEOUT_IGNORED")
1567 {
1568 unsigned long long expected = 0;
1569 sscanf(value.c_str(), "%llx", &expected);
1570 return expected == GL_TIMEOUT_IGNORED;
1571 }
1572
1573 std::set<std::string> names;
1574 getEnumNames(enumExpected, names);
1575
1576 if (enumExpected == 1)
1577 {
1578 for (auto ver_name : m_version_names)
1579 names.insert(ver_name);
1580 }
1581
1582 if (compare_value)
1583 {
1584 for (auto &&found : names)
1585 if (value == found)
1586 return true;
1587 }
1588 else
1589 {
1590 for (auto &&found : names)
1591 if (name == found)
1592 return true;
1593 }
1594 }
1595 return false;
1596 }
1597
verifyFunc(const std::string & name)1598 bool ApiCoverageTestCase::verifyFunc(const std::string &name)
1599 {
1600 if (funcs_map.find(name) == funcs_map.end())
1601 {
1602 m_testCtx.getLog() << tcu::TestLog::Message << "Function coverage test not supported : " << name.c_str()
1603 << tcu::TestLog::EndMessage;
1604 return true;
1605 }
1606
1607 test_func_ptr func_ptr = funcs_map[name];
1608 if (!(this->*func_ptr)())
1609 return false;
1610
1611 return true;
1612 }
1613
1614 template <typename... Args>
tcu_fail_msg(const std::string & format,Args...args)1615 inline void ApiCoverageTestCase::tcu_fail_msg(const std::string &format, Args... args)
1616 {
1617 int str_size = std::snprintf(nullptr, 0, format.c_str(), args...) + 1;
1618 if (str_size <= 0)
1619 throw std::runtime_error("Formatting error.");
1620 size_t s = static_cast<size_t>(str_size);
1621 std::unique_ptr<char[]> buffer(new char[s]);
1622 std::snprintf(buffer.get(), s, format.c_str(), args...);
1623 m_testCtx.getLog() << tcu::TestLog::Message << buffer.get() << tcu::TestLog::EndMessage;
1624 }
1625
tcu_msg(const std::string & msg0,const std::string & msg1)1626 void ApiCoverageTestCase::tcu_msg(const std::string &msg0, const std::string &msg1)
1627 {
1628 m_testCtx.getLog() << tcu::TestLog::Message << msg0.c_str() << " : " << msg1.c_str() << tcu::TestLog::EndMessage;
1629 }
1630
createDefaultProgram(int mode)1631 GLint ApiCoverageTestCase::createDefaultProgram(int mode)
1632 {
1633 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
1634
1635 std::string vert_shader = tcu::StringTemplate(m_vert_shader).specialize(specialization_map);
1636 std::string frag_shader = tcu::StringTemplate(m_frag_shader).specialize(specialization_map);
1637
1638 GLuint program;
1639 GLint status = 0;
1640 GLuint vertexShader = gl.createShader(GL_VERTEX_SHADER);
1641 GLU_EXPECT_NO_ERROR(gl.getError(), "createShader");
1642
1643 GLuint fragmentShader = gl.createShader(GL_FRAGMENT_SHADER);
1644 GLU_EXPECT_NO_ERROR(gl.getError(), "createShader");
1645
1646 const char *vert_src = vert_shader.c_str();
1647 gl.shaderSource(vertexShader, 1, &vert_src, NULL);
1648 GLU_EXPECT_NO_ERROR(gl.getError(), "shaderSource");
1649 gl.compileShader(vertexShader);
1650 GLU_EXPECT_NO_ERROR(gl.getError(), "compileShader");
1651 gl.getShaderiv(vertexShader, GL_COMPILE_STATUS, &status);
1652 GLU_EXPECT_NO_ERROR(gl.getError(), "getShaderiv");
1653 if (status == GL_FALSE)
1654 {
1655 GLint infoLogLength = 0;
1656 gl.getShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &infoLogLength);
1657
1658 std::vector<char> infoLogBuf(infoLogLength + 1);
1659 gl.getShaderInfoLog(vertexShader, (GLsizei)infoLogBuf.size(), NULL, &infoLogBuf[0]);
1660
1661 m_context.getTestContext().getLog()
1662 << tcu::TestLog::Message << vert_src << " compilation should succed. Info Log:\n"
1663 << infoLogBuf.data() << tcu::TestLog::EndMessage;
1664
1665 gl.deleteShader(vertexShader);
1666
1667 return -1;
1668 }
1669
1670 const char *frag_src = frag_shader.c_str();
1671 gl.shaderSource(fragmentShader, 1, &frag_src, NULL);
1672 GLU_EXPECT_NO_ERROR(gl.getError(), "shaderSource");
1673 gl.compileShader(fragmentShader);
1674 GLU_EXPECT_NO_ERROR(gl.getError(), "compileShader");
1675 gl.getShaderiv(fragmentShader, GL_COMPILE_STATUS, &status);
1676 GLU_EXPECT_NO_ERROR(gl.getError(), "getShaderiv");
1677 if (status == GL_FALSE)
1678 {
1679 GLint infoLogLength = 0;
1680 gl.getShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &infoLogLength);
1681
1682 std::vector<char> infoLogBuf(infoLogLength + 1);
1683 gl.getShaderInfoLog(fragmentShader, (GLsizei)infoLogBuf.size(), NULL, &infoLogBuf[0]);
1684
1685 m_context.getTestContext().getLog()
1686 << tcu::TestLog::Message << frag_src << " compilation should succed. Info Log:\n"
1687 << infoLogBuf.data() << tcu::TestLog::EndMessage;
1688
1689 gl.deleteShader(fragmentShader);
1690 return -1;
1691 }
1692
1693 program = gl.createProgram();
1694 GLU_EXPECT_NO_ERROR(gl.getError(), "createProgram");
1695 gl.attachShader(program, vertexShader);
1696 GLU_EXPECT_NO_ERROR(gl.getError(), "attachShader");
1697 gl.attachShader(program, fragmentShader);
1698 GLU_EXPECT_NO_ERROR(gl.getError(), "attachShader");
1699 gl.deleteShader(vertexShader);
1700 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteShader");
1701 gl.deleteShader(fragmentShader);
1702 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteShader");
1703 gl.bindAttribLocation(program, 0, "inPosition");
1704 GLU_EXPECT_NO_ERROR(gl.getError(), "bindAttribLocation");
1705 gl.bindAttribLocation(program, 1, "inTexCoord");
1706 GLU_EXPECT_NO_ERROR(gl.getError(), "bindAttribLocation");
1707
1708 if (mode) // only transformfeedback for now
1709 {
1710 const char *ptex = "texCoords";
1711 gl.transformFeedbackVaryings(program, 1, &ptex, GL_SEPARATE_ATTRIBS);
1712 GLU_EXPECT_NO_ERROR(gl.getError(), "transformFeedbackVaryings");
1713 }
1714
1715 gl.linkProgram(program);
1716 GLU_EXPECT_NO_ERROR(gl.getError(), "linkProgram");
1717 gl.getProgramiv(program, GL_LINK_STATUS, &status);
1718 GLU_EXPECT_NO_ERROR(gl.getError(), "getProgramiv");
1719 if (!status)
1720 {
1721 return -1;
1722 }
1723
1724 gl.useProgram(program);
1725 GLU_EXPECT_NO_ERROR(gl.getError(), "useProgram");
1726
1727 return (GLint)program;
1728 }
1729
1730 /** Executes test iteration.
1731 *
1732 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
1733 */
iterate()1734 tcu::TestNode::IterateResult ApiCoverageTestCase::iterate()
1735 {
1736 bool ret = true;
1737 std::string file_name = m_is_context_ES ? m_config_name : "common/" + m_config_name;
1738
1739 tcu::Archive &archive = m_context.getTestContext().getArchive();
1740 xe::xml::Parser xmlParser;
1741
1742 {
1743 de::UniquePtr<tcu::Resource> res(archive.getResource(file_name.c_str()));
1744
1745 if (res->getSize() == 0)
1746 {
1747 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1748 return STOP;
1749 }
1750
1751 std::vector<uint8_t> data(res->getSize());
1752 res->read(&data[0], (int)data.size());
1753
1754 // feed parser with xml content
1755 xmlParser.feed(reinterpret_cast<const uint8_t *>(data.data()), static_cast<int>(data.size()));
1756 }
1757 xmlParser.advance();
1758
1759 bool skan_enums = false;
1760 bool skan_funcs = false;
1761
1762 std::string name;
1763 std::string value;
1764
1765 while (true)
1766 {
1767 xe::xml::Element currElement = xmlParser.getElement();
1768
1769 // stop if there is parsing error
1770 if (currElement == xe::xml::ELEMENT_INCOMPLETE || currElement == xe::xml::ELEMENT_END_OF_STRING)
1771 break;
1772
1773 const char *elemName = xmlParser.getElementName();
1774 switch (currElement)
1775 {
1776 case xe::xml::ELEMENT_START:
1777 if (strcmp(elemName, "func") == 0)
1778 {
1779 skan_funcs = true;
1780 }
1781 else if (strcmp(elemName, "enum") == 0)
1782 {
1783 skan_enums = true;
1784 }
1785 break;
1786
1787 case xe::xml::ELEMENT_DATA:
1788 if (skan_funcs)
1789 {
1790 if (name.empty() && strcmp(elemName, "name") == 0)
1791 {
1792 xmlParser.getDataStr(name);
1793 }
1794 }
1795 else if (skan_enums)
1796 {
1797 if (name.empty() && strcmp(elemName, "name") == 0)
1798 {
1799 xmlParser.getDataStr(name);
1800 }
1801 else if (value.empty() && strcmp(elemName, "value") == 0)
1802 {
1803 xmlParser.getDataStr(value);
1804 }
1805 }
1806 break;
1807
1808 case xe::xml::ELEMENT_END:
1809
1810 if (strcmp(elemName, "func") == 0)
1811 {
1812 skan_funcs = false;
1813 if (!verifyFunc(name))
1814 {
1815 ret = false;
1816
1817 m_testCtx.getLog() << tcu::TestLog::Message << "Function verification failed :" << name
1818 << tcu::TestLog::EndMessage;
1819 }
1820
1821 name.clear();
1822 }
1823 else if (strcmp(elemName, "enum") == 0)
1824 {
1825 skan_enums = false;
1826
1827 if (!verifyEnum(name, value))
1828 {
1829 ret = false;
1830
1831 m_testCtx.getLog() << tcu::TestLog::Message << "Enum verification failed :" << name << " : "
1832 << value << tcu::TestLog::EndMessage;
1833 }
1834
1835 name.clear();
1836 value.clear();
1837 }
1838
1839 break;
1840
1841 default:
1842 DE_ASSERT(false);
1843 }
1844
1845 xmlParser.advance();
1846 }
1847
1848 if (ret)
1849 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1850 else
1851 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1852 return STOP;
1853 }
1854
TestCoverageGLCallActiveTexture(void)1855 bool ApiCoverageTestCase::TestCoverageGLCallActiveTexture(void)
1856 {
1857 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
1858 GLint i = 0;
1859 bool success = true;
1860 GLint numUnits = 0;
1861
1862 gl.getIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &numUnits);
1863 GLU_EXPECT_NO_ERROR(gl.getError(), "getIntegerv");
1864
1865 if (numUnits > 32)
1866 {
1867 numUnits = 32;
1868 }
1869
1870 for (i = 0; i < numUnits; i++)
1871 {
1872 gl.activeTexture(GL_TEXTURE0 + i);
1873 GLU_EXPECT_NO_ERROR(gl.getError(), "activeTexture");
1874
1875 if (gl.getError() == GL_INVALID_ENUM)
1876 {
1877 tcu_fail_msg("ApiCoverageTestCase::CallActiveTexture", "Invalid enum : GL_TEXTURE%d", i);
1878 success = false;
1879 }
1880 }
1881
1882 return success;
1883 }
1884
TestCoverageGLCallAttachShader(void)1885 bool ApiCoverageTestCase::TestCoverageGLCallAttachShader(void)
1886 {
1887 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
1888 GLuint buf[2];
1889 bool success = true;
1890 GLint i;
1891
1892 // There are tests that leak programs/shaders so we have to find a number that is not a program/shader
1893 for (i = 1; i < 0x7fffffff; ++i)
1894 {
1895 GLboolean isObject;
1896 isObject = gl.isProgram(i) || gl.isShader(i);
1897 GLU_EXPECT_NO_ERROR(gl.getError(), "isShader");
1898
1899 if (!isObject)
1900 {
1901 break;
1902 }
1903 }
1904 buf[0] = i;
1905
1906 for (i = i + 1; i < 0x7fffffff; ++i)
1907 {
1908 GLboolean isObject;
1909 isObject = gl.isProgram(i) || gl.isShader(i);
1910 GLU_EXPECT_NO_ERROR(gl.getError(), "isShader");
1911
1912 if (!isObject)
1913 {
1914 break;
1915 }
1916 }
1917 buf[1] = i;
1918
1919 // ??? : how should this be handled?
1920 gl.attachShader(buf[0], buf[1]);
1921
1922 if (gl.getError() != GL_INVALID_VALUE)
1923 {
1924 tcu_fail_msg("ApiCoverageTestCase::CallAttachShader", "glAttachShader : did not return GL_INVALID_VALUE");
1925 success = false;
1926 }
1927
1928 return success;
1929 }
1930
TestCoverageGLCallBindAttribLocation(void)1931 bool ApiCoverageTestCase::TestCoverageGLCallBindAttribLocation(void)
1932 {
1933 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
1934 GLint i;
1935 char strBuf[32];
1936 GLuint program;
1937 GLint maxAttribs = 0;
1938 bool success = true;
1939
1940 gl.getIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxAttribs);
1941 GLU_EXPECT_NO_ERROR(gl.getError(), "getIntegerv");
1942
1943 program = gl.createProgram();
1944 GLU_EXPECT_NO_ERROR(gl.getError(), "createProgram");
1945
1946 for (i = 0; i < maxAttribs; i++)
1947 {
1948 std::snprintf(strBuf, sizeof(strBuf), "attrib%d", i);
1949 gl.bindAttribLocation(program, i, strBuf);
1950
1951 if (gl.getError() != GL_NO_ERROR)
1952 {
1953 tcu_fail_msg("ApiCoverageTestCase::CallBindAttribLocation", "glBindAttribLocation : failed on attrib %d",
1954 i);
1955 success = false;
1956 }
1957 }
1958
1959 gl.useProgram(0);
1960 GLU_EXPECT_NO_ERROR(gl.getError(), "useProgram");
1961 gl.deleteProgram(program);
1962 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
1963
1964 return success;
1965 }
1966
TestCoverageGLCallBindBuffer(void)1967 bool ApiCoverageTestCase::TestCoverageGLCallBindBuffer(void)
1968 {
1969 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
1970 GLint i;
1971 bool success = true;
1972
1973 for (i = 0; ea_BufferObjectTargets[i].value != -1; i++)
1974 {
1975 gl.bindBuffer(ea_BufferObjectTargets[i].value, 0);
1976
1977 if (gl.getError() == GL_INVALID_ENUM)
1978 {
1979 tcu_fail_msg("ApiCoverageTestCase::CallBindBuffer", "Invalid enum : %s", ea_BufferObjectTargets[i].name);
1980 success = false;
1981 }
1982 }
1983
1984 return success;
1985 }
1986
TestCoverageGLCallBindTexture(void)1987 bool ApiCoverageTestCase::TestCoverageGLCallBindTexture(void)
1988 {
1989 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
1990 bool success = true;
1991
1992 gl.bindTexture(GL_TEXTURE_2D, 0);
1993 GLU_EXPECT_NO_ERROR(gl.getError(), "bindTexture");
1994
1995 return success;
1996 }
1997
TestCoverageGLCallBlendColor(void)1998 bool ApiCoverageTestCase::TestCoverageGLCallBlendColor(void)
1999 {
2000 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2001 bool success = true;
2002
2003 gl.enable(GL_BLEND);
2004 GLU_EXPECT_NO_ERROR(gl.getError(), "enable");
2005 gl.blendColor(-0.5f, 0.2f, 2.5f, 0.5f);
2006 GLU_EXPECT_NO_ERROR(gl.getError(), "blendColor");
2007
2008 return success;
2009 }
2010
TestCoverageGLCallBlendEquation(void)2011 bool ApiCoverageTestCase::TestCoverageGLCallBlendEquation(void)
2012 {
2013 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2014 GLint i;
2015 bool success = true;
2016
2017 gl.enable(GL_BLEND);
2018 GLU_EXPECT_NO_ERROR(gl.getError(), "enable");
2019
2020 for (i = 0; ea_BlendEquation[i].value != -1; i++)
2021 {
2022 gl.blendEquation(ea_BlendEquation[i].value);
2023
2024 if (gl.getError() == GL_INVALID_ENUM)
2025 {
2026 tcu_fail_msg("ApiCoverageTestCase::CallBlendEquation", "Invalid enum : %s", ea_BlendEquation[i].name);
2027 success = false;
2028 }
2029 }
2030
2031 return success;
2032 }
2033
TestCoverageGLCallBlendEquationSeparate(void)2034 bool ApiCoverageTestCase::TestCoverageGLCallBlendEquationSeparate(void)
2035 {
2036 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2037 GLint i, j;
2038 bool success = true;
2039
2040 gl.enable(GL_BLEND);
2041 GLU_EXPECT_NO_ERROR(gl.getError(), "enable");
2042
2043 for (i = 0; ea_BlendEquationSeparate1[i].value != -1; i++)
2044 {
2045 for (j = 0; ea_BlendEquationSeparate2[j].value != -1; j++)
2046 {
2047 gl.blendEquationSeparate(ea_BlendEquationSeparate1[i].value, ea_BlendEquationSeparate2[j].value);
2048
2049 if (gl.getError() == GL_INVALID_ENUM)
2050 {
2051 tcu_fail_msg("ApiCoverageTestCase::CallBlendEquationSeparate", "Invalid enums : (%s, %s)",
2052 ea_BlendEquationSeparate1[i].name, ea_BlendEquationSeparate2[j].name);
2053 success = false;
2054 }
2055 }
2056 }
2057
2058 return success;
2059 }
2060
TestCoverageGLCallBlendFunc(void)2061 bool ApiCoverageTestCase::TestCoverageGLCallBlendFunc(void)
2062 {
2063 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2064 GLint i, j;
2065 bool success = true;
2066
2067 gl.enable(GL_BLEND);
2068 GLU_EXPECT_NO_ERROR(gl.getError(), "enable");
2069
2070 for (i = 0; ea_BlendFunc1[i].value != -1; i++)
2071 {
2072 for (j = 0; ea_BlendFunc2[j].value != -1; j++)
2073 {
2074 gl.blendFunc(ea_BlendFunc1[i].value, ea_BlendFunc2[j].value);
2075
2076 if (gl.getError() == GL_INVALID_ENUM)
2077 {
2078 tcu_fail_msg("ApiCoverageTestCase::CallBlendEquationSeparate", "Invalid enums : (%s, %s)",
2079 ea_BlendFunc1[i].name, ea_BlendFunc2[j].name);
2080 success = false;
2081 }
2082 }
2083 }
2084
2085 return success;
2086 }
2087
TestCoverageGLCallBlendFuncSeparate(void)2088 bool ApiCoverageTestCase::TestCoverageGLCallBlendFuncSeparate(void)
2089 {
2090 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2091 GLint i, j, k, l;
2092 bool success = true;
2093
2094 gl.enable(GL_BLEND);
2095 GLU_EXPECT_NO_ERROR(gl.getError(), "enable");
2096
2097 for (i = 0; ea_BlendFuncSeparate1[i].value != -1; i++)
2098 {
2099 for (j = 0; ea_BlendFuncSeparate2[j].value != -1; j++)
2100 {
2101 for (k = 0; ea_BlendFuncSeparate3[k].value != -1; k++)
2102 {
2103 for (l = 0; ea_BlendFuncSeparate4[l].value != -1; l++)
2104 {
2105 gl.blendFuncSeparate(ea_BlendFuncSeparate1[i].value, ea_BlendFuncSeparate2[j].value,
2106 ea_BlendFuncSeparate3[k].value, ea_BlendFuncSeparate4[l].value);
2107
2108 if (gl.getError() == GL_INVALID_ENUM)
2109 {
2110 tcu_fail_msg("ApiCoverageTestCase::CallBlendEquationSeparate",
2111 "Invalid enums : (%s, %s, %s, %s)", ea_BlendFuncSeparate1[i].name,
2112 ea_BlendFuncSeparate2[j].name, ea_BlendFuncSeparate3[k].name,
2113 ea_BlendFuncSeparate4[l].name);
2114 success = false;
2115 }
2116 }
2117 }
2118 }
2119 }
2120
2121 return success;
2122 }
2123
TestCoverageGLCallBufferData(void)2124 bool ApiCoverageTestCase::TestCoverageGLCallBufferData(void)
2125 {
2126 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2127 GLint i, j;
2128 GLuint buf = 2;
2129 static const GLfloat dummyData[] = {1.0f, 2.0f, 3.0f};
2130 bool success = true;
2131
2132 gl.genBuffers(1, &buf);
2133 GLU_EXPECT_NO_ERROR(gl.getError(), "genBuffers");
2134 for (i = 0; ea_BufferObjectTargets[i].value != -1; i++)
2135 {
2136 for (j = 0; ea_BufferObjectUsages[j].value != -1; j++)
2137 {
2138 gl.bindBuffer(ea_BufferObjectTargets[i].value, buf);
2139 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBuffer");
2140 gl.bufferData(ea_BufferObjectTargets[i].value, 3, dummyData, ea_BufferObjectUsages[j].value);
2141
2142 if (gl.getError() == GL_INVALID_ENUM)
2143 {
2144 tcu_fail_msg("ApiCoverageTestCase::CallBufferData", "Invalid enums : (%s, %s)",
2145 ea_BufferObjectTargets[i].name, ea_BufferObjectUsages[j].name);
2146 success = false;
2147 }
2148 }
2149 }
2150 gl.deleteBuffers(1, &buf);
2151 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
2152
2153 return success;
2154 }
2155
TestCoverageGLCallBufferSubData(void)2156 bool ApiCoverageTestCase::TestCoverageGLCallBufferSubData(void)
2157 {
2158 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2159 GLint i, j;
2160 GLuint buf = 2;
2161 static const GLfloat dummyData[] = {1.0f, 2.0f, 3.0f};
2162 bool success = true;
2163
2164 gl.genBuffers(1, &buf);
2165 GLU_EXPECT_NO_ERROR(gl.getError(), "genBuffers");
2166 for (i = 0; ea_BufferObjectTargets[i].value != -1; i++)
2167 {
2168 for (j = 0; ea_BufferObjectUsages[j].value != -1; j++)
2169 {
2170 gl.bindBuffer(ea_BufferObjectTargets[i].value, buf);
2171 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBuffer");
2172 gl.bufferData(ea_BufferObjectTargets[i].value, 3, dummyData, ea_BufferObjectUsages[j].value);
2173 GLU_EXPECT_NO_ERROR(gl.getError(), "bufferData");
2174 gl.bufferSubData(ea_BufferObjectTargets[i].value, 0, 3, dummyData);
2175
2176 if (gl.getError() == GL_INVALID_ENUM)
2177 {
2178 tcu_fail_msg("ApiCoverageTestCase::CallBufferData", "Invalid enums : (%s, %s)",
2179 ea_BufferObjectTargets[i].name, ea_BufferObjectUsages[j].name);
2180 success = false;
2181 }
2182 }
2183 }
2184 gl.deleteBuffers(1, &buf);
2185 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
2186
2187 return success;
2188 }
2189
TestCoverageGLCallClear(void)2190 bool ApiCoverageTestCase::TestCoverageGLCallClear(void)
2191 {
2192 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2193 GLint i;
2194 bool success = true;
2195
2196 for (i = 0; ea_ClearBufferMask[i].value != -1; i++)
2197 {
2198 gl.clear(ea_ClearBufferMask[i].value);
2199
2200 if (gl.getError() == GL_INVALID_ENUM)
2201 {
2202 tcu_fail_msg("ApiCoverageTestCase::CallClear", "Invalid enum : %s", ea_ClearBufferMask[i].name);
2203 success = false;
2204 }
2205 }
2206
2207 return success;
2208 }
2209
TestCoverageGLCallClearColor(void)2210 bool ApiCoverageTestCase::TestCoverageGLCallClearColor(void)
2211 {
2212 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2213 bool success = true;
2214
2215 gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
2216 GLU_EXPECT_NO_ERROR(gl.getError(), "clearColor");
2217
2218 return success;
2219 }
2220
TestCoverageGLCallClearStencil(void)2221 bool ApiCoverageTestCase::TestCoverageGLCallClearStencil(void)
2222 {
2223 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2224 bool success = true;
2225
2226 gl.clearStencil(0);
2227 GLU_EXPECT_NO_ERROR(gl.getError(), "clearStencil");
2228
2229 return success;
2230 }
2231
TestCoverageGLCallColorMask(void)2232 bool ApiCoverageTestCase::TestCoverageGLCallColorMask(void)
2233 {
2234 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2235 bool success = true;
2236
2237 gl.colorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
2238 GLU_EXPECT_NO_ERROR(gl.getError(), "colorMask");
2239
2240 return success;
2241 }
2242
TestCoverageGLGetNumPaletteEntries(GLenum format)2243 GLsizei ApiCoverageTestCase::TestCoverageGLGetNumPaletteEntries(GLenum format)
2244 {
2245 if (m_is_context_ES)
2246 {
2247 switch (format)
2248 {
2249 case GL_PALETTE4_R5_G6_B5_OES:
2250 case GL_PALETTE4_RGB8_OES:
2251 case GL_PALETTE4_RGBA4_OES:
2252 case GL_PALETTE4_RGB5_A1_OES:
2253 case GL_PALETTE4_RGBA8_OES:
2254 return 16;
2255
2256 case GL_PALETTE8_R5_G6_B5_OES:
2257 case GL_PALETTE8_RGB8_OES:
2258 case GL_PALETTE8_RGBA4_OES:
2259 case GL_PALETTE8_RGB5_A1_OES:
2260 case GL_PALETTE8_RGBA8_OES:
2261 return 256;
2262
2263 default:
2264 return 0;
2265 }
2266 }
2267 else
2268 return 0;
2269 }
2270
TestCoverageGLGetPixelSize(GLenum format)2271 GLsizei ApiCoverageTestCase::TestCoverageGLGetPixelSize(GLenum format)
2272 {
2273 if (m_is_context_ES)
2274 {
2275 switch (format)
2276 {
2277 case GL_PALETTE4_R5_G6_B5_OES:
2278 case GL_PALETTE4_RGBA4_OES:
2279 case GL_PALETTE4_RGB5_A1_OES:
2280 case GL_PALETTE8_R5_G6_B5_OES:
2281 case GL_PALETTE8_RGBA4_OES:
2282 case GL_PALETTE8_RGB5_A1_OES:
2283 return 2;
2284
2285 case GL_PALETTE4_RGB8_OES:
2286 case GL_PALETTE8_RGB8_OES:
2287 return 3;
2288
2289 case GL_PALETTE4_RGBA8_OES:
2290 case GL_PALETTE8_RGBA8_OES:
2291 return 4;
2292 default:
2293 return 0;
2294 }
2295 }
2296 else
2297 return 0;
2298 }
2299
TestCoverageGLGetCompressedPaletteSize(GLenum internalformat)2300 GLsizei ApiCoverageTestCase::TestCoverageGLGetCompressedPaletteSize(GLenum internalformat)
2301 {
2302 return TestCoverageGLGetPixelSize(internalformat) * TestCoverageGLGetNumPaletteEntries(internalformat);
2303 }
2304
TestCoverageGLGetCompressedPixelsSize(GLenum internalformat,GLsizei width,GLsizei height,GLsizei border)2305 GLsizei ApiCoverageTestCase::TestCoverageGLGetCompressedPixelsSize(GLenum internalformat, GLsizei width, GLsizei height,
2306 GLsizei border)
2307 {
2308 GLsizei pixels;
2309
2310 pixels = (width + border * 2) * (height + border * 2);
2311
2312 if (m_is_context_ES)
2313 {
2314 switch (internalformat)
2315 {
2316 case GL_PALETTE4_RGB8_OES:
2317 case GL_PALETTE4_RGBA8_OES:
2318 case GL_PALETTE4_R5_G6_B5_OES:
2319 case GL_PALETTE4_RGBA4_OES:
2320 case GL_PALETTE4_RGB5_A1_OES:
2321 return ((pixels % 2) == 0) ? (pixels / 2) : (pixels / 2 + 1);
2322
2323 case GL_PALETTE8_RGB8_OES:
2324 case GL_PALETTE8_RGBA8_OES:
2325 case GL_PALETTE8_R5_G6_B5_OES:
2326 case GL_PALETTE8_RGBA4_OES:
2327 case GL_PALETTE8_RGB5_A1_OES:
2328 return pixels;
2329 default:
2330 return 0;
2331 }
2332 }
2333 else
2334 return 0;
2335 }
2336
TestCoverageGLGetCompressedTextureSize(GLenum internalformat,GLsizei width,GLsizei height,GLsizei border)2337 GLsizei ApiCoverageTestCase::TestCoverageGLGetCompressedTextureSize(GLenum internalformat, GLsizei width,
2338 GLsizei height, GLsizei border)
2339 {
2340 return TestCoverageGLGetCompressedPaletteSize(internalformat) +
2341 TestCoverageGLGetCompressedPixelsSize(internalformat, width, height, border);
2342 }
2343
TestCoverageGLCallCompressedTexImage2D(void)2344 bool ApiCoverageTestCase::TestCoverageGLCallCompressedTexImage2D(void)
2345 {
2346 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2347 bool success = true;
2348 GLubyte buf[1025]; /* big enough for 256*1 byte palette + 1 byte image */
2349 GLsizei size;
2350 GLint i;
2351
2352 if (m_context.getContextInfo().isExtensionSupported("GL_OES_compressed_paletted_texture"))
2353 {
2354 for (i = 0; ea_CompressedTextureFormats[i].value != -1; i++)
2355 {
2356 size = TestCoverageGLGetCompressedTextureSize(ea_CompressedTextureFormats[i].value, 1, 1, 0);
2357
2358 memset(buf, 0, sizeof(buf));
2359
2360 gl.compressedTexImage2D(GL_TEXTURE_2D, 0, ea_CompressedTextureFormats[i].value, 1, 1, 0, size, buf);
2361
2362 if (gl.getError() == GL_INVALID_ENUM)
2363 {
2364 tcu_fail_msg("ApiCoverageTestCase::CallCompressedTexImage2D", "Invalid enum : %s",
2365 ea_CompressedTextureFormats[i].name);
2366 success = false;
2367 }
2368
2369 gl.compressedTexImage2D(GL_TEXTURE_2D, 0, ea_CompressedTextureFormats[i].value, 1, 1, 0, size,
2370 (const void *)NULL);
2371 GLU_EXPECT_NO_ERROR(gl.getError(), "compressedTexImage2D");
2372 if (gl.getError() == GL_INVALID_ENUM)
2373 {
2374 tcu_fail_msg("ApiCoverageTestCase::CallCompressedTexImage2D", "Invalid enum : %s",
2375 ea_CompressedTextureFormats[i].name);
2376 success = false;
2377 }
2378 }
2379 }
2380
2381 /* It would be nice to test any other exported compressed texture formats, but it is not possible to know the size
2382 to pass in, so this is likely to result in INVALID_VALUE.
2383 */
2384 return success;
2385 }
2386
TestCoverageGLCallCompressedTexSubImage2D(void)2387 bool ApiCoverageTestCase::TestCoverageGLCallCompressedTexSubImage2D(void)
2388 {
2389 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2390 bool success = true;
2391 GLubyte buf[1025];
2392 GLsizei size;
2393 GLint i;
2394
2395 if (m_context.getContextInfo().isExtensionSupported("GL_OES_compressed_paletted_texture"))
2396 {
2397 for (i = 0; ea_CompressedTextureFormats[i].value != -1; i++)
2398 {
2399 size = TestCoverageGLGetCompressedTextureSize(ea_CompressedTextureFormats[i].value, 1, 1, 0);
2400
2401 memset(buf, 0, sizeof(buf));
2402
2403 gl.compressedTexImage2D(GL_TEXTURE_2D, 0, ea_CompressedTextureFormats[i].value, 1, 1, 0, size,
2404 (const void *)NULL);
2405
2406 if (gl.getError() == GL_INVALID_ENUM)
2407 {
2408 tcu_fail_msg("ApiCoverageTestCase::CallCompressedTexSubImage2D", "Invalid enum : %s",
2409 ea_CompressedTextureFormats[i].name);
2410 success = false;
2411 }
2412
2413 gl.compressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1, 1, ea_CompressedTextureFormats[i].value, size, buf);
2414 GLU_EXPECT_NO_ERROR(gl.getError(), "compressedTexSubImage2D");
2415
2416 /* not sure if error should be INVALID_OPERATION or INVALID_ENUM */
2417 gl.getError();
2418 GLU_EXPECT_NO_ERROR(gl.getError(), "getError");
2419 }
2420 }
2421
2422 /* It would be nice to test any other exported compressed texture formats, but it is not possible to know the size
2423 to pass in, so this is likely to result in INVALID_VALUE.
2424 */
2425 return success;
2426 }
2427
TestCoverageGLGuessColorBufferFormat(void)2428 GLenum ApiCoverageTestCase::TestCoverageGLGuessColorBufferFormat(void)
2429 {
2430 GLsizei colorBits[4];
2431
2432 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2433
2434 getReadbufferBits(gl, m_is_context_ES, GL_RED_BITS, &colorBits[0]);
2435 getReadbufferBits(gl, m_is_context_ES, GL_GREEN_BITS, &colorBits[1]);
2436 getReadbufferBits(gl, m_is_context_ES, GL_BLUE_BITS, &colorBits[2]);
2437 getReadbufferBits(gl, m_is_context_ES, GL_ALPHA_BITS, &colorBits[3]);
2438
2439 if (m_is_context_ES)
2440 {
2441 if (colorBits[0] == 0)
2442 {
2443 return GL_ALPHA;
2444 }
2445 else
2446 {
2447 if (colorBits[1] == 0 || colorBits[2] == 0)
2448 {
2449 if (colorBits[3] == 0)
2450 {
2451 return GL_LUMINANCE;
2452 }
2453 else
2454 {
2455 return GL_LUMINANCE_ALPHA;
2456 }
2457 }
2458 else
2459 {
2460 if (colorBits[3] == 0)
2461 {
2462 return GL_RGB;
2463 }
2464 else
2465 {
2466 return GL_RGBA;
2467 }
2468 }
2469 }
2470 }
2471 else
2472 {
2473 if (colorBits[3])
2474 {
2475 return GL_RGBA;
2476 }
2477 else if (colorBits[2])
2478 {
2479 return GL_RGB;
2480 }
2481 else if (colorBits[1])
2482 {
2483 return GL_RG;
2484 }
2485 else if (colorBits[0])
2486 {
2487 return GL_RED;
2488 }
2489 else
2490 {
2491 return GL_NONE;
2492 }
2493 }
2494 }
2495
TestCoverageGLCalcTargetFormats(GLenum colorBufferFormat,GLenum * textureFormats)2496 GLsizei ApiCoverageTestCase::TestCoverageGLCalcTargetFormats(GLenum colorBufferFormat, GLenum *textureFormats)
2497 {
2498 GLsizei i;
2499
2500 i = 0;
2501
2502 if (m_is_context_ES)
2503 {
2504 switch (colorBufferFormat)
2505 {
2506 case GL_ALPHA:
2507 textureFormats[i++] = GL_ALPHA;
2508 break;
2509
2510 case GL_LUMINANCE:
2511 textureFormats[i++] = GL_LUMINANCE;
2512 break;
2513
2514 case GL_LUMINANCE_ALPHA:
2515 textureFormats[i++] = GL_LUMINANCE;
2516 textureFormats[i++] = GL_LUMINANCE_ALPHA;
2517 textureFormats[i++] = GL_ALPHA;
2518 break;
2519
2520 case GL_RGB:
2521 textureFormats[i++] = GL_RGB;
2522 textureFormats[i++] = GL_LUMINANCE;
2523 break;
2524
2525 case GL_RGBA:
2526 textureFormats[i++] = GL_RGB;
2527 textureFormats[i++] = GL_RGBA;
2528 textureFormats[i++] = GL_LUMINANCE;
2529 textureFormats[i++] = GL_LUMINANCE_ALPHA;
2530 textureFormats[i++] = GL_ALPHA;
2531 break;
2532 }
2533 }
2534 else
2535 {
2536 switch (colorBufferFormat)
2537 {
2538 case GL_RED:
2539 textureFormats[i++] = GL_RED;
2540 break;
2541
2542 case GL_RG:
2543 textureFormats[i++] = GL_RED;
2544 textureFormats[i++] = GL_RG;
2545 break;
2546
2547 case GL_RGB:
2548 textureFormats[i++] = GL_RED;
2549 textureFormats[i++] = GL_RG;
2550 textureFormats[i++] = GL_RGB;
2551 break;
2552
2553 case GL_RGBA:
2554 textureFormats[i++] = GL_RED;
2555 textureFormats[i++] = GL_RG;
2556 textureFormats[i++] = GL_RGB;
2557 textureFormats[i++] = GL_RGBA;
2558 break;
2559 }
2560 }
2561
2562 return i;
2563 }
2564
TestCoverageGLCallCopyTexImage2D(void)2565 bool ApiCoverageTestCase::TestCoverageGLCallCopyTexImage2D(void)
2566 {
2567 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2568 bool success = true;
2569 GLenum colorBufferFormat, targetFormats[5];
2570 GLsizei numTargetFormats;
2571 GLint i;
2572
2573 colorBufferFormat = TestCoverageGLGuessColorBufferFormat();
2574 numTargetFormats = TestCoverageGLCalcTargetFormats(colorBufferFormat, targetFormats);
2575
2576 for (i = 0; i != numTargetFormats; i++)
2577 {
2578 gl.copyTexImage2D(GL_TEXTURE_2D, 0, targetFormats[i], 0, 0, 1, 1, 0);
2579
2580 if (gl.getError() == GL_INVALID_ENUM)
2581 {
2582 const char *invalidEnum = glu::getTextureFormatName(targetFormats[i]);
2583 tcu_fail_msg("ApiCoverageTestCase::CallCopyTexImage2D", "Invalid enum : %s", invalidEnum);
2584 success = false;
2585 }
2586 }
2587
2588 return success;
2589 }
2590
TestCoverageGLCallCopyTexSubImage2D(void)2591 bool ApiCoverageTestCase::TestCoverageGLCallCopyTexSubImage2D(void)
2592 {
2593 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2594 bool success = true;
2595 GLubyte buf[1000];
2596 GLenum colorBufferFormat, targetFormats[5];
2597 GLsizei numTargetFormats;
2598 GLint i;
2599
2600 colorBufferFormat = TestCoverageGLGuessColorBufferFormat();
2601 numTargetFormats = TestCoverageGLCalcTargetFormats(colorBufferFormat, targetFormats);
2602
2603 memset(buf, 0, sizeof(GLubyte) * 100);
2604
2605 for (i = 0; i != numTargetFormats; i++)
2606 {
2607 gl.texImage2D(GL_TEXTURE_2D, 0, targetFormats[i], 1, 1, 0, targetFormats[i], GL_UNSIGNED_BYTE, buf);
2608 GLU_EXPECT_NO_ERROR(gl.getError(), "texImage2D");
2609 gl.copyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 1, 1);
2610
2611 if (gl.getError() == GL_INVALID_ENUM)
2612 {
2613 const char *invalidEnum = glu::getTextureFormatName(targetFormats[i]);
2614 tcu_fail_msg("ApiCoverageTestCase::CallCopyTexSubImage2D", "Invalid enum : %s", invalidEnum);
2615 success = false;
2616 }
2617
2618 gl.texImage2D(GL_TEXTURE_2D, 0, targetFormats[i], 1, 1, 0, targetFormats[i], GL_UNSIGNED_BYTE,
2619 (const void *)NULL);
2620 GLU_EXPECT_NO_ERROR(gl.getError(), "texImage2D");
2621 gl.copyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 1, 1);
2622
2623 if (gl.getError() == GL_INVALID_ENUM)
2624 {
2625 const char *invalidEnum = glu::getTextureFormatName(targetFormats[i]);
2626 tcu_fail_msg("ApiCoverageTestCase::CallCopyTexSubImage2D", "Invalid enum : %s", invalidEnum);
2627 success = false;
2628 }
2629 }
2630
2631 return success;
2632 }
2633
TestCoverageGLCallCreateProgram(void)2634 bool ApiCoverageTestCase::TestCoverageGLCallCreateProgram(void)
2635 {
2636 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2637 bool success = true;
2638 GLuint program;
2639
2640 program = gl.createProgram();
2641 GLU_EXPECT_NO_ERROR(gl.getError(), "createProgram");
2642
2643 gl.useProgram(0);
2644 GLU_EXPECT_NO_ERROR(gl.getError(), "useProgram");
2645 gl.deleteProgram(program);
2646 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
2647
2648 return success;
2649 }
2650
TestCoverageGLCallCreateShader(void)2651 bool ApiCoverageTestCase::TestCoverageGLCallCreateShader(void)
2652 {
2653 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2654 bool success = true;
2655 GLint i;
2656
2657 for (i = 0; ea_ShaderTypes[i].value != -1; i++)
2658 {
2659 GLuint shader = gl.createShader(ea_ShaderTypes[i].value);
2660
2661 if (gl.getError() == GL_INVALID_ENUM)
2662 {
2663 tcu_fail_msg("ApiCoverageTestCase::CallCreateShader", "Invalid enum : %s", ea_ShaderTypes[i]);
2664 success = false;
2665 }
2666 gl.deleteShader(shader);
2667 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteShader");
2668 }
2669
2670 return success;
2671 }
2672
TestCoverageGLCallCullFace(void)2673 bool ApiCoverageTestCase::TestCoverageGLCallCullFace(void)
2674 {
2675 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2676 GLint i;
2677 bool success = true;
2678
2679 for (i = 0; ea_CullFaceMode[i].value != -1; i++)
2680 {
2681 gl.cullFace(ea_CullFaceMode[i].value);
2682
2683 if (gl.getError() == GL_INVALID_ENUM)
2684 {
2685 tcu_fail_msg("ApiCoverageTestCase::CallCullFace", "Invalid enum : %s", ea_CullFaceMode[i].name);
2686 success = false;
2687 }
2688 }
2689
2690 return success;
2691 }
2692
TestCoverageGLCallDeleteBuffers(void)2693 bool ApiCoverageTestCase::TestCoverageGLCallDeleteBuffers(void)
2694 {
2695 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2696 GLint i;
2697 bool success = true;
2698
2699 for (i = 0; ea_BufferObjectTargets[i].value != -1; i++)
2700 {
2701 GLuint buf[1];
2702 buf[0] = 2;
2703
2704 gl.bindBuffer(ea_BufferObjectTargets[i].value, buf[0]);
2705
2706 if (gl.getError() == GL_INVALID_ENUM)
2707 {
2708 tcu_fail_msg("ApiCoverageTestCase::CallDeleteBuffers", "Invalid enum : %s", ea_BufferObjectTargets[i].name);
2709 success = false;
2710 }
2711
2712 gl.deleteBuffers(1, buf);
2713 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
2714 }
2715
2716 return success;
2717 }
2718
TestCoverageGLCallDeleteTextures(void)2719 bool ApiCoverageTestCase::TestCoverageGLCallDeleteTextures(void)
2720 {
2721 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2722 bool success = true;
2723
2724 GLuint buf[1];
2725 buf[0] = 2;
2726
2727 gl.bindTexture(GL_TEXTURE_2D, buf[0]);
2728
2729 if (gl.getError() == GL_INVALID_ENUM)
2730 {
2731 tcu_fail_msg("ApiCoverageTestCase::CallDeleteBuffers", "Invalid enum : GL_TEXTURE_2D");
2732 success = false;
2733 }
2734
2735 gl.deleteTextures(1, buf);
2736 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteTextures");
2737
2738 return success;
2739 }
2740
TestCoverageGLCallDeleteProgram(void)2741 bool ApiCoverageTestCase::TestCoverageGLCallDeleteProgram(void)
2742 {
2743 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2744 bool success = true;
2745 GLuint program;
2746
2747 program = gl.createProgram();
2748 GLU_EXPECT_NO_ERROR(gl.getError(), "createProgram");
2749
2750 gl.useProgram(0);
2751 GLU_EXPECT_NO_ERROR(gl.getError(), "useProgram");
2752 gl.deleteProgram(program);
2753 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
2754
2755 return success;
2756 }
2757
TestCoverageGLCallDeleteShader(void)2758 bool ApiCoverageTestCase::TestCoverageGLCallDeleteShader(void)
2759 {
2760 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2761 bool success = true;
2762 GLint i;
2763
2764 for (i = 0; ea_ShaderTypes[i].value != -1; i++)
2765 {
2766 GLuint shader = gl.createShader(ea_ShaderTypes[i].value);
2767 if (gl.getError() == GL_INVALID_ENUM)
2768 {
2769 tcu_fail_msg("ApiCoverageTestCase::CallDeleteShader", "Invalid enum : %s", ea_ShaderTypes[i]);
2770 success = false;
2771 }
2772 gl.deleteShader(shader);
2773 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteShader");
2774 }
2775
2776 return success;
2777 }
2778
TestCoverageGLCallDetachShader(void)2779 bool ApiCoverageTestCase::TestCoverageGLCallDetachShader(void)
2780 {
2781 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2782 bool success = true;
2783 GLint i;
2784 GLuint program = gl.createProgram();
2785 GLU_EXPECT_NO_ERROR(gl.getError(), "createProgram");
2786
2787 for (i = 0; ea_ShaderTypes[i].value != -1; i++)
2788 {
2789 GLuint shader = gl.createShader(ea_ShaderTypes[i].value);
2790 GLU_EXPECT_NO_ERROR(gl.getError(), "createShader");
2791
2792 gl.attachShader(program, shader);
2793 GLU_EXPECT_NO_ERROR(gl.getError(), "attachShader");
2794 gl.detachShader(program, shader);
2795 GLU_EXPECT_NO_ERROR(gl.getError(), "detachShader");
2796
2797 gl.deleteShader(shader);
2798 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteShader");
2799 }
2800
2801 gl.useProgram(0);
2802 GLU_EXPECT_NO_ERROR(gl.getError(), "useProgram");
2803 gl.deleteProgram(program);
2804 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
2805
2806 return success;
2807 }
2808
TestCoverageGLCallDepthFunc(void)2809 bool ApiCoverageTestCase::TestCoverageGLCallDepthFunc(void)
2810 {
2811 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2812 GLint i;
2813 bool success = true;
2814
2815 for (i = 0; ea_DepthFunction[i].value != -1; i++)
2816 {
2817 gl.depthFunc(ea_DepthFunction[i].value);
2818
2819 if (gl.getError() == GL_INVALID_ENUM)
2820 {
2821 tcu_fail_msg("ApiCoverageTestCase::CallDepthFunc", "Invalid enum : %s", ea_DepthFunction[i].name);
2822 success = false;
2823 }
2824 }
2825
2826 return success;
2827 }
2828
TestCoverageGLCallDepthMask(void)2829 bool ApiCoverageTestCase::TestCoverageGLCallDepthMask(void)
2830 {
2831 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2832 bool success = true;
2833
2834 gl.depthMask(GL_FALSE);
2835 GLU_EXPECT_NO_ERROR(gl.getError(), "depthMask");
2836
2837 return success;
2838 }
2839
TestCoverageGLCallDisable(void)2840 bool ApiCoverageTestCase::TestCoverageGLCallDisable(void)
2841 {
2842 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2843 bool success = true;
2844 GLint i;
2845
2846 for (i = 0; ea_Enable[i].value != -1; i++)
2847 {
2848 gl.disable(ea_Enable[i].value);
2849
2850 if (gl.getError() == GL_INVALID_ENUM)
2851 {
2852 tcu_fail_msg("ApiCoverageTestCase::CallDisable", "Invalid enum : %s", ea_Enable[i].name);
2853 success = false;
2854 }
2855 }
2856
2857 return success;
2858 }
2859
TestCoverageGLCallDisableVertexAttribArray(void)2860 bool ApiCoverageTestCase::TestCoverageGLCallDisableVertexAttribArray(void)
2861 {
2862 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2863 bool success = true;
2864
2865 gl.enableVertexAttribArray(0);
2866 GLU_EXPECT_NO_ERROR(gl.getError(), "enableVertexAttribArray");
2867 gl.disableVertexAttribArray(0);
2868 GLU_EXPECT_NO_ERROR(gl.getError(), "disableVertexAttribArray");
2869
2870 return success;
2871 }
2872
TestCoverageGLCallDrawArrays(void)2873 bool ApiCoverageTestCase::TestCoverageGLCallDrawArrays(void)
2874 {
2875 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2876 bool success = true;
2877 GLint i;
2878
2879 for (i = 0; ea_Primitives[i].value != -1; i++)
2880 {
2881 gl.drawArrays(ea_Primitives[i].value, 0, 1);
2882
2883 if (gl.getError() == GL_INVALID_ENUM)
2884 {
2885 tcu_fail_msg("ApiCoverageTestCase::CallDrawArrays", "Invalid enum : %s", ea_Primitives[i].name);
2886 success = false;
2887 }
2888 }
2889
2890 return success;
2891 }
2892
TestCoverageGLCallDrawElements(void)2893 bool ApiCoverageTestCase::TestCoverageGLCallDrawElements(void)
2894 {
2895 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2896 bool success = true;
2897 GLint i;
2898
2899 for (i = 0; ea_Primitives[i].value != -1; i++)
2900 {
2901 {
2902 GLubyte indices[1];
2903 indices[0] = 0;
2904 gl.drawElements(ea_Primitives[i].value, 1, GL_UNSIGNED_BYTE, indices);
2905
2906 if (gl.getError() == GL_INVALID_ENUM)
2907 {
2908 tcu_fail_msg("ApiCoverageTestCase::CallDrawElements", "Invalid enum : %s", ea_Primitives[i].name);
2909 success = false;
2910 }
2911 }
2912
2913 {
2914 GLushort indices[1];
2915 indices[0] = 0;
2916 gl.drawElements(ea_Primitives[i].value, 1, GL_UNSIGNED_SHORT, indices);
2917
2918 if (gl.getError() == GL_INVALID_ENUM)
2919 {
2920 tcu_fail_msg("ApiCoverageTestCase::CallDrawElements", "Invalid enum : %s", ea_Primitives[i].name);
2921 success = false;
2922 }
2923 }
2924 }
2925
2926 return success;
2927 }
2928
TestCoverageGLCallEnable(void)2929 bool ApiCoverageTestCase::TestCoverageGLCallEnable(void)
2930 {
2931 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2932 bool success = true;
2933 GLint i;
2934
2935 for (i = 0; ea_Enable[i].value != -1; i++)
2936 {
2937 gl.enable(ea_Enable[i].value);
2938
2939 if (gl.getError() == GL_INVALID_ENUM)
2940 {
2941 tcu_fail_msg("ApiCoverageTestCase::CallEnable", "Invalid enum : %s", ea_Enable[i].name);
2942 success = false;
2943 }
2944 }
2945
2946 return success;
2947 }
2948
TestCoverageGLCallEnableVertexAttribArray(void)2949 bool ApiCoverageTestCase::TestCoverageGLCallEnableVertexAttribArray(void)
2950 {
2951 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2952 bool success = true;
2953
2954 gl.enableVertexAttribArray(0);
2955 GLU_EXPECT_NO_ERROR(gl.getError(), "enableVertexAttribArray");
2956 gl.disableVertexAttribArray(0);
2957 GLU_EXPECT_NO_ERROR(gl.getError(), "disableVertexAttribArray");
2958
2959 return success;
2960 }
2961
TestCoverageGLCallFinish(void)2962 bool ApiCoverageTestCase::TestCoverageGLCallFinish(void)
2963 {
2964 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2965 bool success = true;
2966
2967 gl.finish();
2968 GLU_EXPECT_NO_ERROR(gl.getError(), "finish");
2969
2970 return success;
2971 }
2972
TestCoverageGLCallFlush(void)2973 bool ApiCoverageTestCase::TestCoverageGLCallFlush(void)
2974 {
2975 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2976 bool success = true;
2977
2978 gl.flush();
2979 GLU_EXPECT_NO_ERROR(gl.getError(), "flush");
2980
2981 return success;
2982 }
2983
TestCoverageGLCallFrontFace(void)2984 bool ApiCoverageTestCase::TestCoverageGLCallFrontFace(void)
2985 {
2986 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
2987 bool success = true;
2988 GLint i;
2989
2990 for (i = 0; ea_FrontFaceDirection[i].value != -1; i++)
2991 {
2992 gl.frontFace(ea_FrontFaceDirection[i].value);
2993
2994 if (gl.getError() == GL_INVALID_ENUM)
2995 {
2996 tcu_fail_msg("ApiCoverageTestCase::CallFrontFace", "Invalid enum : %s", ea_FrontFaceDirection[i].name);
2997 success = false;
2998 }
2999 }
3000
3001 return success;
3002 }
3003
TestCoverageGLCallGetActiveAttrib(void)3004 bool ApiCoverageTestCase::TestCoverageGLCallGetActiveAttrib(void)
3005 {
3006 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3007 bool success = true;
3008 GLsizei length;
3009 GLint size;
3010 GLenum type;
3011 GLchar name[256];
3012
3013 // ??? : will this maybe not work
3014 gl.getActiveAttrib(0, 0, 256, &length, &size, &type, name);
3015 if (gl.getError() != GL_INVALID_VALUE)
3016 {
3017 tcu_fail_msg("ApiCoverageTestCase::CallGetActiveAttrib", "Unexpected getActiveAttrib result");
3018 success = false;
3019 }
3020
3021 return success;
3022 }
3023
TestCoverageGLCallGetActiveUniform(void)3024 bool ApiCoverageTestCase::TestCoverageGLCallGetActiveUniform(void)
3025 {
3026 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3027 bool success = true;
3028 GLsizei length;
3029 GLint size;
3030 GLenum type;
3031 GLchar name[256];
3032
3033 // ??? : will this maybe not work -> All shader examples should return GL_INVALID_OPERATION if incorrect program object
3034 gl.getActiveUniform(0, 0, 256, &length, &size, &type, name);
3035 if (gl.getError() != GL_INVALID_VALUE)
3036 {
3037 tcu_fail_msg("ApiCoverageTestCase::CallGetActiveUniform", "Unexpected getActiveUniform result");
3038 success = false;
3039 }
3040
3041 return success;
3042 }
3043
TestCoverageGLCallGetAttachedShaders(void)3044 bool ApiCoverageTestCase::TestCoverageGLCallGetAttachedShaders(void)
3045 {
3046 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3047 bool success = true;
3048 GLsizei count;
3049 GLuint shaders[10];
3050 GLuint program;
3051
3052 program = gl.createProgram();
3053 GLU_EXPECT_NO_ERROR(gl.getError(), "createProgram");
3054
3055 gl.getAttachedShaders(program, 10, &count, shaders);
3056 GLU_EXPECT_NO_ERROR(gl.getError(), "getAttachedShaders");
3057 gl.useProgram(0);
3058 GLU_EXPECT_NO_ERROR(gl.getError(), "useProgram");
3059 gl.deleteProgram(program);
3060 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
3061
3062 return success;
3063 }
3064
TestCoverageGLCallGetAttribLocation(void)3065 bool ApiCoverageTestCase::TestCoverageGLCallGetAttribLocation(void)
3066 {
3067 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3068 bool success = true;
3069 GLuint program;
3070
3071 program = gl.createProgram();
3072 GLU_EXPECT_NO_ERROR(gl.getError(), "createProgram");
3073 gl.getAttribLocation(program, "attrib");
3074
3075 /* program is unlinked, so error should be INVALID_OPERATION */
3076 if (gl.getError() != GL_INVALID_OPERATION)
3077 {
3078 tcu_fail_msg("ApiCoverageTestCase::CallGetAttribLocation", "GL_INVALID_OPERATION not returned.");
3079 success = false;
3080 }
3081
3082 gl.useProgram(0);
3083 GLU_EXPECT_NO_ERROR(gl.getError(), "useProgram");
3084 gl.deleteProgram(program);
3085 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
3086
3087 return success;
3088 }
3089
TestCoverageGLCallGetBooleanv(void)3090 bool ApiCoverageTestCase::TestCoverageGLCallGetBooleanv(void)
3091 {
3092 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3093 bool success = true;
3094 GLint i;
3095 GLboolean buf[10];
3096
3097 for (i = 0; ea_GetBoolean[i].value != -1; i++)
3098 {
3099 gl.getBooleanv(ea_GetBoolean[i].value, buf);
3100
3101 if (gl.getError() == GL_INVALID_ENUM)
3102 {
3103 tcu_fail_msg("ApiCoverageTestCase::CallGetBooleanv", "Invalid enum : %s", ea_GetBoolean[i].name);
3104 success = false;
3105 }
3106 }
3107
3108 return success;
3109 }
3110
TestCoverageGLCallGetBufferParameteriv(void)3111 bool ApiCoverageTestCase::TestCoverageGLCallGetBufferParameteriv(void)
3112 {
3113 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3114 bool success = true;
3115 GLint i, j;
3116 GLint buf[10];
3117
3118 for (j = 0; ea_BufferObjectTargets[j].value != -1; j++)
3119 {
3120 GLuint buffer = 0;
3121 gl.genBuffers(1, &buffer);
3122 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
3123
3124 gl.bindBuffer(ea_BufferObjectTargets[j].value, buffer);
3125 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBuffer");
3126
3127 for (i = 0; ea_GetBufferParameter[i].value != -1; i++)
3128 {
3129 gl.getBufferParameteriv(ea_BufferObjectTargets[j].value, ea_GetBufferParameter[i].value, buf);
3130
3131 if (gl.getError() == GL_INVALID_ENUM)
3132 {
3133 tcu_fail_msg("ApiCoverageTestCase::CallGetBufferParameteriv", "Invalid enums : (%s, %s)",
3134 ea_BufferObjectTargets[j].name, ea_GetBufferParameter[i].name);
3135 success = false;
3136 }
3137 }
3138
3139 if (m_context.getContextInfo().isExtensionSupported("GL_OES_mapbuffer"))
3140 {
3141 for (i = 0; ea_GetBufferParameter_OES_mapbuffer[i].value != -1; i++)
3142 {
3143 gl.getBufferParameteriv(ea_BufferObjectTargets[j].value, ea_GetBufferParameter_OES_mapbuffer[i].value,
3144 buf);
3145
3146 if (gl.getError() == GL_INVALID_ENUM)
3147 {
3148 tcu_fail_msg("ApiCoverageTestCase::CallGetBufferParameteriv", "Invalid enums : (%s, %s)",
3149 ea_BufferObjectTargets[j].name, ea_GetBufferParameter_OES_mapbuffer[i].name);
3150 success = false;
3151 }
3152 }
3153 }
3154
3155 gl.deleteBuffers(1, &buffer);
3156 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
3157 }
3158
3159 return success;
3160 }
3161
TestCoverageGLCallGenBuffers(void)3162 bool ApiCoverageTestCase::TestCoverageGLCallGenBuffers(void)
3163 {
3164 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3165 bool success = true;
3166 GLuint buffers[10];
3167
3168 gl.genBuffers(10, buffers);
3169 GLU_EXPECT_NO_ERROR(gl.getError(), "genBuffers");
3170 gl.deleteBuffers(10, buffers);
3171 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
3172
3173 return success;
3174 }
3175
TestCoverageGLCallGenTextures(void)3176 bool ApiCoverageTestCase::TestCoverageGLCallGenTextures(void)
3177 {
3178 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3179 bool success = true;
3180 GLuint buffers[10];
3181
3182 gl.genTextures(10, buffers);
3183 GLU_EXPECT_NO_ERROR(gl.getError(), "genTextures");
3184 gl.deleteTextures(10, buffers);
3185 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteTextures");
3186
3187 return success;
3188 }
3189
TestCoverageGLCallGetError(void)3190 bool ApiCoverageTestCase::TestCoverageGLCallGetError(void)
3191 {
3192 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3193 bool success = true;
3194
3195 gl.getError();
3196 GLU_EXPECT_NO_ERROR(gl.getError(), "getError");
3197
3198 return success;
3199 }
3200
TestCoverageGLCallGetFloatv(void)3201 bool ApiCoverageTestCase::TestCoverageGLCallGetFloatv(void)
3202 {
3203 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3204 bool success = true;
3205 GLint i;
3206 GLfloat buf[10];
3207
3208 for (i = 0; ea_GetFloat[i].value != -1; i++)
3209 {
3210 gl.getFloatv(ea_GetFloat[i].value, buf);
3211
3212 if (gl.getError() == GL_INVALID_ENUM)
3213 {
3214 tcu_fail_msg("ApiCoverageTestCase::CallGetFloatv", "Invalid enum : %s", ea_GetFloat[i].name);
3215 success = false;
3216 }
3217 }
3218
3219 return success;
3220 }
3221
TestCoverageGLCallGetIntegerv(void)3222 bool ApiCoverageTestCase::TestCoverageGLCallGetIntegerv(void)
3223 {
3224 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3225 bool success = true;
3226 GLint i;
3227 // buf[10] too small. There are could be more the this for the GL_COMPRESSED_TEXTURE_FORMATS token.
3228 // The correct fix is to figure out the max value that this could be and and allocate the amount of memory.
3229 // But the easier fix is to assume that 256 is enough for anyone.
3230 GLint buf[256];
3231 GLboolean isES3 = GL_FALSE;
3232
3233 for (i = 0; ea_GetInteger[i].value != -1; i++)
3234 {
3235 gl.getIntegerv(ea_GetInteger[i].value, buf);
3236
3237 if (gl.getError() == GL_INVALID_ENUM)
3238 {
3239 tcu_fail_msg("ApiCoverageTestCase::CallGetIntegerv", "Invalid enum : %s", ea_GetInteger[i].name);
3240 success = false;
3241 }
3242 }
3243
3244 {
3245 const char *versionString = (const char *)gl.getString(GL_VERSION);
3246 GLU_EXPECT_NO_ERROR(gl.getError(), "getString");
3247
3248 double versionFloat = atof(versionString);
3249 if (versionFloat >= 3.0)
3250 {
3251 isES3 = GL_TRUE;
3252 }
3253 }
3254
3255 if (isES3)
3256 {
3257 for (i = 0; ea_GetIntegerES3[i].value != -1; i++)
3258 {
3259 gl.getIntegerv(ea_GetIntegerES3[i].value, buf);
3260
3261 if (gl.getError() == GL_INVALID_ENUM)
3262 {
3263 tcu_fail_msg("ApiCoverageTestCase::CallGetIntegerv", "Invalid enum : %s", ea_GetIntegerES3[i].name);
3264 success = false;
3265 }
3266 }
3267 }
3268
3269 if (m_context.getContextInfo().isExtensionSupported("GL_OES_texture_3D"))
3270 {
3271 for (i = 0; ea_GetInteger_OES_Texture_3D[i].value != -1; i++)
3272 {
3273 gl.getIntegerv(ea_GetInteger_OES_Texture_3D[i].value, buf);
3274
3275 if (gl.getError() == GL_INVALID_ENUM)
3276 {
3277 tcu_fail_msg("ApiCoverageTestCase::CallGetIntegerv", "Invalid enum : %s",
3278 ea_GetInteger_OES_Texture_3D[i].name);
3279 success = false;
3280 }
3281 }
3282 }
3283
3284 return success;
3285 }
3286
TestCoverageGLCallGetProgramiv(void)3287 bool ApiCoverageTestCase::TestCoverageGLCallGetProgramiv(void)
3288 {
3289 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3290 bool success = true;
3291 GLint i;
3292 GLint buf[10];
3293 GLuint program;
3294
3295 program = gl.createProgram();
3296 GLU_EXPECT_NO_ERROR(gl.getError(), "createProgram");
3297
3298 for (i = 0; ea_GetProgram[i].value != -1; i++)
3299 {
3300 gl.getProgramiv(program, ea_GetProgram[i].value, buf);
3301
3302 if (gl.getError() == GL_INVALID_ENUM)
3303 {
3304 tcu_fail_msg("ApiCoverageTestCase::CallGetProgramiv", "Invalid enum : %s", ea_GetProgram[i].name);
3305 success = false;
3306 }
3307 }
3308 gl.useProgram(0);
3309 GLU_EXPECT_NO_ERROR(gl.getError(), "useProgram");
3310 gl.deleteProgram(program);
3311 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
3312
3313 return success;
3314 }
3315
TestCoverageGLCallGetProgramInfoLog(void)3316 bool ApiCoverageTestCase::TestCoverageGLCallGetProgramInfoLog(void)
3317 {
3318 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3319 bool success = true;
3320 GLchar infolog[1024];
3321 GLsizei length;
3322 GLuint program;
3323
3324 program = gl.createProgram();
3325 GLU_EXPECT_NO_ERROR(gl.getError(), "createProgram");
3326
3327 gl.getProgramInfoLog(program, 1024, &length, infolog);
3328 GLU_EXPECT_NO_ERROR(gl.getError(), "getProgramInfoLog");
3329 gl.useProgram(0);
3330 GLU_EXPECT_NO_ERROR(gl.getError(), "useProgram");
3331 gl.deleteProgram(program);
3332 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
3333
3334 return success;
3335 }
3336
TestCoverageGLCallGetString(void)3337 bool ApiCoverageTestCase::TestCoverageGLCallGetString(void)
3338 {
3339 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3340 bool success = true;
3341 GLint i;
3342
3343 for (i = 0; ea_GetString[i].value != -1; i++)
3344 {
3345 gl.getString(ea_GetString[i].value);
3346
3347 if (gl.getError() == GL_INVALID_ENUM)
3348 {
3349 tcu_fail_msg("ApiCoverageTestCase::CallGetString", "Invalid enum : %s", ea_GetString[i].name);
3350 success = false;
3351 }
3352 }
3353
3354 return success;
3355 }
3356
TestCoverageGLCallGetTexParameteriv(void)3357 bool ApiCoverageTestCase::TestCoverageGLCallGetTexParameteriv(void)
3358 {
3359 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3360 bool success = true;
3361 GLint i;
3362 GLint buf[10];
3363
3364 for (i = 0; ea_GetTexParameter[i].value != -1; i++)
3365 {
3366 gl.getTexParameteriv(GL_TEXTURE_2D, ea_GetTexParameter[i].value, buf);
3367
3368 if (gl.getError() == GL_INVALID_ENUM)
3369 {
3370 tcu_fail_msg("ApiCoverageTestCase::CallGetTexParameteriv", "Invalid enum : %s", ea_GetTexParameter[i].name);
3371 success = false;
3372 }
3373 }
3374
3375 return success;
3376 }
3377
TestCoverageGLCallGetTexParameterfv(void)3378 bool ApiCoverageTestCase::TestCoverageGLCallGetTexParameterfv(void)
3379 {
3380 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3381 bool success = true;
3382 GLint i;
3383 GLfloat buf[10];
3384
3385 for (i = 0; ea_GetTexParameter[i].value != -1; i++)
3386 {
3387 gl.getTexParameterfv(GL_TEXTURE_2D, ea_GetTexParameter[i].value, buf);
3388
3389 if (gl.getError() == GL_INVALID_ENUM)
3390 {
3391 tcu_fail_msg("ApiCoverageTestCase::CallGetTexParameterfv", "Invalid enum : %s", ea_GetTexParameter[i].name);
3392 success = false;
3393 }
3394 }
3395
3396 return success;
3397 }
3398
TestCoverageGLCallGetUniformfv(void)3399 bool ApiCoverageTestCase::TestCoverageGLCallGetUniformfv(void)
3400 {
3401 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3402 bool success = true;
3403 GLfloat buf[10];
3404 GLuint program;
3405
3406 program = gl.createProgram();
3407 GLU_EXPECT_NO_ERROR(gl.getError(), "createProgram");
3408
3409 gl.getUniformfv(program, 0, buf);
3410
3411 /* program is unlinked, so error should be INVALID_OPERATION */
3412 if (gl.getError() != GL_INVALID_OPERATION)
3413 {
3414 tcu_fail_msg("ApiCoverageTestCase::CallGetUniformfv", "GL_INVALID_OPERATION not returned.");
3415 success = false;
3416 }
3417
3418 gl.useProgram(0);
3419 GLU_EXPECT_NO_ERROR(gl.getError(), "useProgram");
3420 gl.deleteProgram(program);
3421 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
3422
3423 return success;
3424 }
3425
TestCoverageGLCallGetUniformiv(void)3426 bool ApiCoverageTestCase::TestCoverageGLCallGetUniformiv(void)
3427 {
3428 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3429 bool success = true;
3430 GLint buf[10];
3431 GLuint program;
3432
3433 program = gl.createProgram();
3434 GLU_EXPECT_NO_ERROR(gl.getError(), "createProgram");
3435
3436 gl.getUniformiv(program, 0, buf);
3437
3438 /* program is unlinked, so error should be INVALID_OPERATION */
3439 if (gl.getError() != GL_INVALID_OPERATION)
3440 {
3441 tcu_fail_msg("ApiCoverageTestCase::CallGetUniformiv", "GL_INVALID_OPERATION not returned.");
3442 success = false;
3443 }
3444
3445 gl.useProgram(0);
3446 GLU_EXPECT_NO_ERROR(gl.getError(), "useProgram");
3447 gl.deleteProgram(program);
3448 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
3449
3450 return success;
3451 }
3452
TestCoverageGLCallGetUniformLocation(void)3453 bool ApiCoverageTestCase::TestCoverageGLCallGetUniformLocation(void)
3454 {
3455 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3456 bool success = true;
3457 GLuint program;
3458
3459 program = gl.createProgram();
3460 GLU_EXPECT_NO_ERROR(gl.getError(), "createProgram");
3461
3462 gl.getUniformLocation(program, "uniform1");
3463
3464 /* program is unlinked, so error should be INVALID_OPERATION */
3465 if (gl.getError() != GL_INVALID_OPERATION)
3466 {
3467 tcu_fail_msg("ApiCoverageTestCase::CallGetUniformLocation", "GL_INVALID_OPERATION not returned.");
3468 success = false;
3469 }
3470
3471 gl.useProgram(0);
3472 GLU_EXPECT_NO_ERROR(gl.getError(), "useProgram");
3473 gl.deleteProgram(program);
3474 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
3475
3476 while (gl.getError() != GL_NO_ERROR)
3477 {
3478 }
3479
3480 return success;
3481 }
3482
TestCoverageGLCallGetVertexAttribfv(void)3483 bool ApiCoverageTestCase::TestCoverageGLCallGetVertexAttribfv(void)
3484 {
3485 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3486 bool success = true;
3487 GLfloat buf[10];
3488 GLuint index;
3489 GLint i;
3490
3491 index = 1;
3492
3493 for (i = 0; ea_GetVertexAttrib[i].value != -1; i++)
3494 {
3495 gl.getVertexAttribfv(index, ea_GetVertexAttrib[i].value, buf);
3496
3497 if (gl.getError() == GL_INVALID_ENUM)
3498 {
3499 tcu_fail_msg("ApiCoverageTestCase::CallGetVertexAttribfv", "Invalid enum : %s", ea_GetVertexAttrib[i].name);
3500 success = false;
3501 }
3502 }
3503
3504 return success;
3505 }
3506
TestCoverageGLCallGetVertexAttribiv(void)3507 bool ApiCoverageTestCase::TestCoverageGLCallGetVertexAttribiv(void)
3508 {
3509 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3510 bool success = true;
3511 GLint buf[10];
3512 GLuint index;
3513 GLint i;
3514
3515 index = 1;
3516
3517 for (i = 0; ea_GetVertexAttrib[i].value != -1; i++)
3518 {
3519 gl.getVertexAttribiv(index, ea_GetVertexAttrib[i].value, buf);
3520
3521 if (gl.getError() == GL_INVALID_ENUM)
3522 {
3523 tcu_fail_msg("ApiCoverageTestCase::CallGetVertexAttribiv", "Invalid enum : %s", ea_GetVertexAttrib[i].name);
3524 success = false;
3525 }
3526 }
3527
3528 return success;
3529 }
3530
TestCoverageGLCallGetVertexAttribPointerv(void)3531 bool ApiCoverageTestCase::TestCoverageGLCallGetVertexAttribPointerv(void)
3532 {
3533 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3534 bool success = true;
3535 void *buf;
3536 GLuint index;
3537 GLint i;
3538
3539 index = 1;
3540
3541 for (i = 0; ea_GetVertexAttribPointer[i].value != -1; i++)
3542 {
3543 gl.getVertexAttribPointerv(index, ea_GetVertexAttribPointer[i].value, &buf);
3544
3545 if (gl.getError() == GL_INVALID_ENUM)
3546 {
3547 tcu_fail_msg("ApiCoverageTestCase::CallGetVertexAttribPointerv", "Invalid enum : %s",
3548 ea_GetVertexAttribPointer[i].name);
3549 success = false;
3550 }
3551 }
3552
3553 return success;
3554 }
3555
TestCoverageGLCallHint(void)3556 bool ApiCoverageTestCase::TestCoverageGLCallHint(void)
3557 {
3558 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3559 bool success = true;
3560 GLint i, j;
3561
3562 for (i = 0; ea_HintTarget[i].value != -1; i++)
3563 {
3564 for (j = 0; ea_HintMode[j].value != -1; j++)
3565 {
3566 gl.hint(ea_HintTarget[i].value, ea_HintMode[j].value);
3567
3568 if (gl.getError() == GL_INVALID_ENUM)
3569 {
3570 tcu_fail_msg("ApiCoverageTestCase::CallHint", "Invalid enums : (%s, %s)", ea_HintTarget[i].name,
3571 ea_HintMode[j].name);
3572 success = false;
3573 }
3574 }
3575 }
3576
3577 if (m_context.getContextInfo().isExtensionSupported("GL_OES_standard_derivatives"))
3578 {
3579 for (i = 0; ea_HintTarget_OES_fragment_shader_derivative[i].value != -1; i++)
3580 {
3581 for (j = 0; ea_HintMode[j].value != -1; j++)
3582 {
3583 gl.hint(ea_HintTarget_OES_fragment_shader_derivative[i].value, ea_HintMode[j].value);
3584
3585 if (gl.getError() == GL_INVALID_ENUM)
3586 {
3587 tcu_fail_msg("ApiCoverageTestCase::CallHint", "Invalid enums : (%s, %s)",
3588 ea_HintTarget_OES_fragment_shader_derivative[i].name, ea_HintMode[j].name);
3589 success = false;
3590 }
3591 }
3592 }
3593 }
3594 return success;
3595 }
3596
TestCoverageGLCallIsBuffer(void)3597 bool ApiCoverageTestCase::TestCoverageGLCallIsBuffer(void)
3598 {
3599 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3600 bool success = true;
3601
3602 gl.isBuffer(0);
3603 GLU_EXPECT_NO_ERROR(gl.getError(), "isBuffer");
3604
3605 return success;
3606 }
3607
TestCoverageGLCallIsEnabled(void)3608 bool ApiCoverageTestCase::TestCoverageGLCallIsEnabled(void)
3609 {
3610 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3611 bool success = true;
3612 GLint i;
3613
3614 for (i = 0; ea_Enable[i].value != -1; i++)
3615 {
3616 gl.isEnabled(ea_Enable[i].value);
3617
3618 if (gl.getError() == GL_INVALID_ENUM)
3619 {
3620 tcu_fail_msg("ApiCoverageTestCase::CallIsEnabled", "Invalid enum : %s", ea_Enable[i].name);
3621 success = false;
3622 }
3623 }
3624
3625 return success;
3626 }
3627
TestCoverageGLCallIsProgram(void)3628 bool ApiCoverageTestCase::TestCoverageGLCallIsProgram(void)
3629 {
3630 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3631 bool success = true;
3632
3633 gl.isProgram(0);
3634 GLU_EXPECT_NO_ERROR(gl.getError(), "isProgram");
3635
3636 return success;
3637 }
3638
TestCoverageGLCallIsShader(void)3639 bool ApiCoverageTestCase::TestCoverageGLCallIsShader(void)
3640 {
3641 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3642 bool success = true;
3643
3644 gl.isShader(0);
3645 GLU_EXPECT_NO_ERROR(gl.getError(), "isShader");
3646
3647 return success;
3648 }
3649
TestCoverageGLCallIsTexture(void)3650 bool ApiCoverageTestCase::TestCoverageGLCallIsTexture(void)
3651 {
3652 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3653 bool success = true;
3654
3655 gl.isTexture(0);
3656 GLU_EXPECT_NO_ERROR(gl.getError(), "isTexture");
3657
3658 return success;
3659 }
3660
TestCoverageGLCallLineWidth(void)3661 bool ApiCoverageTestCase::TestCoverageGLCallLineWidth(void)
3662 {
3663 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3664 bool success = true;
3665
3666 gl.lineWidth(1.0f);
3667 GLU_EXPECT_NO_ERROR(gl.getError(), "lineWidth");
3668
3669 return success;
3670 }
3671
TestCoverageGLCallLinkProgram(void)3672 bool ApiCoverageTestCase::TestCoverageGLCallLinkProgram(void)
3673 {
3674 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3675 bool success = true;
3676 GLuint program;
3677
3678 program = gl.createProgram();
3679 GLU_EXPECT_NO_ERROR(gl.getError(), "createProgram");
3680
3681 gl.linkProgram(program);
3682 GLU_EXPECT_NO_ERROR(gl.getError(), "linkProgram");
3683
3684 gl.useProgram(0);
3685 GLU_EXPECT_NO_ERROR(gl.getError(), "useProgram");
3686 gl.deleteProgram(program);
3687 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
3688
3689 while (gl.getError() != GL_NO_ERROR)
3690 {
3691 }
3692
3693 return success;
3694 }
3695
TestCoverageGLCallPixelStorei(void)3696 bool ApiCoverageTestCase::TestCoverageGLCallPixelStorei(void)
3697 {
3698 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3699 bool success = true;
3700 GLint i;
3701
3702 for (i = 0; ea_PixelStore[i].value != -1; i++)
3703 {
3704 gl.pixelStorei(ea_PixelStore[i].value, 1);
3705 GLU_EXPECT_NO_ERROR(gl.getError(), "pixelStorei");
3706 gl.pixelStorei(ea_PixelStore[i].value, 2);
3707 GLU_EXPECT_NO_ERROR(gl.getError(), "pixelStorei");
3708 gl.pixelStorei(ea_PixelStore[i].value, 4);
3709 GLU_EXPECT_NO_ERROR(gl.getError(), "pixelStorei");
3710 gl.pixelStorei(ea_PixelStore[i].value, 8);
3711
3712 if (gl.getError() == GL_INVALID_ENUM)
3713 {
3714 tcu_fail_msg("ApiCoverageTestCase::CallPixelStorei", "Invalid enum : %s", ea_PixelStore[i].name);
3715 success = false;
3716 }
3717 }
3718
3719 return success;
3720 }
3721
TestCoverageGLCallPolygonOffset(void)3722 bool ApiCoverageTestCase::TestCoverageGLCallPolygonOffset(void)
3723 {
3724 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3725 bool success = true;
3726
3727 gl.polygonOffset(1.0f, 0.0f);
3728 GLU_EXPECT_NO_ERROR(gl.getError(), "polygonOffset");
3729
3730 return success;
3731 }
3732
TestCoverageGLCallReadPixels(void)3733 bool ApiCoverageTestCase::TestCoverageGLCallReadPixels(void)
3734 {
3735 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3736 bool success = true;
3737 GLubyte readBuf[64]; /* 4 pixels * 4 components * 4 bytes/component */
3738 GLint format, type;
3739
3740 gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, (void *)readBuf);
3741
3742 if (GL_NO_ERROR != gl.getError())
3743 {
3744 tcu_fail_msg("ApiCoverageTestCase::CallReadPixels", "Error occured during read pixel call");
3745 success = false;
3746 }
3747
3748 if (m_is_context_ES)
3749 {
3750 gl.getIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &format);
3751 GLU_EXPECT_NO_ERROR(gl.getError(), "getIntegerv");
3752 gl.getIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &type);
3753 GLU_EXPECT_NO_ERROR(gl.getError(), "getIntegerv");
3754
3755 gl.readPixels(0, 0, 1, 1, format, type, (void *)readBuf);
3756
3757 if (gl.getError() == GL_INVALID_ENUM)
3758 {
3759 tcu_fail_msg("ApiCoverageTestCase::CallReadPixels", "Invalid enum in read pixel call");
3760 success = false;
3761 }
3762 }
3763
3764 return success;
3765 }
3766
TestCoverageGLCallSampleCoverage(void)3767 bool ApiCoverageTestCase::TestCoverageGLCallSampleCoverage(void)
3768 {
3769 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3770 bool success = true;
3771
3772 gl.sampleCoverage(1.0f, GL_FALSE);
3773 GLU_EXPECT_NO_ERROR(gl.getError(), "sampleCoverage");
3774
3775 return success;
3776 }
3777
TestCoverageGLCallScissor(void)3778 bool ApiCoverageTestCase::TestCoverageGLCallScissor(void)
3779 {
3780 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3781 bool success = true;
3782
3783 gl.scissor(0, 0, 1, 1);
3784 GLU_EXPECT_NO_ERROR(gl.getError(), "scissor");
3785
3786 return success;
3787 }
3788
TestCoverageGLCallStencilFunc(void)3789 bool ApiCoverageTestCase::TestCoverageGLCallStencilFunc(void)
3790 {
3791 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3792 bool success = true;
3793 GLint i;
3794
3795 for (i = 0; ea_StencilFunction[i].value != -1; i++)
3796 {
3797 gl.stencilFunc(ea_StencilFunction[i].value, 0, 0);
3798
3799 if (gl.getError() == GL_INVALID_ENUM)
3800 {
3801 tcu_fail_msg("ApiCoverageTestCase::CallStencilFunc", "Invalid enums : %s", ea_StencilFunction[i].name);
3802 success = false;
3803 }
3804 }
3805
3806 return success;
3807 }
3808
TestCoverageGLCallStencilFuncSeparate(void)3809 bool ApiCoverageTestCase::TestCoverageGLCallStencilFuncSeparate(void)
3810 {
3811 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3812 bool success = true;
3813 GLint i, j;
3814
3815 for (j = 0; ea_Face[j].value != -1; j++)
3816 {
3817 for (i = 0; ea_StencilFunction[i].value != -1; i++)
3818 {
3819 gl.stencilFuncSeparate(ea_Face[j].value, ea_StencilFunction[i].value, 0, 0);
3820
3821 if (gl.getError() == GL_INVALID_ENUM)
3822 {
3823 tcu_fail_msg("ApiCoverageTestCase::CallStencilFunc", "Invalid enums : (%s, %s)", ea_Face[j].name,
3824 ea_StencilFunction[i].name);
3825 success = false;
3826 }
3827 }
3828 }
3829
3830 return success;
3831 }
3832
TestCoverageGLCallStencilMask(void)3833 bool ApiCoverageTestCase::TestCoverageGLCallStencilMask(void)
3834 {
3835 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3836 bool success = true;
3837
3838 gl.stencilMask(0);
3839 GLU_EXPECT_NO_ERROR(gl.getError(), "stencilMask");
3840
3841 return success;
3842 }
3843
TestCoverageGLCallStencilMaskSeparate(void)3844 bool ApiCoverageTestCase::TestCoverageGLCallStencilMaskSeparate(void)
3845 {
3846 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3847 bool success = true;
3848 GLint i;
3849
3850 for (i = 0; ea_Face[i].value != -1; i++)
3851 {
3852 gl.stencilMaskSeparate(ea_Face[i].value, 0);
3853
3854 if (gl.getError() == GL_INVALID_ENUM)
3855 {
3856 tcu_fail_msg("ApiCoverageTestCase::CallStencilFunc", "Invalid enums : %s", ea_Face[i].name);
3857 success = false;
3858 }
3859 }
3860
3861 return success;
3862 }
3863
TestCoverageGLCallStencilOp(void)3864 bool ApiCoverageTestCase::TestCoverageGLCallStencilOp(void)
3865 {
3866 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3867 bool success = true;
3868 GLint i, j, k;
3869
3870 for (i = 0; ea_StencilOp[i].value != -1; i++)
3871 {
3872 for (j = 0; ea_StencilOp[j].value != -1; j++)
3873 {
3874 for (k = 0; ea_StencilOp[k].value != -1; k++)
3875 {
3876 gl.stencilOp(ea_StencilOp[i].value, ea_StencilOp[j].value, ea_StencilOp[k].value);
3877
3878 if (gl.getError() == GL_INVALID_ENUM)
3879 {
3880 tcu_fail_msg("ApiCoverageTestCase::CallStencilFunc", "Invalid enums : (%s, %s, %s)",
3881 ea_StencilOp[i].name, ea_StencilOp[j].name, ea_StencilOp[k].name);
3882 success = false;
3883 }
3884 }
3885 }
3886 }
3887
3888 return success;
3889 }
3890
TestCoverageGLCallStencilOpSeparate(void)3891 bool ApiCoverageTestCase::TestCoverageGLCallStencilOpSeparate(void)
3892 {
3893 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3894 bool success = true;
3895 GLint i, j, k, l;
3896
3897 for (l = 0; ea_Face[l].value != -1; l++)
3898 {
3899 for (i = 0; ea_StencilOp[i].value != -1; i++)
3900 {
3901 for (j = 0; ea_StencilOp[j].value != -1; j++)
3902 {
3903 for (k = 0; ea_StencilOp[k].value != -1; k++)
3904 {
3905 gl.stencilOpSeparate(ea_Face[l].value, ea_StencilOp[i].value, ea_StencilOp[j].value,
3906 ea_StencilOp[k].value);
3907
3908 if (gl.getError() == GL_INVALID_ENUM)
3909 {
3910 tcu_fail_msg("ApiCoverageTestCase::CallStencilFunc", "Invalid enums : (%s, %s, %s, %s)",
3911 ea_Face[l].name, ea_StencilOp[i].name, ea_StencilOp[j].name, ea_StencilOp[k].name);
3912 success = false;
3913 }
3914 }
3915 }
3916 }
3917 }
3918
3919 return success;
3920 }
3921
TestCoverageGLCallTexImage2D(void)3922 bool ApiCoverageTestCase::TestCoverageGLCallTexImage2D(void)
3923 {
3924 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3925 bool success = true;
3926 GLubyte buf[1000];
3927 GLint i, j;
3928
3929 for (i = 0; ea_TextureTarget[i].value != -1; i++)
3930 {
3931 for (j = 0; ea_TextureFormat[j].value != -1; j++)
3932 {
3933 memset(buf, 0, 1000 * sizeof(GLubyte));
3934 gl.texImage2D(ea_TextureTarget[i].value, 0, ea_TextureFormat[j].value, 1, 1, 0, ea_TextureFormat[j].value,
3935 ea_TextureType[j].value, buf);
3936
3937 if (gl.getError() == GL_INVALID_ENUM)
3938 {
3939 tcu_fail_msg("ApiCoverageTestCase::CallTexImage2D", "Invalid enums : (%s, %s, %s)",
3940 ea_TextureTarget[i].name, ea_TextureFormat[j].name, ea_TextureType[j].name);
3941 success = false;
3942 }
3943
3944 gl.texImage2D(ea_TextureTarget[i].value, 0, ea_TextureFormat[j].value, 1, 1, 0, ea_TextureFormat[j].value,
3945 ea_TextureType[j].value, (const void *)NULL);
3946
3947 if (gl.getError() == GL_INVALID_ENUM)
3948 {
3949 tcu_fail_msg("ApiCoverageTestCase::CallTexImage2D", "Invalid enums : (%s, %s, %s)",
3950 ea_TextureTarget[i].name, ea_TextureFormat[j].name, ea_TextureType[j].name);
3951 success = false;
3952 }
3953 }
3954 }
3955
3956 return success;
3957 }
3958
TestCoverageGLCallTexParameteri(void)3959 bool ApiCoverageTestCase::TestCoverageGLCallTexParameteri(void)
3960 {
3961 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
3962 bool success = true;
3963 GLint i, j, k;
3964
3965 for (i = 0; ea_TextureTarget[i].value != -1; i++)
3966 {
3967 for (j = 0; ea_GetTexParameter[j].value != -1; j++)
3968 {
3969 switch (ea_GetTexParameter[j].value)
3970 {
3971 case GL_TEXTURE_WRAP_S:
3972 case GL_TEXTURE_WRAP_T:
3973 for (k = 0; ea_TextureWrapMode[k].value != -1; k++)
3974 {
3975 gl.texParameteri(ea_TextureTarget[i].value, ea_GetTexParameter[j].value,
3976 ea_TextureWrapMode[k].value);
3977
3978 if (gl.getError() == GL_INVALID_ENUM)
3979 {
3980 tcu_fail_msg("ApiCoverageTestCase::CallTexParameteri", "Invalid enums : (%s, %s, %s)",
3981 ea_TextureTarget[i].name, ea_GetTexParameter[j].name, ea_TextureWrapMode[k].name);
3982 success = false;
3983 }
3984 }
3985 break;
3986 case GL_TEXTURE_MIN_FILTER:
3987 for (k = 0; ea_TextureMinFilter[k].value != -1; k++)
3988 {
3989 gl.texParameteri(ea_TextureTarget[i].value, ea_GetTexParameter[j].value,
3990 ea_TextureMinFilter[k].value);
3991
3992 if (gl.getError() == GL_INVALID_ENUM)
3993 {
3994 tcu_fail_msg("ApiCoverageTestCase::CallTexParameteri", "Invalid enums : (%s, %s, %s)",
3995 ea_TextureTarget[i].name, ea_GetTexParameter[j].name, ea_TextureMinFilter[k].name);
3996 success = false;
3997 }
3998 }
3999 break;
4000 case GL_TEXTURE_MAG_FILTER:
4001 for (k = 0; ea_TextureMagFilter[k].value != -1; k++)
4002 {
4003 gl.texParameteri(ea_TextureTarget[i].value, ea_GetTexParameter[j].value,
4004 ea_TextureMagFilter[k].value);
4005
4006 if (gl.getError() == GL_INVALID_ENUM)
4007 {
4008 tcu_fail_msg("ApiCoverageTestCase::CallTexParameteri", "Invalid enums : (%s, %s, %s)",
4009 ea_TextureTarget[i].name, ea_GetTexParameter[j].name, ea_TextureMagFilter[k].name);
4010 success = false;
4011 }
4012 }
4013 break;
4014 }
4015 }
4016 }
4017
4018 return success;
4019 }
4020
TestCoverageGLCallTexParameterf(void)4021 bool ApiCoverageTestCase::TestCoverageGLCallTexParameterf(void)
4022 {
4023 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4024 bool success = true;
4025 GLint i, j, k;
4026
4027 for (i = 0; ea_TextureTarget[i].value != -1; i++)
4028 {
4029 for (j = 0; ea_GetTexParameter[j].value != -1; j++)
4030 {
4031 switch (ea_GetTexParameter[j].value)
4032 {
4033 case GL_TEXTURE_WRAP_S:
4034 case GL_TEXTURE_WRAP_T:
4035 for (k = 0; ea_TextureWrapMode[k].value != -1; k++)
4036 {
4037 gl.texParameterf(ea_TextureTarget[i].value, ea_GetTexParameter[j].value,
4038 (GLfloat)ea_TextureWrapMode[k].value);
4039
4040 if (gl.getError() == GL_INVALID_ENUM)
4041 {
4042 tcu_fail_msg("ApiCoverageTestCase::CallTexParameterf", "Invalid enums : (%s, %s, %s)",
4043 ea_TextureTarget[i].name, ea_GetTexParameter[j].name, ea_TextureWrapMode[k].name);
4044 success = false;
4045 }
4046 }
4047 break;
4048 case GL_TEXTURE_MIN_FILTER:
4049 for (k = 0; ea_TextureMinFilter[k].value != -1; k++)
4050 {
4051 gl.texParameterf(ea_TextureTarget[i].value, ea_GetTexParameter[j].value,
4052 (GLfloat)ea_TextureMinFilter[k].value);
4053
4054 if (gl.getError() == GL_INVALID_ENUM)
4055 {
4056 tcu_fail_msg("ApiCoverageTestCase::CallTexParameterf", "Invalid enums : (%s, %s, %s)",
4057 ea_TextureTarget[i].name, ea_GetTexParameter[j].name, ea_TextureMinFilter[k].name);
4058 success = false;
4059 }
4060 }
4061 break;
4062 case GL_TEXTURE_MAG_FILTER:
4063 for (k = 0; ea_TextureMagFilter[k].value != -1; k++)
4064 {
4065 gl.texParameterf(ea_TextureTarget[i].value, ea_GetTexParameter[j].value,
4066 (GLfloat)ea_TextureMagFilter[k].value);
4067
4068 if (gl.getError() == GL_INVALID_ENUM)
4069 {
4070 tcu_fail_msg("ApiCoverageTestCase::CallTexParameterf", "Invalid enums : (%s, %s, %s)",
4071 ea_TextureTarget[i].name, ea_GetTexParameter[j].name, ea_TextureMagFilter[k].name);
4072 success = false;
4073 }
4074 }
4075 break;
4076 }
4077 }
4078 }
4079
4080 return success;
4081 }
4082
TestCoverageGLCallTexParameteriv(void)4083 bool ApiCoverageTestCase::TestCoverageGLCallTexParameteriv(void)
4084 {
4085 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4086 bool success = true;
4087 GLint i, j, k;
4088
4089 for (i = 0; ea_TextureTarget[i].value != -1; i++)
4090 {
4091 for (j = 0; ea_GetTexParameter[j].value != -1; j++)
4092 {
4093 switch (ea_GetTexParameter[j].value)
4094 {
4095 case GL_TEXTURE_WRAP_S:
4096 case GL_TEXTURE_WRAP_T:
4097 for (k = 0; ea_TextureWrapMode[k].value != -1; k++)
4098 {
4099 gl.texParameteriv(ea_TextureTarget[i].value, ea_GetTexParameter[j].value,
4100 &ea_TextureWrapMode[k].value);
4101
4102 if (gl.getError() == GL_INVALID_ENUM)
4103 {
4104 tcu_fail_msg("ApiCoverageTestCase::CallTexParameteriv", "Invalid enums : (%s, %s, %s)",
4105 ea_TextureTarget[i].name, ea_GetTexParameter[j].name, ea_TextureWrapMode[k].name);
4106 success = false;
4107 }
4108 }
4109 break;
4110 case GL_TEXTURE_MIN_FILTER:
4111 for (k = 0; ea_TextureMinFilter[k].value != -1; k++)
4112 {
4113 gl.texParameteriv(ea_TextureTarget[i].value, ea_GetTexParameter[j].value,
4114 &ea_TextureMinFilter[k].value);
4115
4116 if (gl.getError() == GL_INVALID_ENUM)
4117 {
4118 tcu_fail_msg("ApiCoverageTestCase::CallTexParameteriv", "Invalid enums : (%s, %s, %s)",
4119 ea_TextureTarget[i].name, ea_GetTexParameter[j].name, ea_TextureMinFilter[k].name);
4120 success = false;
4121 }
4122 }
4123 break;
4124 case GL_TEXTURE_MAG_FILTER:
4125 for (k = 0; ea_TextureMagFilter[k].value != -1; k++)
4126 {
4127 gl.texParameteriv(ea_TextureTarget[i].value, ea_GetTexParameter[j].value,
4128 &ea_TextureMagFilter[k].value);
4129
4130 if (gl.getError() == GL_INVALID_ENUM)
4131 {
4132 tcu_fail_msg("ApiCoverageTestCase::CallTexParameteriv", "Invalid enums : (%s, %s, %s)",
4133 ea_TextureTarget[i].name, ea_GetTexParameter[j].name, ea_TextureMagFilter[k].name);
4134 success = false;
4135 }
4136 }
4137 break;
4138 }
4139 }
4140 }
4141
4142 return success;
4143 }
4144
TestCoverageGLCallTexParameterfv(void)4145 bool ApiCoverageTestCase::TestCoverageGLCallTexParameterfv(void)
4146 {
4147 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4148 bool success = true;
4149 GLfloat value;
4150 GLint i, j, k;
4151
4152 for (i = 0; ea_TextureTarget[i].value != -1; i++)
4153 {
4154 for (j = 0; ea_GetTexParameter[j].value != -1; j++)
4155 {
4156 switch (ea_GetTexParameter[j].value)
4157 {
4158 case GL_TEXTURE_WRAP_S:
4159 case GL_TEXTURE_WRAP_T:
4160 for (k = 0; ea_TextureWrapMode[k].value != -1; k++)
4161 {
4162 value = (GLfloat)ea_TextureWrapMode[k].value;
4163 gl.texParameterfv(ea_TextureTarget[i].value, ea_GetTexParameter[j].value, &value);
4164
4165 if (gl.getError() == GL_INVALID_ENUM)
4166 {
4167 tcu_fail_msg("ApiCoverageTestCase::CallTexParameterfv", "Invalid enums : (%s, %s, %s)",
4168 ea_TextureTarget[i].name, ea_GetTexParameter[j].name, ea_TextureWrapMode[k].name);
4169 success = false;
4170 }
4171 }
4172 break;
4173 case GL_TEXTURE_MIN_FILTER:
4174 for (k = 0; ea_TextureMinFilter[k].value != -1; k++)
4175 {
4176 value = (GLfloat)ea_TextureMinFilter[k].value;
4177 gl.texParameterfv(ea_TextureTarget[i].value, ea_GetTexParameter[j].value, &value);
4178
4179 if (gl.getError() == GL_INVALID_ENUM)
4180 {
4181 tcu_fail_msg("ApiCoverageTestCase::CallTexParameterfv", "Invalid enums : (%s, %s, %s)",
4182 ea_TextureTarget[i].name, ea_GetTexParameter[j].name, ea_TextureMinFilter[k].name);
4183 success = false;
4184 }
4185 }
4186 break;
4187 case GL_TEXTURE_MAG_FILTER:
4188 for (k = 0; ea_TextureMagFilter[k].value != -1; k++)
4189 {
4190 value = (GLfloat)ea_TextureMagFilter[k].value;
4191 gl.texParameterfv(ea_TextureTarget[i].value, ea_GetTexParameter[j].value, &value);
4192
4193 if (gl.getError() == GL_INVALID_ENUM)
4194 {
4195 tcu_fail_msg("ApiCoverageTestCase::CallTexParameterfv", "Invalid enums : (%s, %s, %s)",
4196 ea_TextureTarget[i].name, ea_GetTexParameter[j].name, ea_TextureMagFilter[k].name);
4197 success = false;
4198 }
4199 }
4200 break;
4201 }
4202 }
4203 }
4204
4205 return success;
4206 }
4207
TestCoverageGLCallTexSubImage2D(void)4208 bool ApiCoverageTestCase::TestCoverageGLCallTexSubImage2D(void)
4209 {
4210 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4211 bool success = true;
4212 GLubyte buf[1000];
4213 int i;
4214
4215 for (i = 0; ea_TextureFormat[i].value != -1; i++)
4216 {
4217 memset(buf, 0, 1000 * sizeof(GLubyte));
4218 gl.texImage2D(GL_TEXTURE_2D, 0, ea_TextureFormat[i].value, 1, 1, 0, ea_TextureFormat[i].value,
4219 ea_TextureType[i].value, buf);
4220 GLU_EXPECT_NO_ERROR(gl.getError(), "texImage2D");
4221 gl.texSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1, 1, ea_TextureFormat[i].value, ea_TextureType[i].value, buf);
4222
4223 if (gl.getError() == GL_INVALID_ENUM)
4224 {
4225 tcu_fail_msg("ApiCoverageTestCase::CallTexSubImage2D", "Invalid enums : (%s, %s)", ea_TextureFormat[i].name,
4226 ea_TextureType[i].name);
4227 success = false;
4228 }
4229
4230 gl.texImage2D(GL_TEXTURE_2D, 0, ea_TextureFormat[i].value, 1, 1, 0, ea_TextureFormat[i].value,
4231 ea_TextureType[i].value, (const void *)NULL);
4232 GLU_EXPECT_NO_ERROR(gl.getError(), "texImage2D");
4233 gl.texSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1, 1, ea_TextureFormat[i].value, ea_TextureType[i].value, buf);
4234
4235 if (gl.getError() == GL_INVALID_ENUM)
4236 {
4237 tcu_fail_msg("ApiCoverageTestCase::CallTexSubImage2D", "Invalid enums : (%s, %s)", ea_TextureFormat[i].name,
4238 ea_TextureType[i].name);
4239 success = false;
4240 }
4241 }
4242
4243 return success;
4244 }
4245
TestCoverageGLCallUniform1i(void)4246 bool ApiCoverageTestCase::TestCoverageGLCallUniform1i(void)
4247 {
4248 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4249 bool success = true;
4250
4251 gl.uniform1i(0, 1);
4252
4253 if (gl.getError() != GL_INVALID_OPERATION)
4254 {
4255 tcu_fail_msg("ApiCoverageTestCase::CallUniform1i", "GL_INVALID_OPERATION not returned");
4256 success = false;
4257 }
4258
4259 return success;
4260 }
4261
TestCoverageGLCallUniform2i(void)4262 bool ApiCoverageTestCase::TestCoverageGLCallUniform2i(void)
4263 {
4264 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4265 bool success = true;
4266
4267 gl.uniform2i(0, 1, 2);
4268
4269 if (gl.getError() != GL_INVALID_OPERATION)
4270 {
4271 tcu_fail_msg("ApiCoverageTestCase::CallUniform2i", "GL_INVALID_OPERATION not returned");
4272 success = false;
4273 }
4274
4275 return success;
4276 }
4277
TestCoverageGLCallUniform3i(void)4278 bool ApiCoverageTestCase::TestCoverageGLCallUniform3i(void)
4279 {
4280 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4281 bool success = true;
4282
4283 gl.uniform3i(0, 1, 2, 3);
4284
4285 if (gl.getError() != GL_INVALID_OPERATION)
4286 {
4287 tcu_fail_msg("ApiCoverageTestCase::CallUniform3i", "GL_INVALID_OPERATION not returned");
4288 success = false;
4289 }
4290
4291 return success;
4292 }
4293
TestCoverageGLCallUniform4i(void)4294 bool ApiCoverageTestCase::TestCoverageGLCallUniform4i(void)
4295 {
4296 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4297 bool success = true;
4298
4299 gl.uniform4i(0, 1, 2, 3, 4);
4300
4301 if (gl.getError() != GL_INVALID_OPERATION)
4302 {
4303 tcu_fail_msg("ApiCoverageTestCase::CallUniform4i", "GL_INVALID_OPERATION not returned");
4304 success = false;
4305 }
4306
4307 return success;
4308 }
4309
TestCoverageGLCallUniform1f(void)4310 bool ApiCoverageTestCase::TestCoverageGLCallUniform1f(void)
4311 {
4312 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4313 bool success = true;
4314
4315 gl.uniform1f(0, 1.0f);
4316
4317 if (gl.getError() != GL_INVALID_OPERATION)
4318 {
4319 tcu_fail_msg("ApiCoverageTestCase::CallUniform1f", "GL_INVALID_OPERATION not returned");
4320 success = false;
4321 }
4322
4323 return success;
4324 }
4325
TestCoverageGLCallUniform2f(void)4326 bool ApiCoverageTestCase::TestCoverageGLCallUniform2f(void)
4327 {
4328 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4329 bool success = true;
4330
4331 gl.uniform2f(0, 1.0f, 2.0f);
4332
4333 if (gl.getError() != GL_INVALID_OPERATION)
4334 {
4335 tcu_fail_msg("ApiCoverageTestCase::CallUniform2f", "GL_INVALID_OPERATION not returned");
4336 success = false;
4337 }
4338
4339 return success;
4340 }
4341
TestCoverageGLCallUniform3f(void)4342 bool ApiCoverageTestCase::TestCoverageGLCallUniform3f(void)
4343 {
4344 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4345 bool success = true;
4346
4347 gl.uniform3f(0, 1.0f, 2.0f, 3.0f);
4348
4349 if (gl.getError() != GL_INVALID_OPERATION)
4350 {
4351 tcu_fail_msg("ApiCoverageTestCase::CallUniform3f", "GL_INVALID_OPERATION not returned");
4352 success = false;
4353 }
4354
4355 return success;
4356 }
4357
TestCoverageGLCallUniform4f(void)4358 bool ApiCoverageTestCase::TestCoverageGLCallUniform4f(void)
4359 {
4360 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4361 bool success = true;
4362
4363 gl.uniform4f(0, 1.0f, 2.0f, 3.0f, 4.0f);
4364
4365 if (gl.getError() != GL_INVALID_OPERATION)
4366 {
4367 tcu_fail_msg("ApiCoverageTestCase::CallUniform4f", "GL_INVALID_OPERATION not returned");
4368 success = false;
4369 }
4370
4371 return success;
4372 }
4373
TestCoverageGLCallUniform1iv(void)4374 bool ApiCoverageTestCase::TestCoverageGLCallUniform1iv(void)
4375 {
4376 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4377 bool success = true;
4378 GLint buf[] = {1, 2};
4379
4380 gl.uniform1iv(0, 2, buf);
4381
4382 if (gl.getError() != GL_INVALID_OPERATION)
4383 {
4384 tcu_fail_msg("ApiCoverageTestCase::CallUniform1iv", "GL_INVALID_OPERATION not returned");
4385 success = false;
4386 }
4387
4388 return success;
4389 }
4390
TestCoverageGLCallUniform2iv(void)4391 bool ApiCoverageTestCase::TestCoverageGLCallUniform2iv(void)
4392 {
4393 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4394 bool success = true;
4395 GLint buf[] = {1, 2, 3, 4};
4396
4397 gl.uniform2iv(0, 2, buf);
4398
4399 if (gl.getError() != GL_INVALID_OPERATION)
4400 {
4401 tcu_fail_msg("ApiCoverageTestCase::CallUniform2iv", "GL_INVALID_OPERATION not returned");
4402 success = false;
4403 }
4404
4405 return success;
4406 }
4407
TestCoverageGLCallUniform3iv(void)4408 bool ApiCoverageTestCase::TestCoverageGLCallUniform3iv(void)
4409 {
4410 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4411 bool success = true;
4412 GLint buf[] = {1, 2, 3, 4, 5, 6};
4413
4414 gl.uniform3iv(0, 2, buf);
4415
4416 if (gl.getError() != GL_INVALID_OPERATION)
4417 {
4418 tcu_fail_msg("ApiCoverageTestCase::CallUniform3iv", "GL_INVALID_OPERATION not returned");
4419 success = false;
4420 }
4421
4422 return success;
4423 }
4424
TestCoverageGLCallUniform4iv(void)4425 bool ApiCoverageTestCase::TestCoverageGLCallUniform4iv(void)
4426 {
4427 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4428 bool success = true;
4429 GLint buf[] = {1, 2, 3, 4, 5, 6, 7, 8};
4430
4431 gl.uniform4iv(0, 2, buf);
4432
4433 if (gl.getError() != GL_INVALID_OPERATION)
4434 {
4435 tcu_fail_msg("ApiCoverageTestCase::CallUniform4iv", "GL_INVALID_OPERATION not returned");
4436 success = false;
4437 }
4438
4439 return success;
4440 }
4441
TestCoverageGLCallUniform1fv(void)4442 bool ApiCoverageTestCase::TestCoverageGLCallUniform1fv(void)
4443 {
4444 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4445 bool success = true;
4446 GLfloat buf[] = {1.0f, 2.0f};
4447
4448 gl.uniform1fv(0, 2, buf);
4449
4450 if (gl.getError() != GL_INVALID_OPERATION)
4451 {
4452 tcu_fail_msg("ApiCoverageTestCase::CallUniform1fv", "GL_INVALID_OPERATION not returned");
4453 success = false;
4454 }
4455
4456 return success;
4457 }
4458
TestCoverageGLCallUniform2fv(void)4459 bool ApiCoverageTestCase::TestCoverageGLCallUniform2fv(void)
4460 {
4461 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4462 bool success = true;
4463 GLfloat buf[] = {1.0f, 2.0f, 3.0f, 4.0f};
4464
4465 gl.uniform2fv(0, 2, buf);
4466
4467 if (gl.getError() != GL_INVALID_OPERATION)
4468 {
4469 tcu_fail_msg("ApiCoverageTestCase::CallUniform2fv", "GL_INVALID_OPERATION not returned");
4470 success = false;
4471 }
4472
4473 return success;
4474 }
4475
TestCoverageGLCallUniform3fv(void)4476 bool ApiCoverageTestCase::TestCoverageGLCallUniform3fv(void)
4477 {
4478 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4479 bool success = true;
4480 GLfloat buf[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f};
4481
4482 gl.uniform3fv(0, 2, buf);
4483
4484 if (gl.getError() != GL_INVALID_OPERATION)
4485 {
4486 tcu_fail_msg("ApiCoverageTestCase::CallUniform3fv", "GL_INVALID_OPERATION not returned");
4487 success = false;
4488 }
4489
4490 return success;
4491 }
4492
TestCoverageGLCallUniform4fv(void)4493 bool ApiCoverageTestCase::TestCoverageGLCallUniform4fv(void)
4494 {
4495 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4496 bool success = true;
4497 GLfloat buf[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f};
4498
4499 gl.uniform4fv(0, 2, buf);
4500
4501 if (gl.getError() != GL_INVALID_OPERATION)
4502 {
4503 tcu_fail_msg("ApiCoverageTestCase::CallUniform4fv", "GL_INVALID_OPERATION not returned");
4504 success = false;
4505 }
4506
4507 return success;
4508 }
4509
TestCoverageGLCallUniformMatrix2fv(void)4510 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix2fv(void)
4511 {
4512 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4513 bool success = true;
4514 GLfloat buf[] = {1, 1, 2, 2};
4515
4516 gl.uniformMatrix2fv(0, 1, GL_FALSE, buf);
4517
4518 if (gl.getError() != GL_INVALID_OPERATION)
4519 {
4520 tcu_fail_msg("ApiCoverageTestCase::CallUniformMatrix2fv", "GL_INVALID_OPERATION not returned");
4521 success = false;
4522 }
4523
4524 return success;
4525 }
4526
TestCoverageGLCallUniformMatrix3fv(void)4527 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix3fv(void)
4528 {
4529 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4530 bool success = true;
4531 GLfloat buf[] = {1, 1, 1, 2, 2, 2, 3, 3, 3};
4532
4533 gl.uniformMatrix3fv(0, 1, GL_FALSE, buf);
4534
4535 if (gl.getError() != GL_INVALID_OPERATION)
4536 {
4537 tcu_fail_msg("ApiCoverageTestCase::CallUniformMatrix3fv", "GL_INVALID_OPERATION not returned");
4538 success = false;
4539 }
4540
4541 return success;
4542 }
4543
TestCoverageGLCallUniformMatrix4fv(void)4544 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix4fv(void)
4545 {
4546 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4547 bool success = true;
4548 GLfloat buf[] = {1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4};
4549
4550 gl.uniformMatrix4fv(0, 1, GL_FALSE, buf);
4551
4552 if (gl.getError() != GL_INVALID_OPERATION)
4553 {
4554 tcu_fail_msg("ApiCoverageTestCase::CallUniformMatrix4fv", "GL_INVALID_OPERATION not returned");
4555 success = false;
4556 }
4557
4558 return success;
4559 }
4560
TestCoverageGLCallUseProgram(void)4561 bool ApiCoverageTestCase::TestCoverageGLCallUseProgram(void)
4562 {
4563 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4564 bool success = true;
4565 GLuint program;
4566
4567 program = gl.createProgram();
4568 GLU_EXPECT_NO_ERROR(gl.getError(), "createProgram");
4569
4570 gl.useProgram(program);
4571
4572 if (gl.getError() != GL_INVALID_OPERATION)
4573 {
4574 tcu_fail_msg("ApiCoverageTestCase::CallUseProgram", "GL_INVALID_OPERATION not returned");
4575 success = false;
4576 }
4577
4578 gl.useProgram(0);
4579 GLU_EXPECT_NO_ERROR(gl.getError(), "useProgram");
4580 gl.deleteProgram(program);
4581 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
4582
4583 return success;
4584 }
4585
TestCoverageGLCallValidateProgram(void)4586 bool ApiCoverageTestCase::TestCoverageGLCallValidateProgram(void)
4587 {
4588 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4589 bool success = true;
4590 GLuint program;
4591
4592 program = gl.createProgram();
4593 GLU_EXPECT_NO_ERROR(gl.getError(), "createProgram");
4594
4595 gl.validateProgram(program);
4596 GLU_EXPECT_NO_ERROR(gl.getError(), "validateProgram");
4597
4598 gl.useProgram(0);
4599 GLU_EXPECT_NO_ERROR(gl.getError(), "useProgram");
4600 gl.deleteProgram(program);
4601 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
4602
4603 return success;
4604 }
4605
TestCoverageGLCallVertexAttrib1f(void)4606 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib1f(void)
4607 {
4608 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4609 bool success = true;
4610
4611 gl.vertexAttrib1f(0, 1.0f);
4612 GLU_EXPECT_NO_ERROR(gl.getError(), "vertexAttrib1f");
4613
4614 return success;
4615 }
4616
TestCoverageGLCallVertexAttrib2f(void)4617 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib2f(void)
4618 {
4619 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4620 bool success = true;
4621
4622 gl.vertexAttrib2f(0, 1.0f, 2.0f);
4623 GLU_EXPECT_NO_ERROR(gl.getError(), "vertexAttrib2f");
4624
4625 return success;
4626 }
4627
TestCoverageGLCallVertexAttrib3f(void)4628 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib3f(void)
4629 {
4630 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4631 bool success = true;
4632
4633 gl.vertexAttrib3f(0, 1.0f, 2.0f, 3.0f);
4634 GLU_EXPECT_NO_ERROR(gl.getError(), "vertexAttrib3f");
4635
4636 return success;
4637 }
4638
TestCoverageGLCallVertexAttrib4f(void)4639 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4f(void)
4640 {
4641 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4642 bool success = true;
4643
4644 gl.vertexAttrib4f(0, 1.0f, 2.0f, 3.0f, 4.0f);
4645 GLU_EXPECT_NO_ERROR(gl.getError(), "vertexAttrib4f");
4646
4647 return success;
4648 }
4649
TestCoverageGLCallVertexAttrib1fv(void)4650 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib1fv(void)
4651 {
4652 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4653 bool success = true;
4654 GLfloat buf[] = {1.0f, 2.0f};
4655
4656 gl.vertexAttrib1fv(0, buf);
4657 GLU_EXPECT_NO_ERROR(gl.getError(), "vertexAttrib1fv");
4658
4659 return success;
4660 }
4661
TestCoverageGLCallVertexAttrib2fv(void)4662 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib2fv(void)
4663 {
4664 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4665 bool success = true;
4666 GLfloat buf[] = {1.0f, 2.0f, 3.0f, 4.0f};
4667
4668 gl.vertexAttrib2fv(0, buf);
4669 GLU_EXPECT_NO_ERROR(gl.getError(), "vertexAttrib2fv");
4670
4671 return success;
4672 }
4673
TestCoverageGLCallVertexAttrib3fv(void)4674 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib3fv(void)
4675 {
4676 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4677 bool success = true;
4678 GLfloat buf[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f};
4679
4680 gl.vertexAttrib3fv(0, buf);
4681 GLU_EXPECT_NO_ERROR(gl.getError(), "vertexAttrib3fv");
4682
4683 return success;
4684 }
4685
TestCoverageGLCallVertexAttrib4fv(void)4686 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4fv(void)
4687 {
4688 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4689 bool success = true;
4690 GLfloat buf[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f};
4691
4692 gl.vertexAttrib4fv(0, buf);
4693 GLU_EXPECT_NO_ERROR(gl.getError(), "vertexAttrib4fv");
4694
4695 return success;
4696 }
4697
TestCoverageGLCallVertexAttribPointer(void)4698 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribPointer(void)
4699 {
4700 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4701 bool success = true;
4702 GLfloat buf[] = {1.0f};
4703
4704 GLuint vbo = 0;
4705 gl.genBuffers(1, &vbo);
4706 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
4707 gl.bindBuffer(GL_ARRAY_BUFFER, vbo);
4708 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");
4709 gl.bufferData(GL_ARRAY_BUFFER, sizeof(buf), (GLvoid *)buf, GL_STATIC_DRAW);
4710 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");
4711
4712 GLuint vao = 0;
4713 gl.genVertexArrays(1, &vao);
4714 GLU_EXPECT_NO_ERROR(gl.getError(), "genVertexArrays");
4715 gl.bindVertexArray(vao);
4716 GLU_EXPECT_NO_ERROR(gl.getError(), "bindVertexArray");
4717 gl.vertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 0, nullptr);
4718 GLU_EXPECT_NO_ERROR(gl.getError(), "vertexAttribPointer");
4719
4720 if (vbo)
4721 {
4722 gl.deleteBuffers(1, &vbo);
4723 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers");
4724 }
4725
4726 if (vao)
4727 {
4728 gl.deleteVertexArrays(1, &vao);
4729 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteVertexArrays");
4730 }
4731
4732 return success;
4733 }
4734
TestCoverageGLCallViewport(void)4735 bool ApiCoverageTestCase::TestCoverageGLCallViewport(void)
4736 {
4737 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4738 bool success = true;
4739
4740 gl.viewport(0, 0, 50, 50);
4741 GLU_EXPECT_NO_ERROR(gl.getError(), "viewport");
4742
4743 return success;
4744 }
4745
TestCoverageGLCallIsRenderbuffer(void)4746 bool ApiCoverageTestCase::TestCoverageGLCallIsRenderbuffer(void)
4747 {
4748 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4749 bool success = true;
4750
4751 gl.isRenderbuffer(0);
4752 GLU_EXPECT_NO_ERROR(gl.getError(), "isRenderbuffer");
4753
4754 return success;
4755 }
4756
TestCoverageGLCallBindRenderbuffer(void)4757 bool ApiCoverageTestCase::TestCoverageGLCallBindRenderbuffer(void)
4758 {
4759 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4760 GLint i;
4761 bool success = true;
4762
4763 /* Positive tests. */
4764 for (i = 0; ea_RenderBufferTargets[i].value != -1; i++)
4765 {
4766 gl.bindRenderbuffer(ea_RenderBufferTargets[i].value, 0);
4767
4768 if (gl.getError() == GL_INVALID_ENUM)
4769 {
4770 tcu_fail_msg("ApiCoverageTestCase::CallBindRenderBuffer", "Invalid enum : %s",
4771 ea_RenderBufferTargets[i].name);
4772 success = false;
4773 }
4774 }
4775
4776 if (!m_is_context_ES || glu::contextSupports(m_context_type, glu::ApiType::es(3, 0)))
4777 {
4778
4779 /* Negative test for invalid target. GL_INVALID_ENUM error is expected.
4780 This error appears in OpenGL 4.5 Core Profile (update July 7, 2016)
4781 and in OpenGL ES 3.2 Core Profile specification. */
4782
4783 if ((!m_is_context_ES && glu::contextSupports(m_context_type, glu::ApiType::core(4, 5))) ||
4784 (m_is_context_ES && glu::contextSupports(m_context_type, glu::ApiType::es(3, 2))))
4785 {
4786 for (i = 0; ea_RenderBufferInvalidTargets[i].value != -1; i++)
4787 {
4788 gl.bindRenderbuffer(ea_RenderBufferInvalidTargets[i].value, 0);
4789
4790 if (gl.getError() != GL_INVALID_ENUM)
4791 {
4792 tcu_fail_msg("ApiCoverageTestCase::CallBindRenderBuffer",
4793 "Expected INVALID_ENUM during call with invalid target : %s",
4794 ea_RenderBufferInvalidTargets[i].name);
4795 success = false;
4796 }
4797 }
4798 }
4799 }
4800
4801 if (!m_is_context_ES)
4802 {
4803 /* Negative test for invalid renderbuffer object. GL_INVALID_OPERATION is expected.
4804 This error appears in OpenGL 4.5 Core Profile. */
4805 if (glu::contextSupports(m_context_type, glu::ApiType::core(4, 5)))
4806 {
4807 GLuint invalid_rbo = 0;
4808
4809 gl.genRenderbuffers(1, &invalid_rbo);
4810 GLU_EXPECT_NO_ERROR(gl.getError(), "genRenderbuffers");
4811 gl.deleteRenderbuffers(1, &invalid_rbo);
4812 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteRenderbuffers");
4813
4814 for (i = 0; ea_RenderBufferTargets[i].value != -1; i++)
4815 {
4816 gl.bindRenderbuffer(ea_RenderBufferTargets[i].value, invalid_rbo);
4817
4818 if (gl.getError() != GL_INVALID_OPERATION)
4819 {
4820 tcu_fail_msg("ApiCoverageTestCase::CallBindRenderBuffer",
4821 "An INVALID_OPERATION error was expected to be generated if renderbuffer is not zero "
4822 "or a name returned from a previous call to GenRenderbuffers, or if such a name has "
4823 "since been deleted with DeleteRenderbuffers. Invalid renderbuffer object : %s",
4824 invalid_rbo);
4825 success = false;
4826 }
4827 }
4828 }
4829 }
4830 return success;
4831 }
4832
TestCoverageGLCallDeleteRenderbuffers(void)4833 bool ApiCoverageTestCase::TestCoverageGLCallDeleteRenderbuffers(void)
4834 {
4835 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4836 GLint i;
4837 bool success = true;
4838 GLuint buf[1];
4839
4840 buf[0] = 2;
4841 while (glIsRenderbuffer(buf[0]))
4842 {
4843 buf[0] += 1;
4844 }
4845
4846 for (i = 0; ea_RenderBufferTargets[i].value != -1; i++)
4847 {
4848 gl.bindRenderbuffer(ea_RenderBufferTargets[i].value, buf[0]);
4849
4850 if (gl.getError() == GL_INVALID_ENUM)
4851 {
4852 tcu_fail_msg("ApiCoverageTestCase::CallDeleteRenderBuffer", "Invalid enum : %s",
4853 ea_RenderBufferTargets[i].name);
4854 success = false;
4855 }
4856
4857 gl.deleteRenderbuffers(1, buf);
4858 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteRenderbuffers");
4859 }
4860
4861 return success;
4862 }
4863
TestCoverageGLCallGenRenderbuffers(void)4864 bool ApiCoverageTestCase::TestCoverageGLCallGenRenderbuffers(void)
4865 {
4866 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4867 bool success = true;
4868
4869 GLuint buf[2];
4870 gl.genRenderbuffers(2, buf);
4871 GLU_EXPECT_NO_ERROR(gl.getError(), "genRenderbuffers");
4872 gl.deleteRenderbuffers(2, buf);
4873 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteRenderbuffers");
4874
4875 return success;
4876 }
4877
TestCoverageGLCallRenderbufferStorage(void)4878 bool ApiCoverageTestCase::TestCoverageGLCallRenderbufferStorage(void)
4879 {
4880 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
4881 GLint i, j;
4882 bool success = true;
4883 GLuint r, f;
4884
4885 gl.genRenderbuffers(1, &r);
4886 GLU_EXPECT_NO_ERROR(gl.getError(), "genRenderbuffers");
4887 gl.genFramebuffers(1, &f);
4888 GLU_EXPECT_NO_ERROR(gl.getError(), "genFramebuffers");
4889 gl.bindRenderbuffer(GL_RENDERBUFFER, r);
4890 GLU_EXPECT_NO_ERROR(gl.getError(), "bindRenderbuffer");
4891 gl.bindFramebuffer(GL_FRAMEBUFFER, f);
4892 GLU_EXPECT_NO_ERROR(gl.getError(), "bindFramebuffer");
4893
4894 for (i = 0; ea_RenderBufferTargets[i].value != -1; i++)
4895 {
4896 for (j = 0; ea_RenderBufferFormats[j].value != -1; j++)
4897 {
4898 gl.renderbufferStorage(ea_RenderBufferTargets[i].value, ea_RenderBufferFormats[j].value, 1, 1);
4899
4900 if (gl.getError() == GL_INVALID_ENUM)
4901 {
4902 tcu_fail_msg("ApiCoverageTestCase::CallBindRenderBuffer", "Invalid enums : (%s, %s)",
4903 ea_RenderBufferTargets[i].name, ea_RenderBufferFormats[j].name);
4904 success = false;
4905 }
4906 }
4907 }
4908
4909 if (m_context.getContextInfo().isExtensionSupported("GL_OES_rgb8_rgba8"))
4910 {
4911 for (i = 0; ea_RenderBufferTargets[i].value != -1; i++)
4912 {
4913 for (j = 0; ea_RenderBufferFormats_OES_rgb8_rgba8[j].value != -1; j++)
4914 {
4915 gl.renderbufferStorage(ea_RenderBufferTargets[i].value, ea_RenderBufferFormats_OES_rgb8_rgba8[j].value,
4916 1, 1);
4917
4918 if (gl.getError() == GL_INVALID_ENUM)
4919 {
4920 tcu_fail_msg("ApiCoverageTestCase::CallBindRenderBuffer", "Invalid enums : (%s, %s)",
4921 ea_RenderBufferTargets[i].name, ea_RenderBufferFormats_OES_rgb8_rgba8[j].name);
4922 success = false;
4923 }
4924 }
4925 }
4926 }
4927
4928 if (m_context.getContextInfo().isExtensionSupported("GL_OES_depth24"))
4929 {
4930 for (i = 0; ea_RenderBufferTargets[i].value != -1; i++)
4931 {
4932 for (j = 0; ea_RenderBufferFormats_OES_depth_component24[j].value != -1; j++)
4933 {
4934 gl.renderbufferStorage(ea_RenderBufferTargets[i].value,
4935 ea_RenderBufferFormats_OES_depth_component24[j].value, 1, 1);
4936
4937 if (gl.getError() == GL_INVALID_ENUM)
4938 {
4939 tcu_fail_msg("ApiCoverageTestCase::CallBindRenderBuffer", "Invalid enums : (%s, %s)",
4940 ea_RenderBufferTargets[i].name, ea_RenderBufferFormats_OES_depth_component24[j].name);
4941 success = false;
4942 }
4943 }
4944 }
4945 }
4946
4947 if (m_context.getContextInfo().isExtensionSupported("GL_OES_depth32"))
4948 {
4949 for (i = 0; ea_RenderBufferTargets[i].value != -1; i++)
4950 {
4951 for (j = 0; ea_RenderBufferFormats_OES_depth_component32[j].value != -1; j++)
4952 {
4953 gl.renderbufferStorage(ea_RenderBufferTargets[i].value,
4954 ea_RenderBufferFormats_OES_depth_component32[j].value, 1, 1);
4955
4956 if (gl.getError() == GL_INVALID_ENUM)
4957 {
4958 tcu_fail_msg("ApiCoverageTestCase::CallBindRenderBuffer", "Invalid enums : (%s, %s)",
4959 ea_RenderBufferTargets[i].name, ea_RenderBufferFormats_OES_depth_component32[j].name);
4960 success = false;
4961 }
4962 }
4963 }
4964 }
4965
4966 if (m_context.getContextInfo().isExtensionSupported("GL_OES_stencil1"))
4967 {
4968 for (i = 0; ea_RenderBufferTargets[i].value != -1; i++)
4969 {
4970 for (j = 0; ea_RenderBufferFormats_OES_stencil1[j].value != -1; j++)
4971 {
4972 gl.renderbufferStorage(ea_RenderBufferTargets[i].value, ea_RenderBufferFormats_OES_stencil1[j].value, 1,
4973 1);
4974
4975 if (gl.getError() == GL_INVALID_ENUM)
4976 {
4977 tcu_fail_msg("ApiCoverageTestCase::CallBindRenderBuffer", "Invalid enums : (%s, %s)",
4978 ea_RenderBufferTargets[i].name, ea_RenderBufferFormats_OES_stencil1[j].name);
4979 success = false;
4980 }
4981 }
4982 }
4983 }
4984
4985 if (m_context.getContextInfo().isExtensionSupported("GL_OES_stencil4"))
4986 {
4987 for (i = 0; ea_RenderBufferTargets[i].value != -1; i++)
4988 {
4989 for (j = 0; ea_RenderBufferFormats_OES_stencil4[j].value != -1; j++)
4990 {
4991 gl.renderbufferStorage(ea_RenderBufferTargets[i].value, ea_RenderBufferFormats_OES_stencil4[j].value, 1,
4992 1);
4993
4994 if (gl.getError() == GL_INVALID_ENUM)
4995 {
4996 tcu_fail_msg("ApiCoverageTestCase::CallBindRenderBuffer", "Invalid enums : (%s, %s)",
4997 ea_RenderBufferTargets[i].name, ea_RenderBufferFormats_OES_stencil4[j].name);
4998 success = false;
4999 }
5000 }
5001 }
5002 }
5003
5004 if (m_is_context_ES)
5005 {
5006 for (i = 0; ea_RenderBufferTargets[i].value != -1; i++)
5007 {
5008 for (j = 0; ea_InvalidRenderBufferFormats[j].value != -1; j++)
5009 {
5010 gl.renderbufferStorage(ea_RenderBufferTargets[i].value, ea_InvalidRenderBufferFormats[j].value, 1, 1);
5011
5012 if (gl.getError() != GL_INVALID_ENUM)
5013 {
5014 tcu_fail_msg("ApiCoverageTestCase::CallBindRenderBuffer", "Invalid enums accepted: %s",
5015 ea_InvalidRenderBufferFormats[j].name);
5016 success = false;
5017 }
5018 }
5019 }
5020 }
5021
5022 gl.deleteRenderbuffers(1, &r);
5023 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteRenderbuffers");
5024 gl.deleteFramebuffers(1, &f);
5025 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteFramebuffers");
5026
5027 return success;
5028 }
5029
TestCoverageGLCallGetRenderbufferParameteriv(void)5030 bool ApiCoverageTestCase::TestCoverageGLCallGetRenderbufferParameteriv(void)
5031 {
5032 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5033 bool success = true;
5034 GLint i, j;
5035 GLint buf[10];
5036
5037 for (i = 0; ea_RenderBufferTargets[i].value != -1; i++)
5038 {
5039 for (j = 0; ea_GetRenderBufferParameter[j].value != -1; j++)
5040 {
5041 gl.getRenderbufferParameteriv(ea_RenderBufferTargets[i].value, ea_GetRenderBufferParameter[j].value, buf);
5042
5043 if (gl.getError() == GL_INVALID_ENUM)
5044 {
5045 tcu_fail_msg("ApiCoverageTestCase::CallBindRenderBuffer", "Invalid enums : (%s, %s)",
5046 ea_RenderBufferTargets[i].name, ea_GetRenderBufferParameter[j].name);
5047 success = false;
5048 }
5049 }
5050 }
5051
5052 return success;
5053 }
5054
TestCoverageGLCallIsFramebuffer(void)5055 bool ApiCoverageTestCase::TestCoverageGLCallIsFramebuffer(void)
5056 {
5057 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5058 bool success = true;
5059
5060 gl.isFramebuffer(0);
5061 GLU_EXPECT_NO_ERROR(gl.getError(), "isFramebuffer");
5062
5063 return success;
5064 }
5065
TestCoverageGLCallBindFramebuffer(void)5066 bool ApiCoverageTestCase::TestCoverageGLCallBindFramebuffer(void)
5067 {
5068 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5069 GLint i;
5070 bool success = true;
5071
5072 for (i = 0; ea_FrameBufferTargets[i].value != -1; i++)
5073 {
5074 gl.bindFramebuffer(ea_FrameBufferTargets[i].value, 0);
5075
5076 if (gl.getError() == GL_INVALID_ENUM)
5077 {
5078 tcu_fail_msg("ApiCoverageTestCase::CallBindFrameBuffer", "Invalid enum : %s",
5079 ea_FrameBufferTargets[i].name);
5080 success = false;
5081 }
5082 }
5083
5084 return success;
5085 }
5086
TestCoverageGLCallDeleteFramebuffers(void)5087 bool ApiCoverageTestCase::TestCoverageGLCallDeleteFramebuffers(void)
5088 {
5089 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5090 GLint i;
5091 bool success = true;
5092 GLuint buf[1];
5093
5094 buf[0] = 2;
5095
5096 for (i = 0; ea_FrameBufferTargets[i].value != -1; i++)
5097 {
5098 gl.bindFramebuffer(ea_FrameBufferTargets[i].value, buf[0]);
5099
5100 if (gl.getError() == GL_INVALID_ENUM)
5101 {
5102 tcu_fail_msg("ApiCoverageTestCase::CallDeleteFrameBuffer", "Invalid enum : %s",
5103 ea_FrameBufferTargets[i].name);
5104 success = false;
5105 }
5106
5107 gl.deleteFramebuffers(1, buf);
5108 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteFramebuffers");
5109 }
5110
5111 return success;
5112 }
5113
TestCoverageGLCallGenFramebuffers(void)5114 bool ApiCoverageTestCase::TestCoverageGLCallGenFramebuffers(void)
5115 {
5116 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5117 bool success = true;
5118 GLuint buf[2];
5119
5120 gl.genFramebuffers(2, buf);
5121 GLU_EXPECT_NO_ERROR(gl.getError(), "genFramebuffers");
5122 gl.deleteFramebuffers(2, buf);
5123 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteFramebuffers");
5124
5125 return success;
5126 }
5127
TestCoverageGLCallCheckFramebufferStatus(void)5128 bool ApiCoverageTestCase::TestCoverageGLCallCheckFramebufferStatus(void)
5129 {
5130 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5131 GLint i;
5132 bool success = true;
5133
5134 for (i = 0; ea_FrameBufferTargets[i].value != -1; i++)
5135 {
5136 gl.checkFramebufferStatus(ea_FrameBufferTargets[i].value);
5137
5138 if (gl.getError() == GL_INVALID_ENUM)
5139 {
5140 tcu_fail_msg("ApiCoverageTestCase::CallCheckFrameBufferStatus", "Invalid enum : %s",
5141 ea_FrameBufferTargets[i].name);
5142 success = false;
5143 }
5144 }
5145
5146 return success;
5147 }
5148
TestCoverageGLCallFramebufferTexture2D(void)5149 bool ApiCoverageTestCase::TestCoverageGLCallFramebufferTexture2D(void)
5150 {
5151 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5152 GLint i, j;
5153 GLint maxColorAttachments;
5154 bool success = true;
5155 GLenum error = GL_NO_ERROR;
5156 GLuint fb;
5157
5158 /* Some framebuffer object must be bound. */
5159 gl.genFramebuffers(1, &fb);
5160 GLU_EXPECT_NO_ERROR(gl.getError(), "genFramebuffers");
5161 gl.bindFramebuffer(GL_FRAMEBUFFER, fb);
5162 GLU_EXPECT_NO_ERROR(gl.getError(), "bindFramebuffer");
5163
5164 maxColorAttachments = 1; // ES only supports 1 color attachment
5165
5166 for (i = 0; ea_FrameBufferTargets[i].value != -1; i++)
5167 {
5168 for (j = 0; ea_FrameBufferAttachments[j].value != -1; j++)
5169 {
5170 if ((ea_FrameBufferAttachments[j].value - ea_FrameBufferAttachments[0].value >= maxColorAttachments) &&
5171 (ea_FrameBufferAttachments[j].value != GL_DEPTH_ATTACHMENT) &&
5172 (ea_FrameBufferAttachments[j].value != GL_STENCIL_ATTACHMENT))
5173 continue;
5174
5175 gl.framebufferTexture2D(ea_FrameBufferTargets[i].value, ea_FrameBufferAttachments[j].value, GL_TEXTURE_2D,
5176 0, 0);
5177
5178 error = gl.getError();
5179 if (error == GL_INVALID_OPERATION)
5180 {
5181 tcu_fail_msg("ApiCoverageTestCase::CallFramebufferTexture2D", "Invalid operation : (%s, %s)",
5182 ea_FrameBufferTargets[i].name, ea_FrameBufferAttachments[j].name);
5183 success = false;
5184 }
5185 if (error == GL_INVALID_ENUM)
5186 {
5187 tcu_fail_msg("ApiCoverageTestCase::CallFramebufferTexture2D", "Invalid enum : (%s, %s)",
5188 ea_FrameBufferTargets[i].name, ea_FrameBufferAttachments[j].name);
5189 success = false;
5190 }
5191 }
5192 }
5193
5194 gl.deleteFramebuffers(1, &fb);
5195 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteFramebuffers");
5196
5197 return success;
5198 }
5199
TestCoverageGLCallFramebufferRenderbuffer(void)5200 bool ApiCoverageTestCase::TestCoverageGLCallFramebufferRenderbuffer(void)
5201 {
5202 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5203 GLint i, j, k;
5204 GLint maxColorAttachments;
5205 bool success = true;
5206 GLuint fb;
5207
5208 /* Some framebuffer object must be bound. */
5209 gl.genFramebuffers(1, &fb);
5210 GLU_EXPECT_NO_ERROR(gl.getError(), "genFramebuffers");
5211 gl.bindFramebuffer(GL_FRAMEBUFFER, fb);
5212 GLU_EXPECT_NO_ERROR(gl.getError(), "bindFramebuffer");
5213
5214 maxColorAttachments = 1; // ES only supports 1 color attachment
5215
5216 for (i = 0; ea_FrameBufferTargets[i].value != -1; i++)
5217 {
5218 for (j = 0; ea_RenderBufferTargets[j].value != -1; j++)
5219 {
5220 for (k = 0; ea_FrameBufferAttachments[k].value != -1; k++)
5221 {
5222 if ((ea_FrameBufferAttachments[k].value - ea_FrameBufferAttachments[0].value >= maxColorAttachments) &&
5223 (ea_FrameBufferAttachments[k].value != GL_DEPTH_ATTACHMENT) &&
5224 (ea_FrameBufferAttachments[k].value != GL_STENCIL_ATTACHMENT))
5225 continue;
5226
5227 gl.framebufferRenderbuffer(ea_FrameBufferTargets[i].value, ea_FrameBufferAttachments[k].value,
5228 ea_RenderBufferTargets[j].value, 0);
5229
5230 if (gl.getError() == GL_INVALID_ENUM)
5231 {
5232 tcu_fail_msg("ApiCoverageTestCase::CallFramebufferRenderbuffer3DOES", "Invalid enum : (%s, %s, %s)",
5233 ea_FrameBufferTargets[i].name, ea_RenderBufferTargets[j].name,
5234 ea_FrameBufferAttachments[k].name);
5235 success = false;
5236 }
5237 }
5238 }
5239 }
5240
5241 gl.deleteFramebuffers(1, &fb);
5242 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteFramebuffers");
5243
5244 return success;
5245 }
5246
TestCoverageGLCallGetFramebufferAttachmentParameteriv(void)5247 bool ApiCoverageTestCase::TestCoverageGLCallGetFramebufferAttachmentParameteriv(void)
5248 {
5249 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5250 GLint i, j, k;
5251 GLint maxColorAttachments;
5252 bool success = true;
5253 GLenum error = GL_NO_ERROR;
5254 GLint buf[10];
5255 GLuint tex;
5256 GLuint fb;
5257
5258 /* Some framebuffer object must be bound. */
5259 gl.genTextures(1, &tex);
5260 GLU_EXPECT_NO_ERROR(gl.getError(), "genTextures");
5261 gl.bindTexture(GL_TEXTURE_2D, tex);
5262 GLU_EXPECT_NO_ERROR(gl.getError(), "bindTexture");
5263 gl.genFramebuffers(1, &fb);
5264 GLU_EXPECT_NO_ERROR(gl.getError(), "genFramebuffers");
5265 gl.bindFramebuffer(GL_FRAMEBUFFER, fb);
5266 GLU_EXPECT_NO_ERROR(gl.getError(), "bindFramebuffer");
5267
5268 maxColorAttachments = 1; // ES only supports 1 color attachment
5269
5270 for (i = 0; ea_FrameBufferTargets[i].value != -1; i++)
5271 {
5272 for (j = 0; ea_FrameBufferAttachments[j].value != -1; j++)
5273 {
5274 if ((ea_FrameBufferAttachments[j].value - ea_FrameBufferAttachments[0].value >= maxColorAttachments) &&
5275 (ea_FrameBufferAttachments[j].value != GL_DEPTH_ATTACHMENT) &&
5276 (ea_FrameBufferAttachments[j].value != GL_STENCIL_ATTACHMENT))
5277 continue;
5278
5279 /* A texture must be attached to each attachment in turn
5280 to have something to query about. */
5281 gl.framebufferTexture2D(GL_FRAMEBUFFER, ea_FrameBufferAttachments[j].value, GL_TEXTURE_2D, tex, 0);
5282 GLU_EXPECT_NO_ERROR(gl.getError(), "framebufferTexture2D");
5283
5284 for (k = 0; ea_GetFramebufferAttachmentParameter[k].value != -1; k++)
5285 {
5286 gl.getFramebufferAttachmentParameteriv(ea_FrameBufferTargets[i].value,
5287 ea_FrameBufferAttachments[j].value,
5288 ea_GetFramebufferAttachmentParameter[k].value, buf);
5289
5290 error = gl.getError();
5291 if (error == GL_INVALID_OPERATION)
5292 {
5293 tcu_fail_msg("ApiCoverageTestCase::CallGetFramebufferAttachmentParameteriv",
5294 "Invalid operation : (%s, %s, %s)", ea_FrameBufferTargets[i].name,
5295 ea_FrameBufferAttachments[j].name, ea_GetFramebufferAttachmentParameter[k].name);
5296 success = false;
5297 }
5298 if (error == GL_INVALID_ENUM)
5299 {
5300 tcu_fail_msg("ApiCoverageTestCase::CallGetFramebufferAttachmentParameteriv",
5301 "Invalid enum : (%s, %s, %s)", ea_FrameBufferTargets[i].name,
5302 ea_FrameBufferAttachments[j].name, ea_GetFramebufferAttachmentParameter[k].name);
5303 success = false;
5304 }
5305 }
5306
5307 gl.framebufferTexture2D(GL_FRAMEBUFFER, ea_FrameBufferAttachments[j].value, GL_TEXTURE_2D, 0, 0);
5308 GLU_EXPECT_NO_ERROR(gl.getError(), "framebufferTexture2D");
5309 }
5310 }
5311
5312 gl.deleteFramebuffers(1, &fb);
5313 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteFramebuffers");
5314 gl.deleteTextures(1, &tex);
5315 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteTextures");
5316
5317 return success;
5318 }
5319
TestCoverageGLCallGenerateMipmap(void)5320 bool ApiCoverageTestCase::TestCoverageGLCallGenerateMipmap(void)
5321 {
5322 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5323 GLuint tex;
5324 GLubyte buf[4 * 4];
5325 GLenum error;
5326 bool success = true;
5327
5328 gl.genTextures(1, &tex);
5329 GLU_EXPECT_NO_ERROR(gl.getError(), "genTextures");
5330 gl.bindTexture(GL_TEXTURE_2D, tex);
5331 GLU_EXPECT_NO_ERROR(gl.getError(), "bindTexture");
5332 gl.texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, buf);
5333 GLU_EXPECT_NO_ERROR(gl.getError(), "texImage2D");
5334 gl.generateMipmap(GL_TEXTURE_2D);
5335
5336 error = gl.getError();
5337
5338 if (error != GL_NO_ERROR)
5339 {
5340 tcu_fail_msg("ApiCoverageTestCase::CallGenerateMipmap", "Error generated %x", error);
5341 success = false;
5342 }
5343
5344 gl.bindTexture(GL_TEXTURE_2D, 0);
5345 GLU_EXPECT_NO_ERROR(gl.getError(), "bindTexture");
5346 gl.deleteTextures(1, &tex);
5347 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteTextures");
5348
5349 return success;
5350 }
5351
TestCoverageGLCallCompileShader(void)5352 bool ApiCoverageTestCase::TestCoverageGLCallCompileShader(void)
5353 {
5354 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5355 bool success = true;
5356 GLuint shader;
5357 GLenum i;
5358 GLboolean compilerPresent;
5359
5360 if (m_is_context_ES)
5361 {
5362 gl.getBooleanv(GL_SHADER_COMPILER, &compilerPresent);
5363 GLU_EXPECT_NO_ERROR(gl.getError(), "getBooleanv");
5364 }
5365 else
5366 {
5367 compilerPresent = GL_TRUE;
5368 }
5369
5370 for (i = 0; ea_ShaderTypes[i].value != -1; i++)
5371 {
5372 shader = gl.createShader(ea_ShaderTypes[i].value);
5373 GLU_EXPECT_NO_ERROR(gl.getError(), "createShader");
5374
5375 gl.compileShader(shader);
5376 GLU_EXPECT_NO_ERROR(gl.getError(), "compileShader");
5377
5378 if (!compilerPresent)
5379 {
5380 if (gl.getError() != GL_INVALID_OPERATION)
5381 {
5382 tcu_fail_msg("ApiCoverageTestCase::CallCompileShader",
5383 "Compiler not present, expected INVALID_OPERATION");
5384 success = success && false;
5385 }
5386 }
5387
5388 gl.deleteShader(shader);
5389 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteShader");
5390 }
5391
5392 return success;
5393 }
5394
TestCoverageGLCallGetShaderiv(void)5395 bool ApiCoverageTestCase::TestCoverageGLCallGetShaderiv(void)
5396 {
5397 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5398 bool success = true;
5399 GLuint shader;
5400 GLint i, j;
5401 GLint buf[10];
5402 GLenum error;
5403 GLboolean compilerPresent;
5404
5405 if (m_is_context_ES)
5406 {
5407 gl.getBooleanv(GL_SHADER_COMPILER, &compilerPresent);
5408 GLU_EXPECT_NO_ERROR(gl.getError(), "getBooleanv");
5409 }
5410 else
5411 {
5412 compilerPresent = GL_TRUE;
5413 }
5414
5415 for (i = 0; ea_ShaderTypes[i].value != -1; i++)
5416 {
5417 shader = gl.createShader(ea_ShaderTypes[i].value);
5418 GLU_EXPECT_NO_ERROR(gl.getError(), "createShader");
5419
5420 for (j = 0; ea_GetShaderStatus[j].value != -1; j++)
5421 {
5422 gl.getShaderiv(shader, ea_GetShaderStatus[j].value, buf);
5423
5424 error = gl.getError();
5425
5426 if (!compilerPresent && (ea_GetShaderStatus[j].value == GL_COMPILE_STATUS))
5427 {
5428 if (error != GL_INVALID_OPERATION)
5429 {
5430 tcu_fail_msg("ApiCoverageTestCase::CallGetShaderiv",
5431 "Compiler not present, expected INVALID_OPERATION");
5432 success = success && false;
5433 }
5434 }
5435 else if (error == GL_INVALID_ENUM)
5436 {
5437 tcu_fail_msg("ApiCoverageTestCase::CallGetShaderiv", "Invalid enum : (%s, %s)", ea_ShaderTypes[i].name,
5438 ea_GetShaderStatus[j].name);
5439 success = success && false;
5440 }
5441 }
5442
5443 gl.deleteShader(shader);
5444 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteShader");
5445 }
5446
5447 return success;
5448 }
5449
TestCoverageGLCallGetShaderInfoLog(void)5450 bool ApiCoverageTestCase::TestCoverageGLCallGetShaderInfoLog(void)
5451 {
5452 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5453 bool success = true;
5454 GLuint shader;
5455 GLenum i;
5456 GLchar infolog[1024];
5457 GLsizei length;
5458
5459 for (i = 0; ea_ShaderTypes[i].value != -1; i++)
5460 {
5461 shader = gl.createShader(ea_ShaderTypes[i].value);
5462 GLU_EXPECT_NO_ERROR(gl.getError(), "createShader");
5463
5464 gl.getShaderInfoLog(shader, 1024, &length, infolog);
5465 GLU_EXPECT_NO_ERROR(gl.getError(), "getShaderInfoLog");
5466
5467 gl.deleteShader(shader);
5468 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteShader");
5469 }
5470
5471 return success;
5472 }
5473
TestCoverageGLCallGetShaderSource(void)5474 bool ApiCoverageTestCase::TestCoverageGLCallGetShaderSource(void)
5475 {
5476 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5477 bool success = true;
5478 GLuint shader;
5479 GLenum i;
5480 GLchar infolog[1024];
5481 GLsizei length;
5482 GLboolean compilerPresent;
5483
5484 if (m_is_context_ES)
5485 {
5486 gl.getBooleanv(GL_SHADER_COMPILER, &compilerPresent);
5487 GLU_EXPECT_NO_ERROR(gl.getError(), "getBooleanv");
5488 }
5489 else
5490 {
5491 compilerPresent = GL_TRUE;
5492 }
5493
5494 for (i = 0; ea_ShaderTypes[i].value != -1; i++)
5495 {
5496 shader = gl.createShader(ea_ShaderTypes[i].value);
5497 GLU_EXPECT_NO_ERROR(gl.getError(), "createShader");
5498
5499 gl.getShaderSource(shader, 1024, &length, infolog);
5500
5501 if (!compilerPresent)
5502 {
5503 if (gl.getError() != GL_INVALID_OPERATION)
5504 {
5505 tcu_fail_msg("ApiCoverageTestCase::CallGetShaderSource",
5506 "Compiler not present, expected INVALID_OPERATION");
5507 success = success && false;
5508 }
5509 }
5510
5511 gl.deleteShader(shader);
5512 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteShader");
5513 }
5514
5515 return success;
5516 }
5517
TestCoverageGLCallShaderSource(void)5518 bool ApiCoverageTestCase::TestCoverageGLCallShaderSource(void)
5519 {
5520 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5521 bool success = true;
5522 GLuint shader;
5523 GLenum i;
5524 const GLchar *buf = "int main {}\n\0";
5525 GLint bufSize[1];
5526 GLboolean compilerPresent;
5527
5528 bufSize[0] = (GLint)strlen(buf);
5529
5530 if (m_is_context_ES)
5531 {
5532 gl.getBooleanv(GL_SHADER_COMPILER, &compilerPresent);
5533 GLU_EXPECT_NO_ERROR(gl.getError(), "getBooleanv");
5534 }
5535 else
5536 {
5537 compilerPresent = GL_TRUE;
5538 }
5539
5540 for (i = 0; ea_ShaderTypes[i].value != -1; i++)
5541 {
5542 shader = gl.createShader(ea_ShaderTypes[i].value);
5543 GLU_EXPECT_NO_ERROR(gl.getError(), "createShader");
5544
5545 gl.shaderSource(shader, 1, &buf, bufSize);
5546
5547 if (!compilerPresent)
5548 {
5549 if (gl.getError() != GL_INVALID_OPERATION)
5550 {
5551 tcu_fail_msg("ApiCoverageTestCase::CallShaderSource",
5552 "Compiler not present, expected INVALID_OPERATION");
5553 success = success && false;
5554 }
5555 }
5556
5557 gl.deleteShader(shader);
5558 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteShader");
5559 }
5560
5561 return success;
5562 }
5563
5564 /**************************************************************************/
5565
5566 /* Coverage tests for OpenGL ES entry points not shared with OpenGL.
5567 ** Some of these can be re-purposed for comparable OpenGL entry points.
5568 */
5569
TestCoverageGLCallClearDepthf(void)5570 bool ApiCoverageTestCase::TestCoverageGLCallClearDepthf(void)
5571 {
5572 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5573 bool success = true;
5574
5575 gl.clearDepthf(0.0f);
5576 GLU_EXPECT_NO_ERROR(gl.getError(), "clearDepthf");
5577
5578 return success;
5579 }
5580
TestCoverageGLCallDepthRangef(void)5581 bool ApiCoverageTestCase::TestCoverageGLCallDepthRangef(void)
5582 {
5583 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5584 bool success = true;
5585
5586 gl.depthRangef(0.0, 1.0);
5587 GLU_EXPECT_NO_ERROR(gl.getError(), "depthRangef");
5588
5589 return success;
5590 }
5591
TestCoverageGLCallFramebufferTexture3DOES(void)5592 bool ApiCoverageTestCase::TestCoverageGLCallFramebufferTexture3DOES(void)
5593 {
5594 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5595 GLint i, j;
5596 bool success = true;
5597
5598 for (i = 0; ea_FrameBufferTargets[i].value != -1; i++)
5599 {
5600 for (j = 0; ea_FrameBufferAttachments[j].value != -1; j++)
5601 {
5602 if (m_context.getContextInfo().isExtensionSupported("GL_OES_texture_3D"))
5603 {
5604 gl.framebufferTexture3DOES(ea_FrameBufferTargets[i].value, ea_FrameBufferAttachments[j].value,
5605 GL_TEXTURE_2D, 0, 0, 0);
5606 }
5607
5608 if (gl.getError() == GL_INVALID_ENUM)
5609 {
5610 tcu_fail_msg("ApiCoverageTestCase::CallFramebufferTexture3DOES", "Invalid enum : (%s, %s)",
5611 ea_FrameBufferTargets[i].name, ea_FrameBufferAttachments[j].name);
5612 success = false;
5613 }
5614 }
5615 }
5616
5617 return success;
5618 }
5619
TestCoverageGLCallMapBufferOES(void)5620 bool ApiCoverageTestCase::TestCoverageGLCallMapBufferOES(void)
5621 {
5622 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5623 bool success = true;
5624
5625 if (m_context.getContextInfo().isExtensionSupported("GL_OES_mapbuffer"))
5626 {
5627 glMapBufferFunc glMapBufferOES = (glMapBufferFunc)m_context.getRenderContext().getProcAddress("glMapBufferOES");
5628 glUnmapBufferFunc glUnmapBufferOES =
5629 (glUnmapBufferFunc)m_context.getRenderContext().getProcAddress("glUnmapBufferOES");
5630 glGetBufferPointervFunc glGetBufferPointervOES =
5631 (glGetBufferPointervFunc)m_context.getRenderContext().getProcAddress("glGetBufferPointervOES");
5632 GLuint bufname;
5633 GLenum error;
5634
5635 /* Set up a buffer to map */
5636 gl.genBuffers(1, &bufname);
5637 GLU_EXPECT_NO_ERROR(gl.getError(), "genBuffers");
5638 gl.bindBuffer(GL_ARRAY_BUFFER, bufname);
5639 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBuffer");
5640 gl.bufferData(GL_ARRAY_BUFFER, 4, 0, GL_STATIC_DRAW);
5641 GLU_EXPECT_NO_ERROR(gl.getError(), "bufferData");
5642
5643 if (glMapBufferOES)
5644 {
5645 GLuint *mapping;
5646
5647 mapping = (GLuint *)glMapBufferOES(GL_ARRAY_BUFFER, GL_WRITE_ONLY_OES);
5648
5649 mapping[0] = 0xDEADBEEF;
5650
5651 error = gl.getError();
5652
5653 if (error != GL_NO_ERROR)
5654 {
5655 tcu_fail_msg("ApiCoverageTestCase::CallMapBufferOES", "Error generated from glMapBufferOES: %x", error);
5656 success = false;
5657 }
5658 }
5659 else
5660 {
5661 tcu_fail_msg("ApiCoverageTestCase::CallMapBufferOES", "GETPROCADDRESS failed for glMapBufferOES");
5662 success = false;
5663 }
5664
5665 if (glGetBufferPointervOES)
5666 {
5667 void *mapping;
5668
5669 glGetBufferPointervOES(GL_ARRAY_BUFFER, GL_BUFFER_MAP_POINTER_OES, &mapping);
5670
5671 error = gl.getError();
5672
5673 if (error != GL_NO_ERROR)
5674 {
5675 tcu_fail_msg("ApiCoverageTestCase::CallMapBufferOES", "Error generated from glGetBufferPointervOES: %x",
5676 error);
5677 success = false;
5678 }
5679 }
5680 else
5681 {
5682 tcu_fail_msg("ApiCoverageTestCase::CallMapBufferOES", "GETPROCADDRESS failed for glGetBufferPointervOES");
5683 success = false;
5684 }
5685
5686 if (glUnmapBufferOES)
5687 {
5688 glUnmapBufferOES(GL_ARRAY_BUFFER);
5689
5690 error = gl.getError();
5691
5692 if (error != GL_NO_ERROR)
5693 {
5694 tcu_fail_msg("ApiCoverageTestCase::CallMapBufferOES", "Error generated from glUnmapBufferOES: %x",
5695 error);
5696 success = false;
5697 }
5698 }
5699 else
5700 {
5701 tcu_fail_msg("ApiCoverageTestCase::CallMapBufferOES", "GETPROCADDRESS failed for glUnmapBufferOES");
5702 success = false;
5703 }
5704
5705 gl.bindBuffer(GL_ARRAY_BUFFER, 0);
5706 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBuffer");
5707 gl.deleteBuffers(1, &bufname);
5708 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
5709 }
5710
5711 return success;
5712 }
5713
TestCoverageGLCallTexImage3DOES(void)5714 bool ApiCoverageTestCase::TestCoverageGLCallTexImage3DOES(void)
5715 {
5716 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5717 bool success = true;
5718
5719 if (m_context.getContextInfo().isExtensionSupported("GL_OES_texture_3D"))
5720 {
5721 GLubyte buf[1000];
5722 GLint i, j;
5723
5724 for (i = 0; ea_TextureTarget[i].value != -1; i++)
5725 {
5726 for (j = 0; ea_TextureFormat[j].value != -1; j++)
5727 {
5728 memset(buf, 0, 1000 * sizeof(GLubyte));
5729 gl.texImage3DOES(ea_TextureTarget[i].value, 0, ea_TextureFormat[j].value, 1, 1, 1, 0,
5730 ea_TextureFormat[j].value, ea_TextureType[j].value, buf);
5731
5732 if (gl.getError() == GL_INVALID_ENUM)
5733 {
5734 tcu_fail_msg("ApiCoverageTestCase::CallTexImage3D", "Invalid enums : (%s, %s, %s)",
5735 ea_TextureTarget[i].name, ea_TextureFormat[j].name, ea_TextureType[j].name);
5736 success = false;
5737 }
5738
5739 gl.texImage3DOES(ea_TextureTarget[i].value, 0, ea_TextureFormat[j].value, 1, 1, 1, 0,
5740 ea_TextureFormat[j].value, ea_TextureType[j].value, (const void *)NULL);
5741
5742 if (gl.getError() == GL_INVALID_ENUM)
5743 {
5744 tcu_fail_msg("ApiCoverageTestCase::CallTexImage3D", "Invalid enums : (%s, %s, %s)",
5745 ea_TextureTarget[i].name, ea_TextureFormat[j].name, ea_TextureType[j].name);
5746 success = false;
5747 }
5748 }
5749 }
5750 }
5751
5752 return success;
5753 }
5754
TestCoverageGLCallTexSubImage3DOES(void)5755 bool ApiCoverageTestCase::TestCoverageGLCallTexSubImage3DOES(void)
5756 {
5757 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5758 bool success = true;
5759
5760 if (m_context.getContextInfo().isExtensionSupported("GL_OES_texture_3D"))
5761 {
5762 GLubyte buf[1000];
5763 int i;
5764
5765 for (i = 0; ea_TextureFormat[i].value != -1; i++)
5766 {
5767 memset(buf, 0, 1000 * sizeof(GLubyte));
5768 gl.texImage3DOES(GL_TEXTURE_2D, 0, ea_TextureFormat[i].value, 1, 1, 1, 0, ea_TextureFormat[i].value,
5769 ea_TextureType[i].value, buf);
5770
5771 gl.texSubImage3DOES(GL_TEXTURE_2D, 0, 0, 0, 0, 1, 1, 1, ea_TextureFormat[i].value, ea_TextureType[i].value,
5772 buf);
5773
5774 if (gl.getError() == GL_INVALID_ENUM)
5775 {
5776 tcu_fail_msg("ApiCoverageTestCase::CallTexSubImage3D", "Invalid enums : (%s, %s)",
5777 ea_TextureFormat[i].name, ea_TextureType[i].name);
5778 success = false;
5779 }
5780
5781 gl.texImage3DOES(GL_TEXTURE_2D, 0, ea_TextureFormat[i].value, 1, 1, 1, 0, ea_TextureFormat[i].value,
5782 ea_TextureType[i].value, (const void *)NULL);
5783
5784 gl.texSubImage3DOES(GL_TEXTURE_2D, 0, 0, 0, 0, 1, 1, 1, ea_TextureFormat[i].value, ea_TextureType[i].value,
5785 buf);
5786
5787 if (gl.getError() == GL_INVALID_ENUM)
5788 {
5789 tcu_fail_msg("ApiCoverageTestCase::CallTexSubImage3D", "Invalid enums : (%s, %s)",
5790 ea_TextureFormat[i].name, ea_TextureType[i].name);
5791 success = false;
5792 }
5793 }
5794 }
5795
5796 return success;
5797 }
5798
TestCoverageGLCallCompressedTexImage3DOES(void)5799 bool ApiCoverageTestCase::TestCoverageGLCallCompressedTexImage3DOES(void)
5800 {
5801 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5802 bool success = true;
5803
5804 if (m_context.getContextInfo().isExtensionSupported("GL_OES_texture_3D"))
5805 {
5806 /* Are there any compressed 3D texture formats? Add them here... */
5807 gl.compressedTexImage3DOES(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, 1, (const void *)NULL);
5808 GLU_EXPECT_NO_ERROR(gl.getError(), "compressedTexImage3DOES");
5809
5810 /* Can't really work out what the error might be - probably INVALID_OPERATION or INVALID_VALUE or INVALID_ENUM */
5811 gl.getError();
5812 GLU_EXPECT_NO_ERROR(gl.getError(), "getError");
5813 }
5814
5815 return success;
5816 }
5817
TestCoverageGLCallCompressedTexSubImage3DOES(void)5818 bool ApiCoverageTestCase::TestCoverageGLCallCompressedTexSubImage3DOES(void)
5819 {
5820 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5821 bool success = true;
5822
5823 if (m_context.getContextInfo().isExtensionSupported("GL_OES_texture_3D"))
5824 {
5825 /* Are there any compressed 3D texture formats? Add them here... */
5826 gl.compressedTexSubImage3DOES(GL_TEXTURE_2D, 0, 0, 0, 0, 1, 1, 1, GL_RGBA, 1, (const void *)NULL);
5827 GLU_EXPECT_NO_ERROR(gl.getError(), "getError");
5828
5829 /* Can't really work out what the error might be - probably INVALID_OPERATION or INVALID_VALUE or INVALID_ENUM */
5830 gl.getError();
5831 GLU_EXPECT_NO_ERROR(gl.getError(), "getError");
5832 }
5833
5834 return success;
5835 }
5836
TestCoverageGLCallShaderBinary(void)5837 bool ApiCoverageTestCase::TestCoverageGLCallShaderBinary(void)
5838 {
5839 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5840 GLuint shader;
5841 GLint numBinFormats = 0;
5842 GLenum i;
5843
5844 gl.getIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &numBinFormats);
5845 GLU_EXPECT_NO_ERROR(gl.getError(), "getIntegerv");
5846 if (numBinFormats <= 0)
5847 {
5848 return true;
5849 }
5850
5851 std::vector<GLint> binFormats(numBinFormats);
5852 gl.getIntegerv(GL_SHADER_BINARY_FORMATS, binFormats.data());
5853 GLU_EXPECT_NO_ERROR(gl.getError(), "getIntegerv");
5854
5855 for (i = 0; ea_ShaderTypes[i].value != -1; i++)
5856 {
5857 shader = gl.createShader(ea_ShaderTypes[i].value);
5858 GLU_EXPECT_NO_ERROR(gl.getError(), "createShader");
5859 gl.shaderBinary(1, &shader, binFormats[0], (const void *)NULL, 0);
5860 /* clear the error log - see bug 4109 */
5861 gl.getError();
5862
5863 gl.deleteShader(shader);
5864 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteShader");
5865 }
5866
5867 return true;
5868 }
5869
TestCoverageGLCallReleaseShaderCompiler(void)5870 bool ApiCoverageTestCase::TestCoverageGLCallReleaseShaderCompiler(void)
5871 {
5872 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5873
5874 if (m_is_context_ES)
5875 {
5876 bool success = true;
5877 GLboolean compilerPresent;
5878
5879 gl.getBooleanv(GL_SHADER_COMPILER, &compilerPresent);
5880 GLU_EXPECT_NO_ERROR(gl.getError(), "getBooleanv");
5881 gl.releaseShaderCompiler();
5882
5883 if (!compilerPresent)
5884 {
5885 if (gl.getError() != GL_INVALID_OPERATION)
5886 {
5887 tcu_fail_msg("ApiCoverageTestCase::CallReleaseShaderCompiler",
5888 "Compiler not present, expected INVALID_OPERATION");
5889 success = success && false;
5890 }
5891 }
5892
5893 return success;
5894 }
5895 else
5896 {
5897
5898 // Can't release shader compiler in desktop OpenGL
5899 return true;
5900 }
5901 }
5902
TestCoverageGLCallGetShaderPrecisionFormat(void)5903 bool ApiCoverageTestCase::TestCoverageGLCallGetShaderPrecisionFormat(void)
5904 {
5905 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5906 bool success = true;
5907 GLint i, j;
5908 GLint range[2], precision;
5909 GLboolean compilerPresent;
5910 GLenum error;
5911
5912 gl.getBooleanv(GL_SHADER_COMPILER, &compilerPresent);
5913 GLU_EXPECT_NO_ERROR(gl.getError(), "getBooleanv");
5914
5915 for (i = 0; ea_ShaderTypes[i].value != -1; i++)
5916 {
5917 for (j = 0; ea_ShaderPrecision[j].value != -1; j++)
5918 {
5919 range[0] = 0xffffffff;
5920 range[1] = 0xffffffff;
5921 precision = 0xffffffff;
5922 gl.getShaderPrecisionFormat(ea_ShaderTypes[i].value, ea_ShaderPrecision[j].value, range, &precision);
5923
5924 error = gl.getError();
5925
5926 if (!compilerPresent)
5927 {
5928 // Removing this error check for this release. The spec currently states that this error should exist, but
5929 // the group is discussing whether this is a spec bug. An implementer could also change their binary shader
5930 // extension to allow this error. See bugzilla 4151 for more details.
5931 //if (error != GL_INVALID_OPERATION)
5932 //{
5933 // tcu_fail_msg(
5934 // "ApiCoverageTestCase::CallGetShaderPrecisionFormat",
5935 // "Compiler not present, expected INVALID_OPERATION");
5936 // success = success && false;
5937 //}
5938 }
5939 else if (error != GL_NONE)
5940 {
5941 tcu_fail_msg("ApiCoverageTestCase::CallGetShaderPrecisionFormat", "GL error : (%s, %s)",
5942 ea_ShaderTypes[i].name, ea_ShaderPrecision[j].name);
5943 success = success && false;
5944 }
5945 else
5946 {
5947 if ((ea_ShaderPrecision[j].value == GL_LOW_INT) || (ea_ShaderPrecision[j].value == GL_MEDIUM_INT) ||
5948 (ea_ShaderPrecision[j].value == GL_HIGH_INT))
5949 {
5950 // Log2(1) is 0
5951 if (precision != 0)
5952 {
5953 tcu_fail_msg("ApiCoverageTestCase::CallGetShaderPrecisionFormat",
5954 "Precision of ints must be 0");
5955 success = success && false;
5956 }
5957 }
5958
5959 if ((GLuint(range[0]) == 0xffffffff) || (GLuint(range[1]) == 0xffffffff))
5960 {
5961 tcu_fail_msg("ApiCoverageTestCase::CallGetShaderPrecisionFormat", "Range value not updated");
5962 success = success && false;
5963 }
5964 }
5965 }
5966 }
5967
5968 return success;
5969 }
5970
5971 /* Coverage test for glReadBuffer */
TestCoverageGLCallReadBuffer(void)5972 bool ApiCoverageTestCase::TestCoverageGLCallReadBuffer(void)
5973 {
5974 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
5975 int i;
5976 GLint error;
5977 bool success = true;
5978 GLint origReadBuffer;
5979 GLint width = 32, height = 32;
5980 GLuint fbo = 0, rbo_color[4] = {0, 0, 0, 0};
5981
5982 error = gl.getError(); // clear error from previous test, if any
5983
5984 // Save original read buffer value
5985 gl.getIntegerv(GL_READ_BUFFER, &origReadBuffer);
5986 GLU_EXPECT_NO_ERROR(gl.getError(), "getIntegerv");
5987
5988 for (i = 0; ea_ReadBuffer[i].value != -1; i++)
5989 {
5990 gl.readBuffer(ea_ReadBuffer[i].value);
5991
5992 error = gl.getError();
5993 if ((error != GL_NO_ERROR) && (ea_ReadBuffer[i].value <= GL_BACK))
5994 {
5995
5996 if (!m_is_context_ES)
5997 {
5998 glw::GLenum drawBuffer = 0;
5999 m_context.getRenderContext().getFunctions().getIntegerv(GL_DRAW_BUFFER, (glw::GLint *)&drawBuffer);
6000 bool configIsDoubleBuffered = (drawBuffer == GL_BACK);
6001
6002 /* It is an expected error to call glReadBuffer(GL_BACK) on
6003 a drawable that does not have a back buffer */
6004 if (!configIsDoubleBuffered && ea_ReadBuffer[i].value == GL_BACK && error == GL_INVALID_OPERATION)
6005 {
6006 continue;
6007 }
6008 }
6009 tcu_fail_msg("ApiCoverageTestCase::ReadBuffer", "Invalid error %d for %s.", error, ea_ReadBuffer[i].name);
6010 success = false;
6011 }
6012 }
6013
6014 // FBO
6015 gl.genFramebuffers(1, &fbo);
6016 GLU_EXPECT_NO_ERROR(gl.getError(), "genFramebuffers");
6017 gl.bindFramebuffer(GL_FRAMEBUFFER, fbo);
6018 GLU_EXPECT_NO_ERROR(gl.getError(), "bindFramebuffer");
6019
6020 // RBO (color)
6021 gl.genRenderbuffers(4, rbo_color);
6022 GLU_EXPECT_NO_ERROR(gl.getError(), "genRenderbuffers");
6023 gl.bindRenderbuffer(GL_RENDERBUFFER, rbo_color[0]);
6024 GLU_EXPECT_NO_ERROR(gl.getError(), "bindRenderbuffer");
6025 gl.renderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, width, height);
6026 GLU_EXPECT_NO_ERROR(gl.getError(), "renderbufferStorage");
6027 gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo_color[0]);
6028 GLU_EXPECT_NO_ERROR(gl.getError(), "framebufferRenderbuffer");
6029
6030 gl.bindRenderbuffer(GL_RENDERBUFFER, rbo_color[1]);
6031 GLU_EXPECT_NO_ERROR(gl.getError(), "bindRenderbuffer");
6032 gl.renderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, width, height);
6033 GLU_EXPECT_NO_ERROR(gl.getError(), "renderbufferStorage");
6034 gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_RENDERBUFFER, rbo_color[1]);
6035 GLU_EXPECT_NO_ERROR(gl.getError(), "framebufferRenderbuffer");
6036
6037 error = gl.checkFramebufferStatus(GL_FRAMEBUFFER);
6038 if (error != GL_FRAMEBUFFER_COMPLETE)
6039 {
6040 tcu_fail_msg("ApiCoverageTestCase::ReadBuffers", "Expected GL_FRAMEBUFFER_COMPLETE, got 0x%x", error);
6041 return false;
6042 }
6043
6044 for (i = 0; ea_ReadBuffer[i].value != -1; i++)
6045 {
6046 gl.readBuffer(ea_ReadBuffer[i].value);
6047 error = gl.getError();
6048
6049 if ((error != GL_NO_ERROR) && (ea_ReadBuffer[i].value > GL_BACK))
6050 {
6051 tcu_fail_msg("ApiCoverageTestCase::ReadBuffer", "Invalid error %d for FBO %s.", error,
6052 ea_ReadBuffer[i].name);
6053 success = false;
6054 }
6055 }
6056
6057 gl.deleteFramebuffers(1, &fbo);
6058 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteFramebuffers");
6059
6060 // Restore read buffer
6061 gl.readBuffer(origReadBuffer);
6062 GLU_EXPECT_NO_ERROR(gl.getError(), "readBuffer");
6063
6064 gl.deleteFramebuffers(1, &fbo);
6065 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteFramebuffers");
6066 gl.deleteRenderbuffers(4, rbo_color);
6067 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteRenderbuffers");
6068
6069 return success;
6070 }
6071
6072 /* Coverage test for glDrawRangeElements */
TestCoverageGLCallDrawRangeElements(void)6073 bool ApiCoverageTestCase::TestCoverageGLCallDrawRangeElements(void)
6074 {
6075 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6076 GLint error;
6077 bool success = true;
6078 unsigned short indices[] = {2, 1, 0, 2, 1, 0};
6079 GLint program;
6080
6081 (void)gl.getError(); // clear error from previous test, if any
6082
6083 GLuint va = 0;
6084 gl.genVertexArrays(1, &va);
6085 GLU_EXPECT_NO_ERROR(gl.getError(), "genVertexArrays");
6086 gl.bindVertexArray(va);
6087 GLU_EXPECT_NO_ERROR(gl.getError(), "bindVertexArray");
6088
6089 program = createDefaultProgram(0);
6090
6091 if (program == -1)
6092 {
6093 tcu_fail_msg("ApiCoverageTestCase::DrawRangeElements", "Program create Failed");
6094 return false;
6095 }
6096
6097 gl.drawRangeElements(GL_TRIANGLES, 0, 5, 3, GL_UNSIGNED_SHORT, indices);
6098 GLU_EXPECT_NO_ERROR(gl.getError(), "drawRangeElements");
6099 error = gl.getError();
6100
6101 if (error != GL_NO_ERROR)
6102 {
6103 success = false;
6104 tcu_fail_msg("ApiCoverageTestCase::DrawRangeElements", "Incorrect error %d", error);
6105 }
6106
6107 gl.drawRangeElements(GL_TRIANGLES, 2, 1, 3, GL_UNSIGNED_SHORT, indices);
6108 error = gl.getError();
6109 if (error != GL_INVALID_VALUE)
6110 {
6111 success = false;
6112 tcu_fail_msg("ApiCoverageTestCase::DrawRangeElements", "Incorrect error %d", error);
6113 }
6114
6115 gl.deleteProgram((GLuint)program);
6116 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
6117
6118 gl.deleteVertexArrays(1, &va);
6119 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteVertexArrays");
6120
6121 return success;
6122 }
6123
6124 /* Coverage test for glTexImage3D */
TestCoverageGLCallTexImage3D(void)6125 bool ApiCoverageTestCase::TestCoverageGLCallTexImage3D(void)
6126 {
6127 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6128 bool success = true;
6129 GLubyte buf[1000];
6130 GLint i, j;
6131
6132 (void)gl.getError(); // clear error from previous test, if any
6133
6134 for (i = 0; ea_Texture3DTarget[i].value != -1; i++)
6135 {
6136 for (j = 0; ea_TextureFormat[j].value != -1; j++)
6137 {
6138 memset(buf, 0, 1000 * sizeof(GLubyte));
6139 gl.texImage3D(ea_Texture3DTarget[i].value, 0, ea_TextureFormat[j].value, 1, 1, 1, 0,
6140 ea_TextureFormat[j].value, ea_TextureType[j].value, buf);
6141
6142 if (gl.getError() == GL_INVALID_ENUM)
6143 {
6144 tcu_fail_msg("ApiCoverageTestCase::CallTexImage3D", "Invalid enums : (%s, %s, %s)",
6145 ea_TextureTarget[i].name, ea_TextureFormat[j].name, ea_TextureType[j].name);
6146 success = false;
6147 }
6148
6149 gl.texImage3D(ea_Texture3DTarget[i].value, 0, ea_TextureFormat[j].value, 1, 1, 1, 0,
6150 ea_TextureFormat[j].value, ea_TextureType[j].value, (const void *)NULL);
6151
6152 if (gl.getError() == GL_INVALID_ENUM)
6153 {
6154 tcu_fail_msg("ApiCoverageTestCase::CallTexImage3D", "Invalid enums : (%s, %s, %s)",
6155 ea_TextureTarget[i].name, ea_TextureFormat[j].name, ea_TextureType[j].name);
6156 success = false;
6157 }
6158 }
6159 }
6160
6161 return success;
6162 }
6163
6164 /* Coverage test for glTexSubImage3D */
TestCoverageGLCallTexSubImage3D(void)6165 bool ApiCoverageTestCase::TestCoverageGLCallTexSubImage3D(void)
6166 {
6167 bool success = true;
6168 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6169 GLubyte buf[1000];
6170 int i;
6171
6172 (void)gl.getError(); // clear error from previous test, if any
6173
6174 for (i = 0; ea_TextureFormat[i].value != -1; i++)
6175 {
6176 memset(buf, 0, 1000 * sizeof(GLubyte));
6177 gl.texImage3D(GL_TEXTURE_3D, 0, ea_TextureFormat[i].value, 1, 1, 1, 0, ea_TextureFormat[i].value,
6178 ea_TextureType[i].value, buf);
6179 GLU_EXPECT_NO_ERROR(gl.getError(), "texImage3D");
6180 gl.texSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 1, 1, 1, ea_TextureFormat[i].value, ea_TextureType[i].value, buf);
6181
6182 if (gl.getError() == GL_INVALID_ENUM)
6183 {
6184 tcu_fail_msg("ApiCoverageTestCase::CallTexSubImage3D", "Invalid enums : (%s, %s)", ea_TextureFormat[i].name,
6185 ea_TextureType[i].name);
6186 success = false;
6187 }
6188
6189 gl.texImage3D(GL_TEXTURE_2D_ARRAY, 0, ea_TextureFormat[i].value, 1, 1, 1, 0, ea_TextureFormat[i].value,
6190 ea_TextureType[i].value, (const void *)NULL);
6191 GLU_EXPECT_NO_ERROR(gl.getError(), "texImage3D");
6192 gl.texSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 1, 1, 1, ea_TextureFormat[i].value, ea_TextureType[i].value,
6193 buf);
6194
6195 if (gl.getError() == GL_INVALID_ENUM)
6196 {
6197 tcu_fail_msg("ApiCoverageTestCase::CallTexSubImage3D", "Invalid enums : (%s, %s)", ea_TextureFormat[i].name,
6198 ea_TextureType[i].name);
6199 success = false;
6200 }
6201 }
6202
6203 return success;
6204 }
6205
6206 /* Coverage test for glCopyTexSubImage3D */
TestCoverageGLCallCopyTexSubImage3D(void)6207 bool ApiCoverageTestCase::TestCoverageGLCallCopyTexSubImage3D(void)
6208 {
6209 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6210 bool success = true;
6211 GLubyte buf[1000];
6212 GLint i;
6213 GLenum colorBufferFormat, targetFormats[5];
6214 GLsizei numTargetFormats;
6215
6216 (void)gl.getError(); // clear error from previous test, if any
6217
6218 colorBufferFormat = TestCoverageGLGuessColorBufferFormat();
6219 numTargetFormats = TestCoverageGLCalcTargetFormats(colorBufferFormat, targetFormats);
6220
6221 memset(buf, 0, sizeof(GLubyte) * 100);
6222
6223 for (i = 0; i != numTargetFormats; i++)
6224 {
6225 gl.texImage3D(GL_TEXTURE_3D, 0, targetFormats[i], 1, 1, 1, 0, targetFormats[i], GL_UNSIGNED_BYTE, buf);
6226 GLU_EXPECT_NO_ERROR(gl.getError(), "texImage3D");
6227 gl.copyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, 1, 1);
6228 GLU_EXPECT_NO_ERROR(gl.getError(), "copyTexSubImage3D");
6229 if (gl.getError() == GL_INVALID_ENUM)
6230 {
6231 const char *invalidEnum = glu::getTextureFormatName(targetFormats[i]);
6232 tcu_fail_msg("ApiCoverageTestCase::CallCopyTexSubImage3D", "Invalid enum : %s", invalidEnum);
6233 success = false;
6234 }
6235
6236 gl.texImage3D(GL_TEXTURE_2D_ARRAY, 0, targetFormats[i], 1, 1, 1, 0, targetFormats[i], GL_UNSIGNED_BYTE,
6237 (const void *)NULL);
6238 GLU_EXPECT_NO_ERROR(gl.getError(), "texImage3D");
6239 gl.copyTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 0, 0, 1, 1);
6240 GLU_EXPECT_NO_ERROR(gl.getError(), "copyTexSubImage3D");
6241 if (gl.getError() == GL_INVALID_ENUM)
6242 {
6243 const char *invalidEnum = glu::getTextureFormatName(targetFormats[i]);
6244 tcu_fail_msg("ApiCoverageTestCase::CallCopyTexSubImage3D", "Invalid enum : %s", invalidEnum);
6245 success = false;
6246 }
6247 }
6248
6249 return success;
6250 }
6251
6252 /* Coverage test for glCompressedTexImage3D */
TestCoverageGLCallCompressedTexImage3D(void)6253 bool ApiCoverageTestCase::TestCoverageGLCallCompressedTexImage3D(void)
6254 {
6255 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6256 bool success = true;
6257 GLubyte buf[1000];
6258 GLint i, j;
6259
6260 bool bETCSupported = false;
6261 bool bRGTCSpported = false;
6262
6263 if (!m_is_context_ES)
6264 {
6265 bETCSupported = m_context.getContextInfo().isExtensionSupported("GL_ARB_ES3_compatibility") ||
6266 glu::contextSupports(m_context_type, glu::ApiType::core(4, 3));
6267 bRGTCSpported = m_context.getContextInfo().isExtensionSupported("GL_ARB_texture_compression_rgtc") ||
6268 glu::contextSupports(m_context_type, glu::ApiType::core(3, 0));
6269 }
6270
6271 (void)gl.getError(); // clear error from previous test, if any
6272
6273 for (i = 0; ea_CompressedTexture3DTarget[i].value != -1; i++)
6274 {
6275 for (j = 0; ea_CompressedTextureFormat[j].value != -1; j++)
6276 {
6277 if (!m_is_context_ES)
6278 {
6279 if (GTF_TEXTURE_FORMAT_IS_ETC(ea_CompressedTextureFormat[j].value) && !bETCSupported)
6280 continue;
6281
6282 if (GTF_TEXTURE_FORMAT_IS_RGTC(ea_CompressedTextureFormat[j].value) && !bRGTCSpported)
6283 continue;
6284 }
6285 memset(buf, 0, 1000 * sizeof(GLubyte));
6286 gl.compressedTexImage3D(ea_CompressedTexture3DTarget[i].value, 0, ea_CompressedTextureFormat[j].value, 4, 4,
6287 1, 0, CompressedTextureSize[j], buf);
6288 if (gl.getError() == GL_INVALID_ENUM)
6289 {
6290 tcu_fail_msg("ApiCoverageTestCase::CallCompressedTexImage3D", "Invalid enums : (%s, %s)",
6291 ea_CompressedTexture3DTarget[i].name, ea_CompressedTextureFormat[j].name);
6292 success = false;
6293 }
6294
6295 gl.compressedTexImage3D(ea_CompressedTexture3DTarget[i].value, 0, ea_CompressedTextureFormat[j].value, 4, 4,
6296 1, 0, CompressedTextureSize[j], (const void *)NULL);
6297 if (gl.getError() == GL_INVALID_ENUM)
6298 {
6299 tcu_fail_msg("ApiCoverageTestCase::CallCompressedTexImage3D", "Invalid enums : (%s, %s)",
6300 ea_CompressedTexture3DTarget[i].name, ea_CompressedTextureFormat[j].name);
6301 success = false;
6302 }
6303 }
6304 }
6305 return success;
6306 }
6307
6308 /* Coverage test for glCompressedTexSubImage3D */
TestCoverageGLCallCompressedTexSubImage3D(void)6309 bool ApiCoverageTestCase::TestCoverageGLCallCompressedTexSubImage3D(void)
6310 {
6311 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6312 bool success = true;
6313 GLubyte buf[1000];
6314 GLint i, j;
6315
6316 bool bETCSupported = false;
6317 bool bRGTCSpported = false;
6318
6319 if (!m_is_context_ES)
6320 {
6321 bETCSupported = m_context.getContextInfo().isExtensionSupported("GL_ARB_ES3_compatibility") ||
6322 glu::contextSupports(m_context_type, glu::ApiType::core(4, 3));
6323 bRGTCSpported = m_context.getContextInfo().isExtensionSupported("GL_ARB_texture_compression_rgtc") ||
6324 glu::contextSupports(m_context_type, glu::ApiType::core(3, 0));
6325 }
6326
6327 (void)gl.getError(); // clear error from previous test, if any
6328
6329 for (i = 0; ea_CompressedTexture3DTarget[i].value != -1; i++)
6330 {
6331 for (j = 0; ea_CompressedTextureFormat[j].value != -1; j++)
6332 {
6333 if (!m_is_context_ES)
6334 {
6335 if (GTF_TEXTURE_FORMAT_IS_ETC(ea_CompressedTextureFormat[j].value) && !bETCSupported)
6336 continue;
6337
6338 if (GTF_TEXTURE_FORMAT_IS_RGTC(ea_CompressedTextureFormat[j].value) && !bRGTCSpported)
6339 continue;
6340 }
6341 memset(buf, 0, 1000 * sizeof(GLubyte));
6342 gl.compressedTexImage3D(ea_CompressedTexture3DTarget[i].value, 0, ea_CompressedTextureFormat[j].value, 4, 4,
6343 1, 0, CompressedTextureSize[j], buf);
6344 gl.compressedTexSubImage3D(ea_CompressedTexture3DTarget[i].value, 0, 0, 0, 0, 4, 4, 1,
6345 ea_CompressedTextureFormat[j].value, CompressedTextureSize[j], buf);
6346 if (gl.getError() == GL_INVALID_ENUM)
6347 {
6348 tcu_fail_msg("ApiCoverageTestCase::CallCompressedTexSubImage3D", "Invalid enums : (%s, %s)",
6349 ea_CompressedTexture3DTarget[i].name, ea_CompressedTextureFormat[j].name);
6350 success = false;
6351 }
6352 }
6353 }
6354
6355 return success;
6356 }
6357
6358 /* Coverage test for glGenQueries */
TestCoverageGLCallGenQueries(void)6359 bool ApiCoverageTestCase::TestCoverageGLCallGenQueries(void)
6360 {
6361 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6362 GLuint q[2];
6363 bool success = true;
6364
6365 (void)gl.getError(); // clear error from previous test, if any
6366
6367 gl.genQueries(2, q);
6368 GLU_EXPECT_NO_ERROR(gl.getError(), "genQueries");
6369
6370 if (gl.getError() != GL_NO_ERROR)
6371 {
6372 tcu_fail_msg("ApiCoverageTestCase::GenQueries", "Failed.");
6373 success = false;
6374 }
6375 gl.deleteQueries(2, q);
6376 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteQueries");
6377
6378 return success;
6379 }
6380
6381 /* Coverage test for glDeleteQueries */
TestCoverageGLCallDeleteQueries(void)6382 bool ApiCoverageTestCase::TestCoverageGLCallDeleteQueries(void)
6383 {
6384 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6385 GLuint q[2];
6386 bool success = true;
6387
6388 (void)gl.getError(); // clear error from previous test, if any
6389
6390 gl.genQueries(2, q);
6391 GLU_EXPECT_NO_ERROR(gl.getError(), "genQueries");
6392 if (gl.getError() != GL_NO_ERROR)
6393 {
6394 tcu_fail_msg("ApiCoverageTestCase::GenQueries", "Failed to create a query object.");
6395 success = false;
6396 }
6397
6398 gl.deleteQueries(2, q);
6399 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteQueries");
6400 if (gl.getError() != GL_NO_ERROR)
6401 {
6402 tcu_fail_msg("ApiCoverageTestCase::DeleteQueries", "Failed to deleate a query object.");
6403 success = false;
6404 }
6405
6406 return success;
6407 }
6408
6409 /* Coverage test for glIsQuery */
TestCoverageGLCallIsQuery(void)6410 bool ApiCoverageTestCase::TestCoverageGLCallIsQuery(void)
6411 {
6412 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6413 GLuint q[2];
6414 bool success = true;
6415
6416 (void)gl.getError(); // clear error from previous test, if any
6417
6418 gl.genQueries(2, q);
6419 GLU_EXPECT_NO_ERROR(gl.getError(), "genQueries");
6420 if (gl.getError() != GL_NO_ERROR)
6421 {
6422 tcu_fail_msg("ApiCoverageTestCase::IsQuery", "Failed to create a query object.");
6423 success = false;
6424 }
6425
6426 if (gl.isQuery(0) == GL_TRUE)
6427 {
6428 tcu_fail_msg("ApiCoverageTestCase::IsQuery", "Failed on id 0.");
6429 success = false;
6430 }
6431 if (gl.isQuery(q[0]) == GL_TRUE)
6432 {
6433 tcu_fail_msg("ApiCoverageTestCase::IsQuery", "Failed on id %d.", q[0]);
6434 success = false;
6435 }
6436
6437 gl.beginQuery(GL_ANY_SAMPLES_PASSED, q[0]);
6438 GLU_EXPECT_NO_ERROR(gl.getError(), "beginQuery");
6439 if (gl.isQuery(q[0]) == GL_FALSE)
6440 {
6441 tcu_fail_msg("ApiCoverageTestCase::IsQuery", "Failed on id %d.", q[0]);
6442 success = false;
6443 }
6444 gl.endQuery(GL_ANY_SAMPLES_PASSED);
6445 GLU_EXPECT_NO_ERROR(gl.getError(), "endQuery");
6446
6447 gl.deleteQueries(2, q);
6448 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteQueries");
6449
6450 return success;
6451 }
6452
6453 /* Coverage test for glBeginQuery */
TestCoverageGLCallBeginQuery(void)6454 bool ApiCoverageTestCase::TestCoverageGLCallBeginQuery(void)
6455 {
6456 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6457 GLuint q[2], result = 0;
6458 bool success = true;
6459
6460 (void)gl.getError(); // clear error from previous test, if any
6461
6462 gl.genQueries(2, q);
6463 GLU_EXPECT_NO_ERROR(gl.getError(), "genQueries");
6464 if (gl.getError() != GL_NO_ERROR)
6465 {
6466 tcu_fail_msg("ApiCoverageTestCase::BeginQuery", "Failed to create a query object.");
6467 success = false;
6468 }
6469
6470 gl.beginQuery(GL_ANY_SAMPLES_PASSED, q[0]);
6471 GLU_EXPECT_NO_ERROR(gl.getError(), "beginQuery");
6472
6473 if (gl.getError() != GL_NO_ERROR)
6474 {
6475 tcu_fail_msg("ApiCoverageTestCase::BeginQuery", "Failed to begin query.");
6476 success = false;
6477 }
6478
6479 gl.clear(GL_COLOR_BUFFER_BIT);
6480 GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
6481 gl.endQuery(GL_ANY_SAMPLES_PASSED);
6482 GLU_EXPECT_NO_ERROR(gl.getError(), "endQuery");
6483 gl.finish();
6484 GLU_EXPECT_NO_ERROR(gl.getError(), "finish");
6485 gl.getQueryObjectuiv(q[0], GL_QUERY_RESULT, &result);
6486 GLU_EXPECT_NO_ERROR(gl.getError(), "getQueryObjectuiv");
6487 gl.deleteQueries(2, q);
6488 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteQueries");
6489
6490 return success;
6491 }
6492
6493 /* Coverage test for glEndQuery */
TestCoverageGLCallEndQuery(void)6494 bool ApiCoverageTestCase::TestCoverageGLCallEndQuery(void)
6495 {
6496 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6497 GLuint q[2], result = 0;
6498 bool success = true;
6499
6500 (void)gl.getError(); // clear error from previous test, if any
6501
6502 gl.genQueries(2, q);
6503 GLU_EXPECT_NO_ERROR(gl.getError(), "genQueries");
6504 if (gl.getError() != GL_NO_ERROR)
6505 {
6506 tcu_fail_msg("ApiCoverageTestCase::EndQuery", "Failed to create a query object.");
6507 success = false;
6508 }
6509
6510 gl.beginQuery(GL_ANY_SAMPLES_PASSED, q[0]);
6511 GLU_EXPECT_NO_ERROR(gl.getError(), "beginQuery");
6512
6513 if (gl.getError() != GL_NO_ERROR)
6514 {
6515 tcu_fail_msg("ApiCoverageTestCase::EndQuery", "Failed to begin query.");
6516 success = false;
6517 }
6518
6519 gl.clear(GL_COLOR_BUFFER_BIT);
6520 GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
6521 (void)gl.getError();
6522
6523 gl.endQuery(GL_ANY_SAMPLES_PASSED);
6524 GLU_EXPECT_NO_ERROR(gl.getError(), "endQuery");
6525
6526 if (gl.getError() != GL_NO_ERROR)
6527 {
6528 tcu_fail_msg("ApiCoverageTestCase::EndQuery", "Failed to end query.");
6529 success = false;
6530 }
6531
6532 gl.getQueryObjectuiv(q[0], GL_QUERY_RESULT, &result);
6533 GLU_EXPECT_NO_ERROR(gl.getError(), "getQueryObjectuiv");
6534 gl.deleteQueries(2, q);
6535 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteQueries");
6536
6537 return success;
6538 }
6539
6540 /* Coverage test for glGetQueryiv */
TestCoverageGLCallGetQueryiv(void)6541 bool ApiCoverageTestCase::TestCoverageGLCallGetQueryiv(void)
6542 {
6543 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6544 GLuint q[2] = {0, 0};
6545 GLint iresult = 0;
6546 GLuint uresult = 0;
6547 bool success = true;
6548
6549 (void)gl.getError(); // clear error from previous test, if any
6550
6551 gl.genQueries(2, q);
6552 GLU_EXPECT_NO_ERROR(gl.getError(), "genQueries");
6553 if (gl.getError() != GL_NO_ERROR)
6554 {
6555 tcu_fail_msg("ApiCoverageTestCase::GetQueryiv", "Failed to create a query object.");
6556 success = false;
6557 }
6558
6559 gl.beginQuery(GL_ANY_SAMPLES_PASSED, q[0]);
6560 GLU_EXPECT_NO_ERROR(gl.getError(), "beginQuery");
6561 gl.clear(GL_COLOR_BUFFER_BIT);
6562 GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
6563 (void)gl.getError();
6564
6565 gl.getQueryiv(GL_ANY_SAMPLES_PASSED, GL_CURRENT_QUERY, &iresult);
6566 GLU_EXPECT_NO_ERROR(gl.getError(), "getQueryiv");
6567 if (gl.getError() != GL_NO_ERROR)
6568 {
6569 tcu_fail_msg("ApiCoverageTestCase::GetQueryiv", "Failed to get active query object.");
6570 success = false;
6571 }
6572
6573 gl.endQuery(GL_ANY_SAMPLES_PASSED);
6574 GLU_EXPECT_NO_ERROR(gl.getError(), "endQuery");
6575 gl.getQueryObjectuiv(q[0], GL_QUERY_RESULT, &uresult);
6576 GLU_EXPECT_NO_ERROR(gl.getError(), "getQueryObjectuiv");
6577 gl.deleteQueries(2, q);
6578 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteQueries");
6579
6580 return success;
6581 }
6582
6583 /* Coverage test for glGetQueryObjectuiv */
TestCoverageGLCallGetQueryObjectuiv(void)6584 bool ApiCoverageTestCase::TestCoverageGLCallGetQueryObjectuiv(void)
6585 {
6586 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6587 GLuint q[2], result = 0;
6588 bool success = true;
6589
6590 (void)gl.getError(); // clear error from previous test, if any
6591
6592 gl.genQueries(2, q);
6593 GLU_EXPECT_NO_ERROR(gl.getError(), "genQueries");
6594 if (gl.getError() != GL_NO_ERROR)
6595 {
6596 tcu_fail_msg("ApiCoverageTestCase::GetQueryiv", "Failed to create a query object.");
6597 success = false;
6598 }
6599
6600 gl.beginQuery(GL_ANY_SAMPLES_PASSED, q[0]);
6601 GLU_EXPECT_NO_ERROR(gl.getError(), "beginQuery");
6602 gl.clear(GL_COLOR_BUFFER_BIT);
6603 GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
6604 gl.endQuery(GL_ANY_SAMPLES_PASSED);
6605 GLU_EXPECT_NO_ERROR(gl.getError(), "endQuery");
6606 (void)gl.getError();
6607
6608 gl.getQueryObjectuiv(q[0], GL_QUERY_RESULT, &result);
6609 GLU_EXPECT_NO_ERROR(gl.getError(), "getQueryObjectuiv");
6610 if (gl.getError() != GL_NO_ERROR)
6611 {
6612 tcu_fail_msg("ApiCoverageTestCase::GetQueryObjectuiv", "Failed to get query result.");
6613 success = false;
6614 }
6615
6616 gl.deleteQueries(2, q);
6617 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteQueries");
6618
6619 return success;
6620 }
6621
6622 /* Coverage test for glGetBufferPointerv */
TestCoverageGLCallGetBufferPointerv(void)6623 bool ApiCoverageTestCase::TestCoverageGLCallGetBufferPointerv(void)
6624 {
6625 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6626 bool success = true;
6627 GLuint BufObj, tfObj, size = 4096;
6628 float *pMappedTFBuf;
6629 static GLfloat position[] = {
6630 -0.5f, -0.625f, 0.5f, 1.0f, 0.125f, 0.75f, 0.625f, 1.125f, 0.875f, -0.75f, 1.125f, 1.5f,
6631 };
6632
6633 (void)gl.getError(); // clear error from previous test, if any
6634
6635 GLuint vbo = 0;
6636 gl.genBuffers(1, &vbo);
6637 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
6638 gl.bindBuffer(GL_ARRAY_BUFFER, vbo);
6639 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");
6640 gl.bufferData(GL_ARRAY_BUFFER, sizeof(position), (GLvoid *)position, GL_STATIC_DRAW);
6641 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");
6642
6643 GLuint vao = 0;
6644 gl.genVertexArrays(1, &vao);
6645 GLU_EXPECT_NO_ERROR(gl.getError(), "genVertexArrays");
6646 gl.bindVertexArray(vao);
6647 GLU_EXPECT_NO_ERROR(gl.getError(), "bindVertexArray");
6648 gl.enableVertexAttribArray(0);
6649 GLU_EXPECT_NO_ERROR(gl.getError(), "enableVertexAttribArray");
6650 gl.vertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, nullptr);
6651 GLU_EXPECT_NO_ERROR(gl.getError(), "vertexAttribPointer");
6652 if (m_is_transform_feedback_obj_supported)
6653 {
6654 gl.genTransformFeedbacks(1, &tfObj);
6655 GLU_EXPECT_NO_ERROR(gl.getError(), "genTransformFeedbacks");
6656 gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfObj);
6657 GLU_EXPECT_NO_ERROR(gl.getError(), "bindTransformFeedback");
6658 }
6659
6660 gl.genBuffers(1, &BufObj);
6661 GLU_EXPECT_NO_ERROR(gl.getError(), "genBuffers");
6662 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, BufObj);
6663 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBufferBase");
6664 gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 4096, NULL, GL_DYNAMIC_READ);
6665 GLU_EXPECT_NO_ERROR(gl.getError(), "bufferData");
6666 pMappedTFBuf = (float *)glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, size, GL_MAP_READ_BIT);
6667
6668 if (gl.getError() != GL_NO_ERROR)
6669 {
6670 tcu_fail_msg("ApiCoverageTestCase::GetBufferPointerv", "Setup Failed.");
6671 success = false;
6672 }
6673
6674 gl.getBufferPointerv(GL_TRANSFORM_FEEDBACK_BUFFER, GL_BUFFER_MAP_POINTER, (GLvoid **)(&pMappedTFBuf));
6675 GLU_EXPECT_NO_ERROR(gl.getError(), "getBufferPointerv");
6676 if (pMappedTFBuf == NULL || gl.getError() != GL_NO_ERROR)
6677 {
6678 tcu_fail_msg("ApiCoverageTestCase::GetBufferPointerv", "Failed.");
6679 success = false;
6680 }
6681
6682 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
6683 GLU_EXPECT_NO_ERROR(gl.getError(), "unmapBuffer");
6684 gl.deleteBuffers(1, &BufObj);
6685 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
6686 if (m_is_transform_feedback_obj_supported)
6687 {
6688 gl.deleteTransformFeedbacks(1, &tfObj);
6689 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteTransformFeedbacks");
6690 }
6691
6692 gl.disableVertexAttribArray(0);
6693 GLU_EXPECT_NO_ERROR(gl.getError(), "glDisableVertexAttribArray");
6694
6695 if (vbo)
6696 {
6697 gl.deleteBuffers(1, &vbo);
6698 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers");
6699 }
6700
6701 if (vao)
6702 {
6703 gl.deleteVertexArrays(1, &vao);
6704 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteVertexArrays");
6705 }
6706
6707 return success;
6708 }
6709
6710 /* Coverage test for glMapBufferRange */
TestCoverageGLCallMapBufferRange(void)6711 bool ApiCoverageTestCase::TestCoverageGLCallMapBufferRange(void)
6712 {
6713 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6714 bool success = true;
6715 GLuint BufObj, tfObj, size = 4096;
6716 float *pMappedTFBuf;
6717 static GLfloat position[] = {
6718 -0.5f, -0.625f, 0.5f, 1.0f, 0.125f, 0.75f, 0.625f, 1.125f, 0.875f, -0.75f, 1.125f, 1.5f,
6719 };
6720
6721 (void)gl.getError(); // clear error from previous test, if any
6722
6723 GLuint vbo = 0;
6724 gl.genBuffers(1, &vbo);
6725 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
6726 gl.bindBuffer(GL_ARRAY_BUFFER, vbo);
6727 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");
6728 gl.bufferData(GL_ARRAY_BUFFER, sizeof(position), (GLvoid *)position, GL_STATIC_DRAW);
6729 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");
6730
6731 GLuint vao = 0;
6732 gl.genVertexArrays(1, &vao);
6733 GLU_EXPECT_NO_ERROR(gl.getError(), "genVertexArrays");
6734 gl.bindVertexArray(vao);
6735 GLU_EXPECT_NO_ERROR(gl.getError(), "bindVertexArray");
6736
6737 gl.enableVertexAttribArray(0);
6738 GLU_EXPECT_NO_ERROR(gl.getError(), "enableVertexAttribArray");
6739 gl.vertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, nullptr);
6740 GLU_EXPECT_NO_ERROR(gl.getError(), "vertexAttribPointer");
6741 if (m_is_transform_feedback_obj_supported)
6742 {
6743 gl.genTransformFeedbacks(1, &tfObj);
6744 GLU_EXPECT_NO_ERROR(gl.getError(), "genTransformFeedbacks");
6745 gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfObj);
6746 GLU_EXPECT_NO_ERROR(gl.getError(), "bindTransformFeedback");
6747 }
6748 gl.genBuffers(1, &BufObj);
6749 GLU_EXPECT_NO_ERROR(gl.getError(), "genBuffers");
6750 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, BufObj);
6751 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBufferBase");
6752 gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 4096, NULL, GL_DYNAMIC_READ);
6753 GLU_EXPECT_NO_ERROR(gl.getError(), "bufferData");
6754
6755 if (gl.getError() != GL_NO_ERROR)
6756 {
6757 tcu_fail_msg("ApiCoverageTestCase::MapBufferRange", "Setup Failed.");
6758 success = false;
6759 }
6760
6761 pMappedTFBuf = (float *)glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, size, GL_MAP_READ_BIT);
6762 if (pMappedTFBuf == NULL || gl.getError() != GL_NO_ERROR)
6763 {
6764 tcu_fail_msg("ApiCoverageTestCase::MapBufferRange", "Failed.");
6765 success = false;
6766 }
6767
6768 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
6769 GLU_EXPECT_NO_ERROR(gl.getError(), "unmapBuffer");
6770 gl.deleteBuffers(1, &BufObj);
6771 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
6772 if (m_is_transform_feedback_obj_supported)
6773 {
6774 gl.deleteTransformFeedbacks(1, &tfObj);
6775 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteTransformFeedbacks");
6776 }
6777
6778 if (vbo)
6779 {
6780 gl.deleteBuffers(1, &vbo);
6781 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers");
6782 }
6783
6784 if (vao)
6785 {
6786 gl.deleteVertexArrays(1, &vao);
6787 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteVertexArrays");
6788 }
6789
6790 return success;
6791 }
6792 /* Coverage test for glUnmapBuffer */
TestCoverageGLCallUnmapBuffer(void)6793 bool ApiCoverageTestCase::TestCoverageGLCallUnmapBuffer(void)
6794 {
6795 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6796 bool success = true;
6797 GLuint BufObj, tfObj, size = 4096;
6798 static GLfloat position[] = {
6799 -0.5f, -0.625f, 0.5f, 1.0f, 0.125f, 0.75f, 0.625f, 1.125f, 0.875f, -0.75f, 1.125f, 1.5f,
6800 };
6801
6802 (void)gl.getError(); // clear error from previous test, if any
6803
6804 GLuint vbo = 0;
6805 gl.genBuffers(1, &vbo);
6806 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
6807 gl.bindBuffer(GL_ARRAY_BUFFER, vbo);
6808 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");
6809 gl.bufferData(GL_ARRAY_BUFFER, sizeof(position), (GLvoid *)position, GL_STATIC_DRAW);
6810 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");
6811
6812 GLuint vao = 0;
6813 gl.genVertexArrays(1, &vao);
6814 GLU_EXPECT_NO_ERROR(gl.getError(), "genVertexArrays");
6815 gl.bindVertexArray(vao);
6816 GLU_EXPECT_NO_ERROR(gl.getError(), "bindVertexArray");
6817 gl.enableVertexAttribArray(0);
6818 GLU_EXPECT_NO_ERROR(gl.getError(), "enableVertexAttribArray");
6819 gl.vertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, nullptr);
6820 GLU_EXPECT_NO_ERROR(gl.getError(), "vertexAttribPointer");
6821 if (m_is_transform_feedback_obj_supported)
6822 {
6823 gl.genTransformFeedbacks(1, &tfObj);
6824 GLU_EXPECT_NO_ERROR(gl.getError(), "genTransformFeedbacks");
6825 gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfObj);
6826 GLU_EXPECT_NO_ERROR(gl.getError(), "bindTransformFeedback");
6827 }
6828 gl.genBuffers(1, &BufObj);
6829 GLU_EXPECT_NO_ERROR(gl.getError(), "genBuffers");
6830 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, BufObj);
6831 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBufferBase");
6832 gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 4096, NULL, GL_DYNAMIC_READ);
6833 GLU_EXPECT_NO_ERROR(gl.getError(), "bufferData");
6834 float *pMappedTFBuf = (float *)glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, size, GL_MAP_READ_BIT);
6835
6836 if (gl.getError() != GL_NO_ERROR || pMappedTFBuf == nullptr)
6837 {
6838 tcu_fail_msg("ApiCoverageTestCase::UnmapBuffer", "Setup Failed.");
6839 success = false;
6840 }
6841
6842 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
6843 GLU_EXPECT_NO_ERROR(gl.getError(), "unmapBuffer");
6844 if (gl.getError() != GL_NO_ERROR)
6845 {
6846 tcu_fail_msg("ApiCoverageTestCase::UnmapBuffer", "Failed.");
6847 success = false;
6848 }
6849
6850 gl.disableVertexAttribArray(0);
6851 GLU_EXPECT_NO_ERROR(gl.getError(), "glDisableVertexAttribArray");
6852
6853 gl.deleteBuffers(1, &BufObj);
6854 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
6855 if (m_is_transform_feedback_obj_supported)
6856 {
6857 gl.deleteTransformFeedbacks(1, &tfObj);
6858 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteTransformFeedbacks");
6859 }
6860
6861 if (vbo)
6862 {
6863 gl.deleteBuffers(1, &vbo);
6864 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers");
6865 }
6866
6867 if (vao)
6868 {
6869 gl.deleteVertexArrays(1, &vao);
6870 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteVertexArrays");
6871 }
6872
6873 return success;
6874 }
6875
6876 /* Coverage test for glFlushMappedBufferRange */
TestCoverageGLCallFlushMappedBufferRange(void)6877 bool ApiCoverageTestCase::TestCoverageGLCallFlushMappedBufferRange(void)
6878 {
6879 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6880 bool success = true;
6881 GLuint BufObj, tfObj, size = 4096;
6882 static GLfloat position[] = {
6883 -0.5f, -0.625f, 0.5f, 1.0f, 0.125f, 0.75f, 0.625f, 1.125f, 0.875f, -0.75f, 1.125f, 1.5f,
6884 };
6885
6886 (void)gl.getError(); // clear error from previous test, if any
6887
6888 GLuint vbo = 0;
6889 gl.genBuffers(1, &vbo);
6890 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
6891 gl.bindBuffer(GL_ARRAY_BUFFER, vbo);
6892 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");
6893 gl.bufferData(GL_ARRAY_BUFFER, sizeof(position), (GLvoid *)position, GL_STATIC_DRAW);
6894 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");
6895
6896 GLuint vao = 0;
6897 gl.genVertexArrays(1, &vao);
6898 GLU_EXPECT_NO_ERROR(gl.getError(), "genVertexArrays");
6899 gl.bindVertexArray(vao);
6900 GLU_EXPECT_NO_ERROR(gl.getError(), "bindVertexArray");
6901
6902 gl.enableVertexAttribArray(0);
6903 GLU_EXPECT_NO_ERROR(gl.getError(), "enableVertexAttribArray");
6904 gl.vertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, nullptr);
6905 GLU_EXPECT_NO_ERROR(gl.getError(), "vertexAttribPointer");
6906 if (m_is_transform_feedback_obj_supported)
6907 {
6908 gl.genTransformFeedbacks(1, &tfObj);
6909 GLU_EXPECT_NO_ERROR(gl.getError(), "genTransformFeedbacks");
6910 gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfObj);
6911 GLU_EXPECT_NO_ERROR(gl.getError(), "bindTransformFeedback");
6912 }
6913 gl.genBuffers(1, &BufObj);
6914 GLU_EXPECT_NO_ERROR(gl.getError(), "genBuffers");
6915 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, BufObj);
6916 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBufferBase");
6917 gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 4096, NULL, GL_DYNAMIC_READ);
6918 GLU_EXPECT_NO_ERROR(gl.getError(), "bufferData");
6919 float *pMappedTFBuf = (float *)glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, size,
6920 GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
6921
6922 if (gl.getError() != GL_NO_ERROR || pMappedTFBuf == nullptr)
6923 {
6924 tcu_fail_msg("ApiCoverageTestCase::FlushMappedBufferRange", "Setup Failed.");
6925 success = false;
6926 }
6927
6928 gl.flushMappedBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, size);
6929 GLU_EXPECT_NO_ERROR(gl.getError(), "flushMappedBufferRange");
6930 if (gl.getError() != GL_NO_ERROR)
6931 {
6932 tcu_fail_msg("ApiCoverageTestCase::FlushMappedBufferRange", "Failed.");
6933 success = false;
6934 }
6935
6936 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
6937 GLU_EXPECT_NO_ERROR(gl.getError(), "unmapBuffer");
6938 gl.deleteBuffers(1, &BufObj);
6939 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
6940 if (m_is_transform_feedback_obj_supported)
6941 {
6942 gl.deleteTransformFeedbacks(1, &tfObj);
6943 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteTransformFeedbacks");
6944 }
6945
6946 if (vbo)
6947 {
6948 gl.deleteBuffers(1, &vbo);
6949 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers");
6950 }
6951
6952 if (vao)
6953 {
6954 gl.deleteVertexArrays(1, &vao);
6955 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteVertexArrays");
6956 }
6957
6958 return success;
6959 }
6960
6961 /* Coverage test for glDrawBuffers */
TestCoverageGLCallDrawBuffers(void)6962 bool ApiCoverageTestCase::TestCoverageGLCallDrawBuffers(void)
6963 {
6964 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
6965 GLuint i;
6966 bool success = true;
6967 GLenum bufs[4];
6968 GLint width = 32, height = 32;
6969 GLuint fbo = 0, rbo_color[4] = {0, 0, 0, 0};
6970
6971 (void)gl.getError(); // clear error from previous test, if any
6972
6973 gl.genFramebuffers(1, &fbo);
6974 GLU_EXPECT_NO_ERROR(gl.getError(), "genFramebuffers");
6975 gl.bindFramebuffer(GL_FRAMEBUFFER, fbo);
6976 GLU_EXPECT_NO_ERROR(gl.getError(), "bindFramebuffer");
6977 gl.genRenderbuffers(4, rbo_color);
6978 GLU_EXPECT_NO_ERROR(gl.getError(), "genRenderbuffers");
6979
6980 // attach RBOs
6981 for (i = 0; ea_DrawBuffers[i].value != -1; i++)
6982 {
6983 gl.bindRenderbuffer(GL_RENDERBUFFER, rbo_color[i]);
6984 GLU_EXPECT_NO_ERROR(gl.getError(), "bindRenderbuffer");
6985 gl.renderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, width, height);
6986 GLU_EXPECT_NO_ERROR(gl.getError(), "renderbufferStorage");
6987 gl.framebufferRenderbuffer(GL_FRAMEBUFFER, ea_DrawBuffers[i].value, GL_RENDERBUFFER, rbo_color[i]);
6988 GLU_EXPECT_NO_ERROR(gl.getError(), "framebufferRenderbuffer");
6989 }
6990
6991 if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
6992 {
6993 tcu_fail_msg("ApiCoverageTestCase::DrawBuffers", "Expected GL_FRAMEBUFFER_COMPLETE.");
6994 gl.deleteFramebuffers(1, &fbo);
6995 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteFramebuffers");
6996 return false;
6997 }
6998
6999 GLuint dbuffer = 0;
7000 gl.drawBuffers(1, &dbuffer);
7001 GLU_EXPECT_NO_ERROR(gl.getError(), "drawBuffers");
7002
7003 ea_DrawBuffers[0].value = (GLint)dbuffer;
7004 if (gl.getError() != GL_NO_ERROR)
7005 {
7006 tcu_fail_msg("ApiCoverageTestCase::DrawBuffers", "Failed %s.", ea_DrawBuffers[i].name);
7007 success = false;
7008 }
7009
7010 for (i = 0; ea_DrawBuffers[i].value != -1; i++)
7011 {
7012 bufs[i] = ea_DrawBuffers[i].value;
7013 }
7014
7015 gl.drawBuffers(4, bufs);
7016 GLU_EXPECT_NO_ERROR(gl.getError(), "drawBuffers");
7017 if (gl.getError() != GL_NO_ERROR)
7018 {
7019 tcu_fail_msg("ApiCoverageTestCase::DrawBuffers", "Failed on 4 concurrent buffers.");
7020 success = false;
7021 }
7022
7023 gl.deleteFramebuffers(1, &fbo);
7024 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteFramebuffers");
7025
7026 gl.deleteRenderbuffers(4, rbo_color);
7027 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteRenderbuffers");
7028
7029 return success;
7030 }
7031 /* Coverage test for glUniformMatrix2x4fv */
7032
TestCoverageGLCallUniformMatrix2x4fv(void)7033 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix2x4fv(void)
7034 {
7035 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7036 bool success = true;
7037 GLint program;
7038 GLfloat v[] = {
7039 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,
7040 };
7041
7042 (void)gl.getError(); // clear error from previous test, if any
7043
7044 program = createDefaultProgram(0);
7045 gl.uniformMatrix2x3fv(0, 1, GL_FALSE, v);
7046
7047 // not a valid config for uniforms
7048 if (gl.getError() != GL_INVALID_OPERATION)
7049 {
7050 tcu_fail_msg("ApiCoverageTestCase::UniformMatrix2x4fv", "Failed.");
7051 success = false;
7052 }
7053
7054 gl.deleteProgram((GLuint)program);
7055 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
7056
7057 return success;
7058 }
7059
7060 /* Coverage test for glBeginTransformFeedback */
TestCoverageGLCallBeginTransformFeedback(void)7061 bool ApiCoverageTestCase::TestCoverageGLCallBeginTransformFeedback(void)
7062 {
7063 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7064 bool success = true;
7065 GLint program;
7066 GLuint tobj = 0, tbufobj = 0;
7067
7068 (void)gl.getError(); // clear error from previous test, if any
7069
7070 program = createDefaultProgram(1);
7071
7072 if (program == -1)
7073 {
7074 tcu_fail_msg("ApiCoverageTestCase::BeginTransformFeedback", "Program create Failed");
7075 return false;
7076 }
7077
7078 if (m_is_transform_feedback_obj_supported)
7079 {
7080 gl.genTransformFeedbacks(1, &tobj);
7081 GLU_EXPECT_NO_ERROR(gl.getError(), "genTransformFeedbacks");
7082 gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, tobj);
7083 GLU_EXPECT_NO_ERROR(gl.getError(), "bindTransformFeedback");
7084 }
7085 gl.genBuffers(1, &tbufobj);
7086 GLU_EXPECT_NO_ERROR(gl.getError(), "genBuffers");
7087 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tbufobj);
7088 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBufferBase");
7089
7090 if (gl.getError() != GL_NO_ERROR)
7091 {
7092 tcu_fail_msg("ApiCoverageTestCase::BeginTransformFeedback", "Failed to create transform feedback buffer.");
7093 success = false;
7094 }
7095
7096 gl.beginTransformFeedback(GL_TRIANGLES);
7097 GLU_EXPECT_NO_ERROR(gl.getError(), "beginTransformFeedback");
7098
7099 if (gl.getError() != GL_NO_ERROR)
7100 {
7101 tcu_fail_msg("ApiCoverageTestCase::BeginTransformFeedback", "Failed.");
7102 success = false;
7103 }
7104
7105 gl.endTransformFeedback();
7106 GLU_EXPECT_NO_ERROR(gl.getError(), "endTransformFeedback");
7107
7108 gl.deleteBuffers(1, &tbufobj);
7109 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
7110 if (m_is_transform_feedback_obj_supported)
7111 {
7112 gl.deleteTransformFeedbacks(1, &tobj);
7113 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteTransformFeedbacks");
7114 }
7115 gl.deleteProgram((GLuint)program);
7116 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
7117
7118 return success;
7119 }
7120
7121 /* Coverage test for glEndTransformFeedback */
TestCoverageGLCallEndTransformFeedback(void)7122 bool ApiCoverageTestCase::TestCoverageGLCallEndTransformFeedback(void)
7123 {
7124 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7125 bool success = true;
7126 GLint program = 0;
7127 GLuint tobj = 0, tbufobj = 0;
7128
7129 (void)gl.getError(); // clear error from previous test, if any
7130
7131 program = createDefaultProgram(1);
7132
7133 if (program == -1)
7134 {
7135 tcu_fail_msg("ApiCoverageTestCase::EndTransformFeedback", "Program create Failed");
7136 return false;
7137 }
7138
7139 if (m_is_transform_feedback_obj_supported)
7140 {
7141 gl.genTransformFeedbacks(1, &tobj);
7142 GLU_EXPECT_NO_ERROR(gl.getError(), "genTransformFeedbacks");
7143 gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, tobj);
7144 GLU_EXPECT_NO_ERROR(gl.getError(), "bindTransformFeedback");
7145 }
7146 gl.genBuffers(1, &tbufobj);
7147 GLU_EXPECT_NO_ERROR(gl.getError(), "genBuffers");
7148 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tbufobj);
7149 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBufferBase");
7150
7151 if (gl.getError() != GL_NO_ERROR)
7152 {
7153 tcu_fail_msg("ApiCoverageTestCase::EndTransformFeedback", "Failed to create transform feedback buffer.");
7154 success = false;
7155 }
7156
7157 gl.beginTransformFeedback(GL_TRIANGLES);
7158 GLU_EXPECT_NO_ERROR(gl.getError(), "beginTransformFeedback");
7159
7160 if (gl.getError() != GL_NO_ERROR)
7161 {
7162 tcu_fail_msg("ApiCoverageTestCase::EndTransformFeedback", "Failed to start.");
7163 success = false;
7164 }
7165
7166 gl.endTransformFeedback();
7167 GLU_EXPECT_NO_ERROR(gl.getError(), "endTransformFeedback");
7168
7169 if (gl.getError() != GL_NO_ERROR)
7170 {
7171 tcu_fail_msg("ApiCoverageTestCase::EndTransformFeedback", "Failed.");
7172 success = false;
7173 }
7174
7175 gl.deleteBuffers(1, &tbufobj);
7176 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
7177 if (m_is_transform_feedback_obj_supported)
7178 {
7179 gl.deleteTransformFeedbacks(1, &tobj);
7180 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteTransformFeedbacks");
7181 }
7182 gl.deleteProgram((GLuint)program);
7183 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
7184
7185 return success;
7186 }
7187
7188 /* Coverage test for glBindBufferRange */
TestCoverageGLCallBindBufferRange(void)7189 bool ApiCoverageTestCase::TestCoverageGLCallBindBufferRange(void)
7190 {
7191 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7192 bool success = true;
7193 GLuint tobj = 0, tbufobj = 0;
7194 char data[16];
7195
7196 (void)gl.getError(); // clear error from previous test, if any
7197
7198 if (m_is_transform_feedback_obj_supported)
7199 {
7200 gl.genTransformFeedbacks(1, &tobj);
7201 GLU_EXPECT_NO_ERROR(gl.getError(), "genTransformFeedbacks");
7202 gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, tobj);
7203 GLU_EXPECT_NO_ERROR(gl.getError(), "bindTransformFeedback");
7204 }
7205 gl.genBuffers(1, &tbufobj);
7206 GLU_EXPECT_NO_ERROR(gl.getError(), "genBuffers");
7207 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tbufobj);
7208 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBufferBase");
7209 gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, data, GL_DYNAMIC_READ);
7210 GLU_EXPECT_NO_ERROR(gl.getError(), "bufferData");
7211
7212 if (gl.getError() != GL_NO_ERROR)
7213 {
7214 tcu_fail_msg("ApiCoverageTestCase::BindBufferRange", "Failed to create transform feedback buffer.");
7215 success = false;
7216 }
7217
7218 gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 1, tbufobj, 0, 4);
7219 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBufferRange");
7220
7221 if (gl.getError() != GL_NO_ERROR)
7222 {
7223 tcu_fail_msg("ApiCoverageTestCase::BindBufferRange", "Failed.");
7224 success = false;
7225 }
7226
7227 gl.deleteBuffers(1, &tbufobj);
7228 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
7229 if (m_is_transform_feedback_obj_supported)
7230 {
7231 gl.deleteTransformFeedbacks(1, &tobj);
7232 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteTransformFeedbacks");
7233 }
7234
7235 return success;
7236 }
7237
7238 /* Coverage test for glBindBufferBase */
TestCoverageGLCallBindBufferBase(void)7239 bool ApiCoverageTestCase::TestCoverageGLCallBindBufferBase(void)
7240 {
7241 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7242 bool success = true;
7243 GLuint tobj = 0, tbufobj = 0;
7244
7245 (void)gl.getError(); // clear error from previous test, if any
7246
7247 if (m_is_transform_feedback_obj_supported)
7248 {
7249 gl.genTransformFeedbacks(1, &tobj);
7250 GLU_EXPECT_NO_ERROR(gl.getError(), "genTransformFeedbacks");
7251 gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, tobj);
7252 GLU_EXPECT_NO_ERROR(gl.getError(), "bindTransformFeedback");
7253 }
7254 gl.genBuffers(1, &tbufobj);
7255 GLU_EXPECT_NO_ERROR(gl.getError(), "genBuffers");
7256
7257 if (gl.getError() != GL_NO_ERROR)
7258 {
7259 tcu_fail_msg("ApiCoverageTestCase::BindBufferBase", "Failed to create transform feedback buffer.");
7260 success = false;
7261 }
7262
7263 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tbufobj);
7264 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBufferBase");
7265
7266 if (gl.getError() != GL_NO_ERROR)
7267 {
7268 tcu_fail_msg("ApiCoverageTestCase::BindBufferBase", "Failed.");
7269 success = false;
7270 }
7271
7272 gl.deleteBuffers(1, &tbufobj);
7273 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
7274 if (m_is_transform_feedback_obj_supported)
7275 {
7276 gl.deleteTransformFeedbacks(1, &tobj);
7277 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteTransformFeedbacks");
7278 }
7279
7280 return success;
7281 }
7282
7283 /* Coverage test for glTransformFeedbackVaryings */
TestCoverageGLCallTransformFeedbackVaryings(void)7284 bool ApiCoverageTestCase::TestCoverageGLCallTransformFeedbackVaryings(void)
7285 {
7286 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7287 bool success = true;
7288 const char *ptex = "texCoords";
7289 GLenum err;
7290
7291 gl.transformFeedbackVaryings(0, 1, &ptex, GL_SEPARATE_ATTRIBS);
7292
7293 err = gl.getError();
7294 if ((err != GL_INVALID_OPERATION) && (err != GL_INVALID_VALUE))
7295 {
7296 tcu_fail_msg("ApiCoverageTestCase::TransformFeedbackVaryings", "Failed.");
7297 success = false;
7298 }
7299
7300 return success;
7301 }
7302
7303 /* Coverage test for glGetTransformFeedbackVarying */
TestCoverageGLCallGetTransformFeedbackVarying(void)7304 bool ApiCoverageTestCase::TestCoverageGLCallGetTransformFeedbackVarying(void)
7305 {
7306 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7307 bool success = true;
7308 GLint program = 0, length = 0, size = 0;
7309 GLuint type = 0;
7310 char name[32];
7311
7312 (void)gl.getError(); // clear error from previous test, if any
7313
7314 program = createDefaultProgram(1);
7315
7316 if (program == -1)
7317 {
7318 tcu_fail_msg("ApiCoverageTestCase::GetTransformFeedbackVarying", "Program create Failed");
7319 return false;
7320 }
7321
7322 gl.getTransformFeedbackVarying(program, 0, 32, &length, &size, &type, name);
7323 GLU_EXPECT_NO_ERROR(gl.getError(), "getTransformFeedbackVarying");
7324
7325 if (gl.getError() != GL_NO_ERROR)
7326 {
7327 tcu_fail_msg("ApiCoverageTestCase::GetTransformFeedbackVarying", "Failed.");
7328 success = false;
7329 }
7330
7331 gl.deleteProgram((GLuint)program);
7332 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
7333
7334 return success;
7335 }
7336
7337 /* Coverage test for glVertexAttribIPointer */
TestCoverageGLCallVertexAttribIPointer(void)7338 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribIPointer(void)
7339 {
7340 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7341 bool success = true;
7342 GLfloat buf[] = {1.0f};
7343
7344 (void)gl.getError(); // clear error from previous test, if any
7345
7346 GLuint vbo = 0;
7347 gl.genBuffers(1, &vbo);
7348 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
7349 gl.bindBuffer(GL_ARRAY_BUFFER, vbo);
7350 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");
7351 gl.bufferData(GL_ARRAY_BUFFER, sizeof(buf), (GLvoid *)buf, GL_STATIC_DRAW);
7352 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");
7353
7354 GLuint vao = 0;
7355 gl.genVertexArrays(1, &vao);
7356 GLU_EXPECT_NO_ERROR(gl.getError(), "genVertexArrays");
7357 gl.bindVertexArray(vao);
7358 GLU_EXPECT_NO_ERROR(gl.getError(), "bindVertexArray");
7359
7360 gl.vertexAttribIPointer(0, 1, GL_INT, 0, nullptr);
7361 GLU_EXPECT_NO_ERROR(gl.getError(), "vertexAttribIPointer");
7362
7363 if (gl.getError() != GL_NO_ERROR)
7364 {
7365 tcu_fail_msg("ApiCoverageTestCase::VertexAttribIPointer", "Failed.");
7366 success = false;
7367 }
7368
7369 gl.vertexAttribIPointer(0, 1, GL_FLOAT, 0, nullptr);
7370
7371 if (gl.getError() != GL_INVALID_ENUM)
7372 {
7373 tcu_fail_msg("ApiCoverageTestCase::VertexAttribIPointer", "Failed.");
7374 success = false;
7375 }
7376
7377 if (vbo)
7378 {
7379 gl.deleteBuffers(1, &vbo);
7380 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers");
7381 }
7382
7383 if (vao)
7384 {
7385 gl.deleteVertexArrays(1, &vao);
7386 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteVertexArrays");
7387 }
7388
7389 return success;
7390 }
7391
7392 /* Coverage test for glGetVertexAttribIiv */
TestCoverageGLCallGetVertexAttribIiv(void)7393 bool ApiCoverageTestCase::TestCoverageGLCallGetVertexAttribIiv(void)
7394 {
7395 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7396 bool success = true;
7397 GLint buf[10];
7398 GLuint index;
7399 GLint i;
7400
7401 index = 1;
7402
7403 for (i = 0; ea_GetVertexAttrib[i].value != -1; i++)
7404 {
7405 gl.getVertexAttribIiv(index, ea_GetVertexAttrib[i].value, buf);
7406
7407 if (gl.getError() == GL_INVALID_ENUM)
7408 {
7409 tcu_fail_msg("ApiCoverageTestCase::CallGetVertexAttribIiv", "Invalid enum : %s",
7410 ea_GetVertexAttrib[i].name);
7411 success = false;
7412 }
7413 }
7414
7415 return success;
7416 }
7417
7418 /* Coverage test for glGetVertexAttribIuiv */
TestCoverageGLCallGetVertexAttribIuiv(void)7419 bool ApiCoverageTestCase::TestCoverageGLCallGetVertexAttribIuiv(void)
7420 {
7421 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7422 bool success = true;
7423 GLuint buf[10];
7424 GLuint index;
7425 GLint i;
7426
7427 index = 1;
7428
7429 for (i = 0; ea_GetVertexAttrib[i].value != -1; i++)
7430 {
7431 gl.getVertexAttribIuiv(index, ea_GetVertexAttrib[i].value, buf);
7432
7433 if (gl.getError() == GL_INVALID_ENUM)
7434 {
7435 tcu_fail_msg("ApiCoverageTestCase::CallGetVertexAttribIuiv", "Invalid enum : %s",
7436 ea_GetVertexAttrib[i].name);
7437 success = false;
7438 }
7439 }
7440
7441 return success;
7442 }
7443
7444 /* Coverage test for glVertexAttribI4i */
7445
TestCoverageGLCallVertexAttribI4i(void)7446 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4i(void)
7447 {
7448 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7449 bool success = true;
7450
7451 gl.vertexAttribI4i(0, 1, 2, 3, 4);
7452
7453 if (gl.getError() != GL_NO_ERROR)
7454 {
7455 tcu_fail_msg("ApiCoverageTestCase::VertexAttribI4i", "Failed.");
7456 success = false;
7457 }
7458
7459 return success;
7460 }
7461
7462 /* Coverage test for glVertexAttribI4iv */
TestCoverageGLCallVertexAttribI4iv(void)7463 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4iv(void)
7464 {
7465 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7466 bool success = true;
7467 GLint buf[] = {1, 2, 3, 4};
7468
7469 gl.vertexAttribI4iv(0, buf);
7470
7471 if (gl.getError() != GL_NO_ERROR)
7472 {
7473 tcu_fail_msg("ApiCoverageTestCase::VertexAttribI4iv", "Failed.");
7474 success = false;
7475 }
7476
7477 return success;
7478 }
7479
7480 /* Coverage test for glVertexAttribI4ui */
TestCoverageGLCallVertexAttribI4ui(void)7481 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4ui(void)
7482 {
7483 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7484 bool success = true;
7485
7486 gl.vertexAttribI4ui(0, 1, 2, 3, 4);
7487
7488 if (gl.getError() != GL_NO_ERROR)
7489 {
7490 tcu_fail_msg("ApiCoverageTestCase::VertexAttribI4ui", "Failed.");
7491 success = false;
7492 }
7493
7494 return success;
7495 }
7496
7497 /* Coverage test for glVertexAttribI4uiv */
TestCoverageGLCallVertexAttribI4uiv(void)7498 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4uiv(void)
7499 {
7500 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7501 bool success = true;
7502 GLuint buf[] = {1, 2, 3, 4};
7503
7504 gl.vertexAttribI4uiv(0, buf);
7505
7506 if (gl.getError() != GL_NO_ERROR)
7507 {
7508 tcu_fail_msg("ApiCoverageTestCase::VertexAttribI4uiv", "Failed.");
7509 success = false;
7510 }
7511
7512 return success;
7513 }
7514
7515 /* Coverage test for glGetUniformuiv */
TestCoverageGLCallGetUniformuiv(void)7516 bool ApiCoverageTestCase::TestCoverageGLCallGetUniformuiv(void)
7517 {
7518 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7519 bool success = true;
7520 GLuint buf[10];
7521 GLuint program;
7522
7523 program = gl.createProgram();
7524 GLU_EXPECT_NO_ERROR(gl.getError(), "createProgram");
7525
7526 gl.getUniformuiv(program, 0, buf);
7527
7528 /* program is unlinked, so error should be INVALID_OPERATION */
7529 if (gl.getError() != GL_INVALID_OPERATION)
7530 {
7531 tcu_fail_msg("ApiCoverageTestCase::GetUniformuiv", "GL_INVALID_OPERATION not returned.");
7532 success = false;
7533 }
7534
7535 gl.useProgram(0);
7536 GLU_EXPECT_NO_ERROR(gl.getError(), "useProgram");
7537 gl.deleteProgram(program);
7538 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
7539
7540 return success;
7541 }
7542
7543 /* Coverage test for glGetFragDataLocation */
TestCoverageGLCallGetFragDataLocation(void)7544 bool ApiCoverageTestCase::TestCoverageGLCallGetFragDataLocation(void)
7545 {
7546 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7547 bool success = true;
7548 GLuint program;
7549
7550 program = gl.createProgram();
7551 GLU_EXPECT_NO_ERROR(gl.getError(), "createProgram");
7552 gl.getFragDataLocation(program, "fragData");
7553
7554 /* program is unlinked, so error should be INVALID_OPERATION */
7555 if (gl.getError() != GL_INVALID_OPERATION)
7556 {
7557 tcu_fail_msg("ApiCoverageTestCase::GetFragDataLocation", "GL_INVALID_OPERATION not returned.");
7558 success = false;
7559 }
7560
7561 gl.deleteProgram(program);
7562 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
7563
7564 return success;
7565 }
7566
7567 /* Coverage test for glUniform2ui */
TestCoverageGLCallUniform2ui(void)7568 bool ApiCoverageTestCase::TestCoverageGLCallUniform2ui(void)
7569 {
7570 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7571 bool success = true;
7572
7573 gl.uniform2ui(0, 1, 2);
7574
7575 if (gl.getError() != GL_INVALID_OPERATION)
7576 {
7577 tcu_fail_msg("ApiCoverageTestCase::CallUniform2ui", "GL_INVALID_OPERATION not returned");
7578 success = false;
7579 }
7580
7581 return success;
7582 }
7583 /* Coverage test for glUniform2uiv */
TestCoverageGLCallUniform2uiv(void)7584 bool ApiCoverageTestCase::TestCoverageGLCallUniform2uiv(void)
7585 {
7586 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7587 bool success = true;
7588 GLuint buf[] = {1, 2, 3, 4};
7589
7590 gl.uniform2uiv(0, 2, buf);
7591
7592 if (gl.getError() != GL_INVALID_OPERATION)
7593 {
7594 tcu_fail_msg("ApiCoverageTestCase::CallUniform2uiv", "GL_INVALID_OPERATION not returned");
7595 success = false;
7596 }
7597
7598 return success;
7599 }
7600
7601 /* Coverage test for glClearBufferiv */
TestCoverageGLCallClearBufferiv(void)7602 bool ApiCoverageTestCase::TestCoverageGLCallClearBufferiv(void)
7603 {
7604 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7605 GLint color[4] = {0, 0, 0, 0};
7606 bool success = true;
7607
7608 gl.clearBufferiv(GL_STENCIL, 0, color);
7609
7610 if (gl.getError() != GL_NO_ERROR)
7611 {
7612 tcu_fail_msg("ApiCoverageTestCase::ClearBufferiv", "Failed.");
7613 success = false;
7614 }
7615
7616 return success;
7617 }
7618
7619 /* Coverage test for glClearBufferuiv */
TestCoverageGLCallClearBufferuiv(void)7620 bool ApiCoverageTestCase::TestCoverageGLCallClearBufferuiv(void)
7621 {
7622 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7623 GLuint color[4] = {0, 0, 0, 0};
7624 bool success = true;
7625
7626 gl.clearBufferuiv(GL_COLOR, 0, color);
7627
7628 if (gl.getError() != GL_NO_ERROR)
7629 {
7630 tcu_fail_msg("ApiCoverageTestCase::ClearBufferuiv", "Failed.");
7631 success = false;
7632 }
7633
7634 return success;
7635 }
7636
7637 /* Coverage test for glClearBufferfv */
TestCoverageGLCallClearBufferfv(void)7638 bool ApiCoverageTestCase::TestCoverageGLCallClearBufferfv(void)
7639 {
7640 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7641 GLfloat color = 0.0f;
7642 bool success = true;
7643
7644 gl.clearBufferfv(GL_DEPTH, 0, &color);
7645
7646 if (gl.getError() != GL_NO_ERROR)
7647 {
7648 tcu_fail_msg("ApiCoverageTestCase::ClearBufferfv", "Failed.");
7649 success = false;
7650 }
7651
7652 return success;
7653 }
7654
7655 /* Coverage test for glClearBufferfi */
TestCoverageGLCallClearBufferfi(void)7656 bool ApiCoverageTestCase::TestCoverageGLCallClearBufferfi(void)
7657 {
7658 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7659 GLfloat depth = 0.0f;
7660 GLint stencil = 0;
7661 bool success = true;
7662
7663 gl.clearBufferfi(GL_DEPTH_STENCIL, 0, depth, stencil);
7664
7665 if (gl.getError() != GL_NO_ERROR)
7666 {
7667 tcu_fail_msg("ApiCoverageTestCase::ClearBufferfi", "Failed.");
7668 success = false;
7669 }
7670
7671 return success;
7672 }
7673
7674 /* Coverage test for glGetStringi */
7675
TestCoverageGLCallGetStringi(void)7676 bool ApiCoverageTestCase::TestCoverageGLCallGetStringi(void)
7677 {
7678 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7679 GLint i, max;
7680 bool success = true;
7681 const GLubyte *pstr = NULL;
7682
7683 (void)gl.getError(); // clear any unchecked errors
7684
7685 gl.getIntegerv(GL_NUM_EXTENSIONS, &i);
7686 max = i;
7687 if (gl.getError() != GL_NO_ERROR)
7688 {
7689 tcu_fail_msg("ApiCoverageTestCase::GetStringi", "Get NUM_EXTENSIONS failed.");
7690 return false;
7691 }
7692
7693 while (i--)
7694 {
7695 pstr = gl.getStringi(GL_EXTENSIONS, i);
7696 if ((gl.getError() != GL_NO_ERROR) || (NULL == pstr) || (std::strlen((const char *)pstr) <= 0))
7697 {
7698 tcu_fail_msg("ApiCoverageTestCase::GetStringi", "Get EXTENSION failed.");
7699 return false;
7700 }
7701 }
7702
7703 pstr = gl.getStringi(GL_EXTENSIONS, max);
7704 if (gl.getError() != GL_INVALID_VALUE)
7705 {
7706 success = false;
7707 tcu_fail_msg("ApiCoverageTestCase::GetStringi", "Get EXTENSION with invalid index succeeded.");
7708 }
7709
7710 return success;
7711 }
7712
7713 /* Coverage test for glBlitFramebuffer */
TestCoverageGLCallBlitFramebuffer(void)7714 bool ApiCoverageTestCase::TestCoverageGLCallBlitFramebuffer(void)
7715 {
7716 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7717 GLint error;
7718 bool success = true;
7719 GLint width = 32, height = 32;
7720 GLuint fbo = 0, rbo_color = 0, rbo_depth = 0;
7721
7722 (void)gl.getError(); // clear error from previous test, if any
7723
7724 // FBO
7725 gl.genFramebuffers(1, &fbo);
7726 GLU_EXPECT_NO_ERROR(gl.getError(), "genFramebuffers");
7727 gl.bindFramebuffer(GL_FRAMEBUFFER, fbo);
7728 GLU_EXPECT_NO_ERROR(gl.getError(), "bindFramebuffer");
7729
7730 // RBO (color)
7731 gl.genRenderbuffers(1, &rbo_color);
7732 GLU_EXPECT_NO_ERROR(gl.getError(), "genRenderbuffers");
7733 gl.bindRenderbuffer(GL_RENDERBUFFER, rbo_color);
7734 GLU_EXPECT_NO_ERROR(gl.getError(), "bindRenderbuffer");
7735 gl.renderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, width, height);
7736 GLU_EXPECT_NO_ERROR(gl.getError(), "renderbufferStorage");
7737 gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo_color);
7738 GLU_EXPECT_NO_ERROR(gl.getError(), "framebufferRenderbuffer");
7739
7740 // RBO (depth & stencil)
7741 gl.genRenderbuffers(1, &rbo_depth);
7742 GLU_EXPECT_NO_ERROR(gl.getError(), "genRenderbuffers");
7743 gl.bindRenderbuffer(GL_RENDERBUFFER, rbo_depth);
7744 GLU_EXPECT_NO_ERROR(gl.getError(), "bindRenderbuffer");
7745 gl.renderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height);
7746 GLU_EXPECT_NO_ERROR(gl.getError(), "renderbufferStorage");
7747 gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rbo_depth);
7748 GLU_EXPECT_NO_ERROR(gl.getError(), "framebufferRenderbuffer");
7749 gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo_depth);
7750 GLU_EXPECT_NO_ERROR(gl.getError(), "framebufferRenderbuffer");
7751
7752 error = gl.checkFramebufferStatus(GL_FRAMEBUFFER);
7753 if (error != GL_FRAMEBUFFER_COMPLETE)
7754 {
7755 tcu_fail_msg("ApiCoverageTestCase::BlitFramebuffer", "Expected GL_FRAMEBUFFER_COMPLETE, got 0x%x", error);
7756 return false;
7757 }
7758
7759 gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, m_defaultFBO);
7760 GLU_EXPECT_NO_ERROR(gl.getError(), "bindFramebuffer");
7761
7762 // Check errors
7763 // No buffer bit
7764 gl.blitFramebuffer(0, 0, width, height, 0, 0, width, height, 0, GL_NEAREST);
7765
7766 if ((error = gl.getError()) != GL_NO_ERROR)
7767 {
7768 tcu_fail_msg("ApiCoverageTestCase::BlitFramebuffer", "Expected GL_NO_ERROR, got 0x%x (1)", error);
7769 success = false;
7770 }
7771
7772 // invald buffer bit
7773 gl.blitFramebuffer(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT | GL_MAP_INVALIDATE_BUFFER_BIT,
7774 GL_NEAREST);
7775
7776 if ((error = gl.getError()) != GL_INVALID_VALUE)
7777 {
7778 tcu_fail_msg("ApiCoverageTestCase::BlitFramebuffer", "Expected GL_INVALID_VALUE, got 0x%x (2)", error);
7779 success = false;
7780 }
7781
7782 // invalide filter mode
7783 gl.blitFramebuffer(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT,
7784 GL_LINEAR);
7785
7786 if ((error = gl.getError()) != GL_INVALID_OPERATION)
7787 {
7788 tcu_fail_msg("ApiCoverageTestCase::BlitFramebuffer", "Expected GL_INVALID_OPERATION, got 0x%x (3)", error);
7789 success = false;
7790 }
7791
7792 // read/draw buffer the same
7793 // Overlapping blits are forbidden with ES3 and allowed with GL
7794 gl.bindFramebuffer(GL_FRAMEBUFFER, m_defaultFBO);
7795 GLU_EXPECT_NO_ERROR(gl.getError(), "bindFramebuffer");
7796
7797 gl.blitFramebuffer(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
7798
7799 if (m_is_context_ES && glu::contextSupports(m_context_type, glu::ApiType::es(3, 0)))
7800 {
7801 if ((error = gl.getError()) != GL_INVALID_OPERATION)
7802 {
7803 tcu_fail_msg("ApiCoverageTestCase::BlitFramebuffer", "Expected GL_INVALID_OPERATION, got 0x%x (4)", error);
7804 success = false;
7805 }
7806 }
7807 else
7808 {
7809 if (gl.getError() != GL_NO_ERROR)
7810 {
7811 tcu_fail_msg("ApiCoverageTestCase::BlitFramebuffer", "Failed!");
7812 success = false;
7813 }
7814 }
7815 // Do the correct blit
7816 gl.bindFramebuffer(GL_READ_FRAMEBUFFER, fbo);
7817 GLU_EXPECT_NO_ERROR(gl.getError(), "bindFramebuffer");
7818 gl.blitFramebuffer(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
7819
7820 if (gl.getError() != GL_NO_ERROR)
7821 {
7822 tcu_fail_msg("ApiCoverageTestCase::BlitFramebuffer", "Failed!");
7823 success = false;
7824 }
7825
7826 gl.deleteFramebuffers(1, &fbo);
7827 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteFramebuffers");
7828 gl.deleteRenderbuffers(1, &rbo_color);
7829 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteRenderbuffers");
7830 gl.deleteRenderbuffers(1, &rbo_depth);
7831 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteRenderbuffers");
7832
7833 return success;
7834 }
7835
7836 /* Coverage test for glRenderbufferStorageMultisample */
7837
7838 /* Enums to test for glRenderbufferStorageMultisample (may not be required) */
7839 struct enumTestRec const ea_RenderbufferStorageMultisample[] = {{"End of List", -1}};
7840
TestCoverageGLCallRenderbufferStorageMultisample(void)7841 bool ApiCoverageTestCase::TestCoverageGLCallRenderbufferStorageMultisample(void)
7842 {
7843 GLuint i;
7844 bool success = true;
7845
7846 /* glRenderbufferStorageMultisample may need to loop over a set of enums doing something with them */
7847 for (i = 0; ea_RenderbufferStorageMultisample[i].value != -1; i++)
7848 {
7849 }
7850
7851 tcu_msg("ApiCoverageTestCase::RenderbufferStorageMultisample", "Coverage test not implemented yet");
7852
7853 return success;
7854 }
7855
7856 /* Coverage test for glFramebufferTextureLayer */
7857
7858 /* Enums to test for glFramebufferTextureLayer (may not be required) */
7859 struct enumTestRec const ea_FramebufferTextureLayer[] = {{"End of List", -1}};
7860
TestCoverageGLCallFramebufferTextureLayer(void)7861 bool ApiCoverageTestCase::TestCoverageGLCallFramebufferTextureLayer(void)
7862 {
7863 GLuint i;
7864 bool success = true;
7865
7866 /* glFramebufferTextureLayer may need to loop over a set of enums doing something with them */
7867 for (i = 0; ea_FramebufferTextureLayer[i].value != -1; i++)
7868 {
7869 }
7870
7871 tcu_msg("ApiCoverageTestCase::FramebufferTextureLayer", "Coverage test not implemented yet");
7872
7873 return success;
7874 }
7875
7876 /* Coverage test for glBindVertexArray */
TestCoverageGLCallBindVertexArray(void)7877 bool ApiCoverageTestCase::TestCoverageGLCallBindVertexArray(void)
7878 {
7879 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7880 GLuint va;
7881 bool success = true;
7882
7883 (void)gl.getError(); // clear error from previous test, if any
7884
7885 gl.genVertexArrays(1, &va);
7886 GLU_EXPECT_NO_ERROR(gl.getError(), "genVertexArrays");
7887 gl.bindVertexArray(va);
7888
7889 if (gl.getError() != GL_NO_ERROR)
7890 {
7891 success = false;
7892 tcu_fail_msg("ApiCoverageTestCase::BindVertexArray", "Failed");
7893 }
7894
7895 gl.deleteVertexArrays(1, &va);
7896 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteVertexArrays");
7897
7898 return success;
7899 }
7900
7901 /* Coverage test for glDeleteVertexArrays */
TestCoverageGLCallDeleteVertexArrays(void)7902 bool ApiCoverageTestCase::TestCoverageGLCallDeleteVertexArrays(void)
7903 {
7904 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7905 GLuint va;
7906 bool success = true;
7907
7908 (void)gl.getError(); // clear error from previous test, if any
7909
7910 gl.genVertexArrays(1, &va);
7911 GLU_EXPECT_NO_ERROR(gl.getError(), "genVertexArrays");
7912 gl.deleteVertexArrays(1, &va);
7913 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteVertexArrays");
7914
7915 gl.genVertexArrays(1, &va);
7916 GLU_EXPECT_NO_ERROR(gl.getError(), "genVertexArrays");
7917 gl.bindVertexArray(va);
7918 GLU_EXPECT_NO_ERROR(gl.getError(), "bindVertexArray");
7919 gl.deleteVertexArrays(1, &va);
7920
7921 if (gl.getError() != GL_NO_ERROR)
7922 {
7923 success = false;
7924 tcu_fail_msg("ApiCoverageTestCase::DeleteVertexArray", "Failed");
7925 }
7926
7927 return success;
7928 }
7929
7930 /* Coverage test for glGenVertexArrays */
TestCoverageGLCallGenVertexArrays(void)7931 bool ApiCoverageTestCase::TestCoverageGLCallGenVertexArrays(void)
7932 {
7933 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7934 GLuint va[3] = {0, 0, 0};
7935 int i;
7936 bool success = true;
7937
7938 (void)gl.getError(); // clear error from previous test, if any
7939
7940 gl.genVertexArrays(3, va);
7941
7942 for (i = 0; i < 3; i++)
7943 {
7944 if (va[i] == 0)
7945 {
7946 break;
7947 }
7948 }
7949
7950 if ((i != 3) || (gl.getError() != GL_NO_ERROR))
7951 {
7952 success = false;
7953 tcu_fail_msg("ApiCoverageTestCase::GenVertexArrays", "Failed");
7954 }
7955
7956 gl.deleteVertexArrays(3, va);
7957 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteVertexArrays");
7958
7959 return success;
7960 }
7961
7962 /* Coverage test for glIsVertexArray */
TestCoverageGLCallIsVertexArray(void)7963 bool ApiCoverageTestCase::TestCoverageGLCallIsVertexArray(void)
7964 {
7965 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7966 GLuint va;
7967 bool success = true;
7968
7969 (void)gl.getError(); // clear error from previous test, if any
7970
7971 gl.genVertexArrays(1, &va);
7972 GLU_EXPECT_NO_ERROR(gl.getError(), "genVertexArrays");
7973 gl.bindVertexArray(va);
7974 GLU_EXPECT_NO_ERROR(gl.getError(), "bindVertexArray");
7975
7976 if (glIsVertexArray(va) != GL_TRUE)
7977 {
7978 success = false;
7979 tcu_fail_msg("ApiCoverageTestCase::IsVertexArray", "Failed - TRUE");
7980 }
7981 if (glIsVertexArray(va + 1) != GL_FALSE)
7982 {
7983 success = false;
7984 tcu_fail_msg("ApiCoverageTestCase::IsVertexArray", "Failed - ");
7985 }
7986
7987 gl.deleteVertexArrays(1, &va);
7988 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteVertexArrays");
7989
7990 return success;
7991 }
7992
7993 /* Coverage test for glDrawArraysInstanced */
TestCoverageGLCallDrawArraysInstanced(void)7994 bool ApiCoverageTestCase::TestCoverageGLCallDrawArraysInstanced(void)
7995 {
7996 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
7997 bool success = true;
7998
7999 (void)gl.getError(); // clear error from previous test, if any
8000
8001 gl.drawArraysInstanced(GL_POINTS - 1, 0, 3, 4);
8002
8003 if (gl.getError() != GL_INVALID_ENUM)
8004 {
8005 tcu_fail_msg("ApiCoverageTestCase::DrawArraysInstanced", "Failed");
8006 success = false;
8007 }
8008
8009 return success;
8010 }
8011
8012 /* Coverage test for glDrawElementsInstanced */
TestCoverageGLCallDrawElementsInstanced(void)8013 bool ApiCoverageTestCase::TestCoverageGLCallDrawElementsInstanced(void)
8014 {
8015 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8016 bool success = true;
8017
8018 (void)gl.getError(); // clear error from previous test, if any
8019
8020 gl.drawElementsInstanced(GL_POINTS - 1, 3, GL_UNSIGNED_INT, NULL, 4);
8021
8022 if (gl.getError() != GL_INVALID_ENUM)
8023 {
8024 tcu_fail_msg("ApiCoverageTestCase::DrawElementsInstanced", "Failed");
8025 success = false;
8026 }
8027
8028 return success;
8029 }
8030
8031 /* Coverage test for glCopyBufferSubData */
TestCoverageGLCallCopyBufferSubData(void)8032 bool ApiCoverageTestCase::TestCoverageGLCallCopyBufferSubData(void)
8033 {
8034 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8035 bool success = true;
8036 GLuint cb[2];
8037 GLubyte rdata[64], wdata[64];
8038
8039 (void)gl.getError(); // clear error from previous test, if any
8040
8041 gl.copyBufferSubData(GL_PIXEL_UNPACK_BUFFER, GL_PIXEL_PACK_BUFFER, 0, 0, 64);
8042
8043 if (gl.getError() != GL_INVALID_OPERATION)
8044 {
8045 tcu_fail_msg("ApiCoverageTestCase::CopyBufferSubData", "Failed (1)");
8046 success = false;
8047 }
8048
8049 gl.copyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, 64);
8050
8051 if (gl.getError() != GL_INVALID_OPERATION)
8052 {
8053 tcu_fail_msg("ApiCoverageTestCase::CopyBufferSubData", "Failed (2)");
8054 success = false;
8055 }
8056
8057 gl.genBuffers(2, cb);
8058 GLU_EXPECT_NO_ERROR(gl.getError(), "genBuffers");
8059 gl.bindBuffer(GL_COPY_READ_BUFFER, cb[0]);
8060 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBuffer");
8061 gl.bufferData(GL_COPY_READ_BUFFER, 64, rdata, GL_DYNAMIC_READ);
8062 GLU_EXPECT_NO_ERROR(gl.getError(), "bufferData");
8063 gl.bindBuffer(GL_COPY_WRITE_BUFFER, cb[1]);
8064 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBuffer");
8065 gl.bufferData(GL_COPY_WRITE_BUFFER, 64, wdata, GL_STATIC_COPY);
8066 GLU_EXPECT_NO_ERROR(gl.getError(), "bufferData");
8067
8068 gl.copyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 8, 8, 32);
8069
8070 if (gl.getError() != GL_NO_ERROR)
8071 {
8072 tcu_fail_msg("ApiCoverageTestCase::CopyBufferSubData", "Failed (3)");
8073 success = false;
8074 }
8075
8076 gl.deleteBuffers(2, cb);
8077 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
8078
8079 return success;
8080 }
8081
TestCoverageGLCallGetUniformIndices(void)8082 bool ApiCoverageTestCase::TestCoverageGLCallGetUniformIndices(void)
8083 {
8084 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8085 bool success = true;
8086 const char *uname = "dummy";
8087 GLuint uindex = 0;
8088 GLint program;
8089
8090 (void)gl.getError(); // clear error from previous test, if any
8091
8092 program = createDefaultProgram(0);
8093
8094 if (program == -1)
8095 {
8096 tcu_fail_msg("ApiCoverageTestCase::GetUniformIndices", "Program create Failed");
8097 return false;
8098 }
8099
8100 gl.getUniformIndices((GLuint)program, 1, &uname, &uindex);
8101
8102 if (gl.getError() != GL_NO_ERROR)
8103 {
8104 tcu_fail_msg("ApiCoverageTestCase::GetUniformIndices", "Failed (2)");
8105 success = false;
8106 }
8107 if (uindex != GL_INVALID_INDEX)
8108 {
8109 tcu_fail_msg("ApiCoverageTestCase::GetUniformIndices", "Failed (3)");
8110 success = false;
8111 }
8112
8113 gl.deleteProgram((GLuint)program);
8114 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
8115
8116 return success;
8117 }
8118
8119 /* Coverage test for glGetActiveUniformsiv */
TestCoverageGLCallGetActiveUniformsiv(void)8120 bool ApiCoverageTestCase::TestCoverageGLCallGetActiveUniformsiv(void)
8121 {
8122 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8123 bool success = true;
8124 GLuint uindex = 0;
8125 GLint program;
8126 GLint data;
8127
8128 (void)gl.getError(); // clear error from previous test, if any
8129
8130 program = createDefaultProgram(0);
8131
8132 if (program == -1)
8133 {
8134 tcu_fail_msg("ApiCoverageTestCase::GetActiveUniformsiv", "Program create Failed");
8135 return false;
8136 }
8137
8138 gl.getActiveUniformsiv((GLuint)program, 1, &uindex, GL_UNIFORM_TYPE, &data);
8139
8140 if (gl.getError() != GL_NO_ERROR)
8141 {
8142 tcu_fail_msg("ApiCoverageTestCase::GetActiveUniformsiv", "Failed (2)");
8143 success = false;
8144 }
8145
8146 gl.deleteProgram((GLuint)program);
8147 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
8148
8149 return success;
8150 }
8151
8152 /* Coverage test for glGetUniformBlockIndex */
TestCoverageGLCallGetUniformBlockIndex(void)8153 bool ApiCoverageTestCase::TestCoverageGLCallGetUniformBlockIndex(void)
8154 {
8155 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8156 bool success = true;
8157 GLuint uindex;
8158 GLint program;
8159
8160 (void)gl.getError(); // clear error from previous test, if any
8161
8162 program = createDefaultProgram(0);
8163
8164 if (program == -1)
8165 {
8166 tcu_fail_msg("ApiCoverageTestCase::GetUniformBlockIndex", "Program create Failed");
8167 return false;
8168 }
8169
8170 uindex = gl.getUniformBlockIndex((GLuint)program, "dummy");
8171 GLU_EXPECT_NO_ERROR(gl.getError(), "getUniformBlockIndex");
8172
8173 if (uindex != GL_INVALID_INDEX)
8174 {
8175 tcu_fail_msg("ApiCoverageTestCase::GetUniformBlockIndex", "Failed");
8176 success = false;
8177 }
8178
8179 gl.deleteProgram((GLuint)program);
8180 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
8181
8182 return success;
8183 }
8184
8185 /* Coverage test for glGetActiveUniformBlockiv */
TestCoverageGLCallGetActiveUniformBlockiv(void)8186 bool ApiCoverageTestCase::TestCoverageGLCallGetActiveUniformBlockiv(void)
8187 {
8188 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8189 bool success = true;
8190 GLint program;
8191 GLint data;
8192
8193 (void)gl.getError(); // clear error from previous test, if any
8194
8195 program = createDefaultProgram(0);
8196
8197 if (program == -1)
8198 {
8199 tcu_fail_msg("ApiCoverageTestCase::GetActiveUniformBlockiv", "Program create Failed");
8200 return false;
8201 }
8202
8203 gl.getActiveUniformBlockiv((GLuint)program, 0, GL_UNIFORM_BLOCK_DATA_SIZE, &data);
8204
8205 if (gl.getError() != GL_INVALID_VALUE)
8206 {
8207 tcu_fail_msg("ApiCoverageTestCase::GetActiveUniformBlockiv", "Failed");
8208 success = false;
8209 }
8210
8211 gl.deleteProgram((GLuint)program);
8212 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
8213
8214 return success;
8215 }
8216
8217 /* Coverage test for glGetActiveUniformBlockName */
TestCoverageGLCallGetActiveUniformBlockName(void)8218 bool ApiCoverageTestCase::TestCoverageGLCallGetActiveUniformBlockName(void)
8219 {
8220 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8221 bool success = true;
8222 GLint program;
8223 GLchar name[256];
8224 GLsizei length;
8225
8226 (void)gl.getError(); // clear error from previous test, if any
8227
8228 program = createDefaultProgram(0);
8229
8230 if (program == -1)
8231 {
8232 tcu_fail_msg("ApiCoverageTestCase::GetActiveUniformBlockName", "Program create Failed");
8233 return false;
8234 }
8235
8236 gl.getActiveUniformBlockName((GLuint)program, 0, 256, &length, name);
8237
8238 if (gl.getError() != GL_INVALID_VALUE)
8239 {
8240 tcu_fail_msg("ApiCoverageTestCase::GetActiveUniformBlockName", "Failed");
8241 success = false;
8242 }
8243
8244 gl.deleteProgram((GLuint)program);
8245 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
8246
8247 return success;
8248 }
8249
8250 /* Coverage test for glUniformBlockBinding */
TestCoverageGLCallUniformBlockBinding(void)8251 bool ApiCoverageTestCase::TestCoverageGLCallUniformBlockBinding(void)
8252 {
8253 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8254 bool success = true;
8255 GLint program;
8256
8257 (void)gl.getError(); // clear error from previous test, if any
8258
8259 program = createDefaultProgram(0);
8260
8261 if (program == -1)
8262 {
8263 tcu_fail_msg("ApiCoverageTestCase::UniformBlockBinding", "Program create Failed");
8264 return false;
8265 }
8266
8267 gl.uniformBlockBinding((GLuint)program, 0, 0);
8268
8269 if (gl.getError() != GL_INVALID_VALUE)
8270 {
8271 tcu_fail_msg("ApiCoverageTestCase::UniformBlockBinding", "Failed");
8272 success = false;
8273 }
8274
8275 gl.deleteProgram((GLuint)program);
8276 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
8277
8278 return success;
8279 }
8280
8281 /* Coverage test for glGetBufferParameteri64v */
TestCoverageGLCallGetBufferParameteri64v(void)8282 bool ApiCoverageTestCase::TestCoverageGLCallGetBufferParameteri64v(void)
8283 {
8284 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8285 GLuint i;
8286 bool success = true;
8287 GLuint cb;
8288 GLuint data[64];
8289 GLint64 param;
8290
8291 (void)gl.getError(); // clear error from previous test, if any
8292
8293 gl.genBuffers(1, &cb);
8294 GLU_EXPECT_NO_ERROR(gl.getError(), "genBuffers");
8295 gl.bindBuffer(GL_PIXEL_PACK_BUFFER, cb);
8296 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBuffer");
8297 gl.bufferData(GL_PIXEL_PACK_BUFFER, 64, data, GL_STATIC_COPY);
8298
8299 if (gl.getError() != GL_NO_ERROR)
8300 {
8301 tcu_fail_msg("ApiCoverageTestCase::GetBufferParameteri64v", "Buffer creation failure");
8302 return false;
8303 }
8304
8305 for (i = 0; ea_GetBufferParameteri64v[i].value != -1; i++)
8306 {
8307 gl.getBufferParameteri64v(GL_PIXEL_PACK_BUFFER, ea_GetBufferParameteri64v[i].value, ¶m);
8308
8309 if (gl.getError() != GL_NO_ERROR)
8310 {
8311 success = false;
8312 }
8313 }
8314
8315 if (success == false)
8316 {
8317 tcu_fail_msg("ApiCoverageTestCase::GetBufferParameteri64v", "Failed");
8318 }
8319 if (param != 64)
8320 {
8321 tcu_fail_msg("ApiCoverageTestCase::GetBufferParameteri64v", "Incorrect return value");
8322 success = false;
8323 }
8324
8325 gl.deleteBuffers(1, &cb);
8326 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
8327
8328 return success;
8329 }
8330
8331 /* Coverage test for glProgramParameteri */
TestCoverageGLCallProgramParameteri(void)8332 bool ApiCoverageTestCase::TestCoverageGLCallProgramParameteri(void)
8333 {
8334 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8335 bool success = true;
8336 GLint program;
8337
8338 (void)gl.getError(); // clear error from previous test, if any
8339
8340 program = createDefaultProgram(0);
8341
8342 if (program == -1)
8343 {
8344 tcu_fail_msg("ApiCoverageTestCase::ProgramParameteri", "Program create Failed");
8345 return false;
8346 }
8347
8348 gl.programParameteri(program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
8349
8350 if (gl.getError() != GL_NO_ERROR)
8351 {
8352 tcu_fail_msg("ApiCoverageTestCase::ProgramParameteri", "Failed");
8353 success = false;
8354 }
8355
8356 gl.deleteProgram((GLuint)program);
8357 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
8358
8359 return success;
8360 }
8361 /* Coverage test for glFenceSync */
8362
8363 /* Enums to test for glFenceSync (may not be required) */
TestCoverageGLCallFenceSync(void)8364 bool ApiCoverageTestCase::TestCoverageGLCallFenceSync(void)
8365 {
8366 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8367 bool success = true;
8368
8369 (void)gl.getError(); // clear error from previous test, if any
8370
8371 GLsync sobj1 = gl.fenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
8372
8373 if (gl.getError() != GL_NO_ERROR)
8374 {
8375 tcu_fail_msg("ApiCoverageTestCase::FenceSync", "Failed (1)");
8376 success = false;
8377 }
8378
8379 GLsync sobj2 = gl.fenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 1);
8380
8381 if (gl.getError() != GL_INVALID_VALUE)
8382 {
8383 tcu_fail_msg("ApiCoverageTestCase::FenceSync", "Failed (2)");
8384 success = false;
8385 }
8386
8387 gl.deleteSync(sobj1);
8388 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteSync");
8389 gl.deleteSync(sobj2);
8390 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteSync");
8391
8392 return success;
8393 }
8394
8395 /* Coverage test for glIsSync */
TestCoverageGLCallIsSync(void)8396 bool ApiCoverageTestCase::TestCoverageGLCallIsSync(void)
8397 {
8398 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8399 bool success = true;
8400 GLsync sobj;
8401
8402 (void)gl.getError(); // clear error from previous test, if any
8403
8404 sobj = gl.fenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
8405 GLU_EXPECT_NO_ERROR(gl.getError(), "fenceSync");
8406
8407 if ((gl.isSync(sobj) == GL_FALSE) || (gl.getError() != GL_NO_ERROR))
8408 {
8409 tcu_fail_msg("ApiCoverageTestCase::IsSync", "Sync creation failed");
8410 success = false;
8411 }
8412 gl.deleteSync(sobj);
8413 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteSync");
8414
8415 return success;
8416 }
8417
8418 /* Coverage test for glDeleteSync */
TestCoverageGLCallDeleteSync(void)8419 bool ApiCoverageTestCase::TestCoverageGLCallDeleteSync(void)
8420 {
8421 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8422 bool success = true;
8423 GLsync sobj;
8424
8425 (void)gl.getError(); // clear error from previous test, if any
8426
8427 sobj = gl.fenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
8428 GLU_EXPECT_NO_ERROR(gl.getError(), "fenceSync");
8429
8430 gl.deleteSync(sobj);
8431 if (gl.getError() != GL_NO_ERROR)
8432 {
8433 tcu_fail_msg("ApiCoverageTestCase::DeleteSync", "Failed");
8434 success = false;
8435 }
8436
8437 return success;
8438 }
8439
8440 /* Coverage test for glClientWaitSync */
TestCoverageGLCallClientWaitSync(void)8441 bool ApiCoverageTestCase::TestCoverageGLCallClientWaitSync(void)
8442 {
8443 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8444 bool success = true;
8445 GLsync sobj;
8446 GLenum sresult;
8447
8448 (void)gl.getError(); // clear error from previous test, if any
8449
8450 // Make sure all GL commands issued before are flushed and finished.
8451 gl.finish();
8452 GLU_EXPECT_NO_ERROR(gl.getError(), "finish");
8453
8454 sobj = gl.fenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
8455 if (gl.getError() != GL_NO_ERROR)
8456 {
8457 tcu_fail_msg("ApiCoverageTestCase::ClientWaitSync", "Sync create failed");
8458 success = false;
8459 }
8460
8461 sresult = gl.clientWaitSync(sobj, 0, 1000000000ULL);
8462 if (gl.getError() != GL_NO_ERROR || sresult == GL_WAIT_FAILED)
8463 {
8464 tcu_fail_msg("ApiCoverageTestCase::ClientWaitSync", "Failed (1)");
8465 success = false;
8466 }
8467
8468 sresult = gl.clientWaitSync(sobj, GL_SYNC_FLUSH_COMMANDS_BIT, 1000000000ULL);
8469 if (gl.getError() != GL_NO_ERROR || sresult == GL_WAIT_FAILED)
8470 {
8471 tcu_fail_msg("ApiCoverageTestCase::ClientWaitSync", "Failed (2)");
8472 success = false;
8473 }
8474
8475 gl.deleteSync(sobj);
8476 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteSync");
8477
8478 return success;
8479 }
8480
8481 /* Coverage test for glWaitSync */
TestCoverageGLCallWaitSync(void)8482 bool ApiCoverageTestCase::TestCoverageGLCallWaitSync(void)
8483 {
8484 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8485 bool success = true;
8486 GLsync sobj;
8487
8488 (void)gl.getError(); // clear error from previous test, if any
8489
8490 sobj = gl.fenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
8491 if (gl.getError() != GL_NO_ERROR)
8492 {
8493 tcu_fail_msg("ApiCoverageTestCase::WaitSync", "Sync create failed");
8494 success = false;
8495 }
8496
8497 gl.waitSync(sobj, 0, GL_TIMEOUT_IGNORED);
8498 if (gl.getError() != GL_NO_ERROR)
8499 {
8500 tcu_fail_msg("ApiCoverageTestCase::WaitSync", "Failed (1)");
8501 success = false;
8502 }
8503
8504 gl.waitSync(sobj, 0, 1000000000ULL);
8505 if (gl.getError() != GL_INVALID_VALUE)
8506 {
8507 tcu_fail_msg("ApiCoverageTestCase::WaitSync", "Failed (2)");
8508 success = false;
8509 }
8510
8511 gl.deleteSync(sobj);
8512 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteSync");
8513
8514 return success;
8515 }
8516
8517 /* Coverage test for glGetInteger64v */
TestCoverageGLCallGetInteger64v(void)8518 bool ApiCoverageTestCase::TestCoverageGLCallGetInteger64v(void)
8519 {
8520 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8521 GLint64 value;
8522 GLint i;
8523 bool success = true;
8524
8525 (void)gl.getError(); // clear error from previous test, if any
8526
8527 for (i = 0; ea_GetInteger64v[i].value != -1; i++)
8528 {
8529 gl.getInteger64v(ea_GetInteger64v[i].value, &value);
8530
8531 if (gl.getError() != GL_NO_ERROR)
8532 {
8533 tcu_fail_msg("ApiCoverageTestCase::GetInteger64v", "Failed 0x%x", ea_GetInteger64v[i].value);
8534 success = false;
8535 }
8536 }
8537
8538 return success;
8539 }
8540
8541 /* Coverage test for glGetSynciv */
TestCoverageGLCallGetSynciv(void)8542 bool ApiCoverageTestCase::TestCoverageGLCallGetSynciv(void)
8543 {
8544 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8545 GLuint i;
8546 bool success = true;
8547 GLsync sobj;
8548 GLsizei length;
8549 GLint value;
8550
8551 (void)gl.getError(); // clear error from previous test, if any
8552
8553 sobj = gl.fenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
8554
8555 for (i = 0; ea_GetSynciv[i].value != -1; i++)
8556 {
8557 gl.getSynciv(sobj, ea_GetSynciv[i].value, 1, &length, &value);
8558
8559 if (gl.getError() != GL_NO_ERROR)
8560 {
8561 tcu_fail_msg("ApiCoverageTestCase::GetSynciv", "Failed 0x%x", ea_GetSynciv[i].value);
8562 success = false;
8563 }
8564 }
8565
8566 gl.deleteSync(sobj);
8567 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteSync");
8568
8569 return success;
8570 }
8571
8572 /* Coverage test for glGenSamplers */
TestCoverageGLCallGenSamplers(void)8573 bool ApiCoverageTestCase::TestCoverageGLCallGenSamplers(void)
8574 {
8575 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8576 bool success = true;
8577 GLuint sampler[2];
8578
8579 (void)gl.getError(); // clear error from previous test, if any
8580
8581 gl.genSamplers(2, sampler);
8582
8583 if (gl.getError() != GL_NO_ERROR)
8584 {
8585 tcu_fail_msg("ApiCoverageTestCase::GenSamplers", "Failed.");
8586 success = false;
8587 }
8588
8589 gl.deleteSamplers(2, sampler);
8590 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteSamplers");
8591
8592 return success;
8593 }
8594
8595 /* Coverage test for glDeleteSamplers */
TestCoverageGLCallDeleteSamplers(void)8596 bool ApiCoverageTestCase::TestCoverageGLCallDeleteSamplers(void)
8597 {
8598 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8599 bool success = true;
8600 GLuint sampler[2];
8601
8602 (void)gl.getError(); // clear error from previous test, if any
8603
8604 gl.genSamplers(2, sampler);
8605
8606 if (gl.getError() != GL_NO_ERROR)
8607 {
8608 tcu_fail_msg("ApiCoverageTestCase::DeleteSamplers", "Could not create a sampler.");
8609 success = false;
8610 }
8611
8612 gl.deleteSamplers(2, sampler);
8613
8614 if (gl.getError() != GL_NO_ERROR)
8615 {
8616 tcu_fail_msg("ApiCoverageTestCase::DeleteSamplers", "Failed.");
8617 success = false;
8618 }
8619
8620 return success;
8621 }
8622
8623 /* Coverage test for glIsSampler */
TestCoverageGLCallIsSampler(void)8624 bool ApiCoverageTestCase::TestCoverageGLCallIsSampler(void)
8625 {
8626 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8627 bool success = true;
8628 GLuint sampler;
8629
8630 (void)gl.getError(); // clear error from previous test, if any
8631
8632 gl.genSamplers(1, &sampler);
8633
8634 if (gl.getError() != GL_NO_ERROR)
8635 {
8636 tcu_fail_msg("ApiCoverageTestCase::IsSampler", "Could not create a sampler.");
8637 success = false;
8638 }
8639
8640 if ((gl.isSampler(sampler) != GL_TRUE) || (gl.getError() != GL_NO_ERROR))
8641 {
8642 tcu_fail_msg("ApiCoverageTestCase::IsSampler", "Failed.");
8643 success = false;
8644 }
8645
8646 gl.bindSampler(0, sampler);
8647 GLU_EXPECT_NO_ERROR(gl.getError(), "bindSampler");
8648
8649 if ((gl.isSampler(sampler) != GL_TRUE) || (gl.getError() != GL_NO_ERROR))
8650 {
8651 tcu_fail_msg("ApiCoverageTestCase::IsSampler", "Failed.");
8652 success = false;
8653 }
8654
8655 gl.deleteSamplers(1, &sampler);
8656 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteSamplers");
8657
8658 return success;
8659 }
8660
8661 /* Coverage test for glBindSampler */
TestCoverageGLCallBindSampler(void)8662 bool ApiCoverageTestCase::TestCoverageGLCallBindSampler(void)
8663 {
8664 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8665 bool success = true;
8666 GLuint sampler;
8667
8668 (void)gl.getError(); // clear error from previous test, if any
8669
8670 gl.genSamplers(1, &sampler);
8671
8672 if (gl.getError() != GL_NO_ERROR)
8673 {
8674 tcu_fail_msg("ApiCoverageTestCase::BindSampler", "Could not create a sampler.");
8675 success = false;
8676 }
8677
8678 gl.bindSampler(0, sampler);
8679
8680 if (gl.getError() != GL_NO_ERROR)
8681 {
8682 tcu_fail_msg("ApiCoverageTestCase::BindSampler", "Failed.");
8683 success = false;
8684 }
8685
8686 gl.deleteSamplers(1, &sampler);
8687 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteSamplers");
8688
8689 return success;
8690 }
8691
8692 /* Coverage test for glSamplerParameteri */
TestCoverageGLCallSamplerParameteri(void)8693 bool ApiCoverageTestCase::TestCoverageGLCallSamplerParameteri(void)
8694 {
8695 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8696 bool success = true;
8697 GLuint sampler;
8698
8699 (void)gl.getError(); // clear error from previous test, if any
8700
8701 gl.genSamplers(1, &sampler);
8702
8703 if (gl.getError() != GL_NO_ERROR)
8704 {
8705 tcu_fail_msg("ApiCoverageTestCase::SamplerParameteri", "Could not create a sampler.");
8706 success = false;
8707 }
8708
8709 gl.samplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
8710
8711 if (gl.getError() != GL_NO_ERROR)
8712 {
8713 tcu_fail_msg("ApiCoverageTestCase::SamplerParameteri", "Failed.");
8714 success = false;
8715 }
8716
8717 gl.deleteSamplers(1, &sampler);
8718 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteSamplers");
8719
8720 return success;
8721 }
8722
8723 /* Coverage test for glSamplerParameteriv */
TestCoverageGLCallSamplerParameteriv(void)8724 bool ApiCoverageTestCase::TestCoverageGLCallSamplerParameteriv(void)
8725 {
8726 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8727 bool success = true;
8728 GLuint sampler;
8729 GLint param = GL_REPEAT;
8730
8731 (void)gl.getError(); // clear error from previous test, if any
8732
8733 gl.genSamplers(1, &sampler);
8734
8735 if (gl.getError() != GL_NO_ERROR)
8736 {
8737 tcu_fail_msg("ApiCoverageTestCase::SamplerParameteriv", "Could not create a sampler.");
8738 success = false;
8739 }
8740
8741 gl.samplerParameteriv(sampler, GL_TEXTURE_WRAP_S, ¶m);
8742
8743 if (gl.getError() != GL_NO_ERROR)
8744 {
8745 tcu_fail_msg("ApiCoverageTestCase::SamplerParameteriv", "Failed.");
8746 success = false;
8747 }
8748
8749 gl.deleteSamplers(1, &sampler);
8750 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteSamplers");
8751
8752 return success;
8753 }
8754
8755 /* Coverage test for glSamplerParameterf */
TestCoverageGLCallSamplerParameterf(void)8756 bool ApiCoverageTestCase::TestCoverageGLCallSamplerParameterf(void)
8757 {
8758 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8759 bool success = true;
8760 GLuint sampler;
8761 GLint parami = GL_MIRRORED_REPEAT;
8762
8763 (void)gl.getError(); // clear error from previous test, if any
8764
8765 gl.genSamplers(1, &sampler);
8766
8767 if (gl.getError() != GL_NO_ERROR)
8768 {
8769 tcu_fail_msg("ApiCoverageTestCase::SamplerParameterf", "Could not create a sampler.");
8770 success = false;
8771 }
8772
8773 gl.samplerParameterf(sampler, GL_TEXTURE_WRAP_R, (GLfloat)parami);
8774
8775 if (gl.getError() != GL_NO_ERROR)
8776 {
8777 tcu_fail_msg("ApiCoverageTestCase::SamplerParameterf", "Failed.");
8778 success = false;
8779 }
8780
8781 gl.deleteSamplers(1, &sampler);
8782 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteSamplers");
8783
8784 return success;
8785 }
8786
8787 /* Coverage test for glSamplerParameterfv */
TestCoverageGLCallSamplerParameterfv(void)8788 bool ApiCoverageTestCase::TestCoverageGLCallSamplerParameterfv(void)
8789 {
8790 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8791 bool success = true;
8792 GLuint sampler;
8793 GLint parami = GL_NEAREST;
8794 GLfloat param = (GLfloat)parami;
8795 GLfloat *params = ¶m;
8796
8797 (void)gl.getError(); // clear error from previous test, if any
8798
8799 gl.genSamplers(1, &sampler);
8800
8801 if (gl.getError() != GL_NO_ERROR)
8802 {
8803 tcu_fail_msg("ApiCoverageTestCase::SamplerParameterfv", "Could not create a sampler.");
8804 success = false;
8805 }
8806
8807 gl.samplerParameterfv(sampler, GL_TEXTURE_MIN_FILTER, params);
8808
8809 if (gl.getError() != GL_NO_ERROR)
8810 {
8811 tcu_fail_msg("ApiCoverageTestCase::SamplerParameterfv", "Failed.");
8812 success = false;
8813 }
8814
8815 gl.deleteSamplers(1, &sampler);
8816 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteSamplers");
8817
8818 return success;
8819 }
8820 /* Coverage test for glGetSamplerParameteriv */
TestCoverageGLCallGetSamplerParameteriv(void)8821 bool ApiCoverageTestCase::TestCoverageGLCallGetSamplerParameteriv(void)
8822 {
8823 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8824 bool success = true;
8825 GLuint sampler;
8826 GLint param;
8827
8828 (void)gl.getError(); // clear error from previous test, if any
8829
8830 gl.genSamplers(1, &sampler);
8831
8832 if (gl.getError() != GL_NO_ERROR)
8833 {
8834 tcu_fail_msg("ApiCoverageTestCase::GetSamplerParameteriv", "Could not create a sampler.");
8835 success = false;
8836 }
8837
8838 gl.getSamplerParameteriv(sampler, GL_TEXTURE_MAG_FILTER, ¶m);
8839
8840 if (gl.getError() != GL_NO_ERROR)
8841 {
8842 tcu_fail_msg("ApiCoverageTestCase::GetSamplerParameteriv", "Failed.");
8843 success = false;
8844 }
8845
8846 gl.deleteSamplers(1, &sampler);
8847 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteSamplers");
8848
8849 return success;
8850 }
8851
8852 /* Coverage test for glGetSamplerParameterfv */
TestCoverageGLCallGetSamplerParameterfv(void)8853 bool ApiCoverageTestCase::TestCoverageGLCallGetSamplerParameterfv(void)
8854 {
8855 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8856 bool success = true;
8857 GLuint sampler;
8858 GLfloat param;
8859
8860 (void)gl.getError(); // clear error from previous test, if any
8861
8862 gl.genSamplers(1, &sampler);
8863
8864 if (gl.getError() != GL_NO_ERROR)
8865 {
8866 tcu_fail_msg("ApiCoverageTestCase::GetSamplerParameterfv", "Could not create a sampler.");
8867 success = false;
8868 }
8869
8870 gl.getSamplerParameterfv(sampler, GL_TEXTURE_COMPARE_FUNC, ¶m);
8871
8872 if (gl.getError() != GL_NO_ERROR)
8873 {
8874 tcu_fail_msg("ApiCoverageTestCase::GetSamplerParameterfv", "Failed.");
8875 success = false;
8876 }
8877
8878 gl.deleteSamplers(1, &sampler);
8879 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteSamplers");
8880
8881 return success;
8882 }
8883
8884 /* Coverage test for glInvalidateFramebuffer */
TestCoverageGLCallInvalidateFramebuffer(void)8885 bool ApiCoverageTestCase::TestCoverageGLCallInvalidateFramebuffer(void)
8886 {
8887 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8888 bool success = true;
8889 GLint max = 0;
8890 GLenum attachment;
8891 int i;
8892 GLuint f;
8893
8894 for (i = 0; ea_InvalidateFramebuffer[i].value != -1; i++)
8895 {
8896 gl.invalidateFramebuffer(ea_InvalidateFramebuffer[i].value, 0, NULL);
8897
8898 if (gl.getError() != GL_NO_ERROR)
8899 {
8900 tcu_fail_msg("ApiCoverageTestCase::InvalidateFramebuffer", "Failed.");
8901 success = false;
8902 break;
8903 }
8904 }
8905
8906 gl.getIntegerv(GL_MAX_COLOR_ATTACHMENTS, &max);
8907 GLU_EXPECT_NO_ERROR(gl.getError(), "getIntegerv");
8908 (void)gl.getError();
8909 attachment = GL_COLOR_ATTACHMENT0 + max;
8910
8911 gl.genFramebuffers(1, &f);
8912 GLU_EXPECT_NO_ERROR(gl.getError(), "genFramebuffers");
8913 gl.bindFramebuffer(GL_FRAMEBUFFER, f);
8914 GLU_EXPECT_NO_ERROR(gl.getError(), "bindFramebuffer");
8915
8916 gl.invalidateFramebuffer(GL_FRAMEBUFFER, 1, &attachment);
8917 if (gl.getError() != GL_INVALID_OPERATION)
8918 {
8919 tcu_fail_msg("ApiCoverageTestCase::InvalidateFramebuffer", "Failed.");
8920 success = false;
8921 }
8922 gl.deleteFramebuffers(1, &f);
8923 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteFramebuffers");
8924
8925 return success;
8926 }
8927
8928 /* Coverage test for glInvalidateSubFramebuffer */
TestCoverageGLCallInvalidateSubFramebuffer(void)8929 bool ApiCoverageTestCase::TestCoverageGLCallInvalidateSubFramebuffer(void)
8930 {
8931 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8932 bool success = true;
8933 int i;
8934
8935 for (i = 0; ea_InvalidateFramebuffer[i].value != -1; i++)
8936 {
8937 gl.invalidateSubFramebuffer(ea_InvalidateFramebuffer[i].value, 0, NULL, 0, 0, 1, 1);
8938
8939 if (gl.getError() != GL_NO_ERROR)
8940 {
8941 tcu_fail_msg("ApiCoverageTestCase::InvalidateSubFramebuffer", "Failed.");
8942 success = false;
8943 break;
8944 }
8945 }
8946
8947 return success;
8948 }
8949
TestCoverageGLCallBindTransformFeedback(void)8950 bool ApiCoverageTestCase::TestCoverageGLCallBindTransformFeedback(void)
8951 {
8952 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8953 bool success = true;
8954 GLint program = 0;
8955 GLuint tobj = 0;
8956
8957 (void)gl.getError(); // clear error from previous test, if any
8958
8959 program = createDefaultProgram(1);
8960
8961 if (program == -1)
8962 {
8963 tcu_fail_msg("ApiCoverageTestCase::BeginTransformFeedback", "Program create Failed");
8964 return false;
8965 }
8966
8967 gl.genTransformFeedbacks(1, &tobj);
8968
8969 if (gl.getError() != GL_NO_ERROR)
8970 {
8971 tcu_fail_msg("ApiCoverageTestCase::BindTransformFeedback", "Failed to create transform feedback object.");
8972 success = false;
8973 }
8974
8975 gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, tobj);
8976
8977 if (gl.getError() != GL_NO_ERROR)
8978 {
8979 tcu_fail_msg("ApiCoverageTestCase::BindTransformFeedback", "Failed.");
8980 success = false;
8981 }
8982
8983 gl.deleteTransformFeedbacks(1, &tobj);
8984 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteTransformFeedbacks");
8985 gl.deleteProgram((GLuint)program);
8986 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
8987
8988 return success;
8989 }
8990
8991 /* Coverage test for glDeleteTransformFeedbacks */
TestCoverageGLCallDeleteTransformFeedbacks(void)8992 bool ApiCoverageTestCase::TestCoverageGLCallDeleteTransformFeedbacks(void)
8993 {
8994 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
8995 bool success = true;
8996 GLint program = 0;
8997 GLuint tobj[2] = {0, 0};
8998
8999 (void)gl.getError(); // clear error from previous test, if any
9000
9001 program = createDefaultProgram(1);
9002
9003 if (program == -1)
9004 {
9005 tcu_fail_msg("ApiCoverageTestCase::DeleteTransformFeedbacks", "Program create Failed");
9006 return false;
9007 }
9008
9009 gl.genTransformFeedbacks(2, tobj);
9010
9011 if (gl.getError() != GL_NO_ERROR)
9012 {
9013 tcu_fail_msg("ApiCoverageTestCase::DeleteTransformFeedbacks", "Failed to create transform feedback object.");
9014 success = false;
9015 }
9016
9017 gl.deleteTransformFeedbacks(2, tobj);
9018
9019 if (gl.getError() != GL_NO_ERROR)
9020 {
9021 tcu_fail_msg("ApiCoverageTestCase::DeleteTransformFeedbacks", "Failed.");
9022 success = false;
9023 }
9024
9025 gl.deleteProgram((GLuint)program);
9026 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
9027
9028 return success;
9029 }
9030
9031 /* Coverage test for glGenTransformFeedbacks */
TestCoverageGLCallGenTransformFeedbacks(void)9032 bool ApiCoverageTestCase::TestCoverageGLCallGenTransformFeedbacks(void)
9033 {
9034 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
9035 bool success = true;
9036 GLint program = 0;
9037 GLuint tobj[2] = {0, 0};
9038
9039 (void)gl.getError(); // clear error from previous test, if any
9040
9041 program = createDefaultProgram(1);
9042
9043 if (program == -1)
9044 {
9045 tcu_fail_msg("ApiCoverageTestCase::GenTransformFeedbacks", "Program create Failed");
9046 return false;
9047 }
9048
9049 gl.genTransformFeedbacks(2, tobj);
9050
9051 if (gl.getError() != GL_NO_ERROR)
9052 {
9053 tcu_fail_msg("ApiCoverageTestCase::GenTransformFeedbacks", "Failed.");
9054 success = false;
9055 }
9056
9057 gl.deleteTransformFeedbacks(2, tobj);
9058 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteTransformFeedbacks");
9059 gl.deleteProgram((GLuint)program);
9060 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
9061
9062 return success;
9063 }
9064
9065 /* Coverage test for glIsTransformFeedback */
TestCoverageGLCallIsTransformFeedback(void)9066 bool ApiCoverageTestCase::TestCoverageGLCallIsTransformFeedback(void)
9067 {
9068 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
9069 bool success = true;
9070 GLint program = 0;
9071 GLuint tobj = 0;
9072
9073 (void)gl.getError(); // clear error from previous test, if any
9074
9075 program = createDefaultProgram(1);
9076
9077 if (program == -1)
9078 {
9079 tcu_fail_msg("ApiCoverageTestCase::IsTransformFeedback", "Program create Failed");
9080 return false;
9081 }
9082
9083 gl.genTransformFeedbacks(1, &tobj);
9084
9085 if (gl.getError() != GL_NO_ERROR)
9086 {
9087 tcu_fail_msg("ApiCoverageTestCase::IsTransformFeedback", "Failed to create transform feedback object.");
9088 success = false;
9089 }
9090
9091 if ((glIsTransformFeedback(tobj) != GL_FALSE) || (gl.getError() != GL_NO_ERROR))
9092 {
9093 tcu_fail_msg("ApiCoverageTestCase::IsTransformFeedback", "Failed.");
9094 success = false;
9095 }
9096
9097 gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, tobj);
9098 GLU_EXPECT_NO_ERROR(gl.getError(), "bindTransformFeedback");
9099 if ((gl.isTransformFeedback(tobj) != GL_TRUE) || (gl.getError() != GL_NO_ERROR))
9100 {
9101 tcu_fail_msg("ApiCoverageTestCase::IsTransformFeedback", "Failed.");
9102 success = false;
9103 }
9104
9105 gl.deleteTransformFeedbacks(1, &tobj);
9106 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteTransformFeedbacks");
9107 gl.deleteProgram((GLuint)program);
9108 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
9109
9110 return success;
9111 }
9112
9113 /* Coverage test for glPauseTransformFeedback */
TestCoverageGLCallPauseTransformFeedback(void)9114 bool ApiCoverageTestCase::TestCoverageGLCallPauseTransformFeedback(void)
9115 {
9116 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
9117 bool success = true;
9118 GLint program = 0;
9119 GLuint tobj = 0, tbufobj = 0;
9120
9121 (void)gl.getError(); // clear error from previous test, if any
9122
9123 program = createDefaultProgram(1);
9124
9125 if (program == -1)
9126 {
9127 tcu_fail_msg("ApiCoverageTestCase::PauseTransformFeedback", "Program create Failed");
9128 return false;
9129 }
9130
9131 gl.genTransformFeedbacks(1, &tobj);
9132 GLU_EXPECT_NO_ERROR(gl.getError(), "genTransformFeedbacks");
9133 gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, tobj);
9134 GLU_EXPECT_NO_ERROR(gl.getError(), "bindTransformFeedback");
9135 gl.genBuffers(1, &tbufobj);
9136 GLU_EXPECT_NO_ERROR(gl.getError(), "genBuffers");
9137 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tbufobj);
9138 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBufferBase");
9139 gl.beginTransformFeedback(GL_TRIANGLES);
9140
9141 if (gl.getError() != GL_NO_ERROR)
9142 {
9143 tcu_fail_msg("ApiCoverageTestCase::PauseTransformFeedback", "Failed to start transform feedback.");
9144 success = false;
9145 }
9146
9147 gl.pauseTransformFeedback();
9148
9149 if (gl.getError() != GL_NO_ERROR)
9150 {
9151 tcu_fail_msg("ApiCoverageTestCase::PauseTransformFeedback", "Failed.");
9152 success = false;
9153 }
9154
9155 gl.endTransformFeedback();
9156 GLU_EXPECT_NO_ERROR(gl.getError(), "endTransformFeedback");
9157
9158 gl.deleteBuffers(1, &tbufobj);
9159 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
9160 gl.deleteTransformFeedbacks(1, &tobj);
9161 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteTransformFeedbacks");
9162 gl.deleteProgram((GLuint)program);
9163 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
9164
9165 return success;
9166 }
9167
9168 /* Coverage test for glResumeTransformFeedback */
TestCoverageGLCallResumeTransformFeedback(void)9169 bool ApiCoverageTestCase::TestCoverageGLCallResumeTransformFeedback(void)
9170 {
9171 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
9172 bool success = true;
9173 GLint program = 0;
9174 GLuint tobj = 0, tbufobj = 0;
9175
9176 (void)gl.getError(); // clear error from previous test, if any
9177
9178 program = createDefaultProgram(1);
9179
9180 if (program == -1)
9181 {
9182 tcu_fail_msg("ApiCoverageTestCase::ResumeTransformFeedback", "Program create Failed");
9183 return false;
9184 }
9185
9186 gl.genTransformFeedbacks(1, &tobj);
9187 GLU_EXPECT_NO_ERROR(gl.getError(), "genTransformFeedbacks");
9188 gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, tobj);
9189 GLU_EXPECT_NO_ERROR(gl.getError(), "bindTransformFeedback");
9190 gl.genBuffers(1, &tbufobj);
9191 GLU_EXPECT_NO_ERROR(gl.getError(), "genBuffers");
9192 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tbufobj);
9193 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBufferBase");
9194 gl.beginTransformFeedback(GL_TRIANGLES);
9195 GLU_EXPECT_NO_ERROR(gl.getError(), "beginTransformFeedback");
9196 gl.pauseTransformFeedback();
9197
9198 if (gl.getError() != GL_NO_ERROR)
9199 {
9200 tcu_fail_msg("ApiCoverageTestCase::ResumeTransformFeedback", "Failed to start transform feedback.");
9201 success = false;
9202 }
9203
9204 gl.resumeTransformFeedback();
9205
9206 if (gl.getError() != GL_NO_ERROR)
9207 {
9208 tcu_fail_msg("ApiCoverageTestCase::ResumeTransformFeedback", "Failed.");
9209 success = false;
9210 }
9211
9212 gl.endTransformFeedback();
9213 GLU_EXPECT_NO_ERROR(gl.getError(), "endTransformFeedback");
9214
9215 gl.deleteBuffers(1, &tbufobj);
9216 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteBuffers");
9217 gl.deleteTransformFeedbacks(1, &tobj);
9218 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteTransformFeedbacks");
9219 gl.deleteProgram((GLuint)program);
9220 GLU_EXPECT_NO_ERROR(gl.getError(), "deleteProgram");
9221
9222 return success;
9223 }
9224
9225 /**************************************************************************/
9226
9227 /* Coverage tests for OpenGL entry points not shared with OpenGL ES.
9228 ** These are automatically generated stubs intended to fail. They
9229 ** must be filled in with actual test code for each function.
9230 */
9231
9232 /* OpenGL 1.0-2.1 entry points */
9233
9234 /* Coverage test for glPointSize */
9235
9236 /* Enums to test for glPointSize (may not be required) */
9237 struct enumTestRec const ea_PointSize[] = {{"End of List", -1}};
9238
TestCoverageGLCallPointSize(void)9239 bool ApiCoverageTestCase::TestCoverageGLCallPointSize(void)
9240 {
9241 GLuint i;
9242 bool success = true;
9243
9244 /* glPointSize may need to loop over a set of enums doing something with them */
9245 for (i = 0; ea_PointSize[i].value != -1; i++)
9246 {
9247 }
9248
9249 tcu_msg("ApiCoverageTestCase::PointSize", "Coverage test not implemented yet");
9250
9251 return success;
9252 }
9253
9254 /* Coverage test for glPolygonMode */
9255
9256 /* Enums to test for glPolygonMode (may not be required) */
9257 struct enumTestRec const ea_PolygonMode[] = {{"End of List", -1}};
9258
TestCoverageGLCallPolygonMode(void)9259 bool ApiCoverageTestCase::TestCoverageGLCallPolygonMode(void)
9260 {
9261 GLuint i;
9262 bool success = true;
9263
9264 /* glPolygonMode may need to loop over a set of enums doing something with them */
9265 for (i = 0; ea_PolygonMode[i].value != -1; i++)
9266 {
9267 }
9268
9269 tcu_msg("ApiCoverageTestCase::PolygonMode", "Coverage test not implemented yet");
9270
9271 return success;
9272 }
9273
9274 /* Coverage test for glTexImage1D */
9275
9276 /* Enums to test for glTexImage1D (may not be required) */
9277 struct enumTestRec const ea_TexImage1D[] = {{"End of List", -1}};
9278
TestCoverageGLCallTexImage1D(void)9279 bool ApiCoverageTestCase::TestCoverageGLCallTexImage1D(void)
9280 {
9281 GLuint i;
9282 bool success = true;
9283
9284 /* glTexImage1D may need to loop over a set of enums doing something with them */
9285 for (i = 0; ea_TexImage1D[i].value != -1; i++)
9286 {
9287 }
9288
9289 tcu_msg("ApiCoverageTestCase::TexImage1D", "Coverage test not implemented yet");
9290
9291 return success;
9292 }
9293
9294 /* Coverage test for glDrawBuffer */
9295
9296 /* Enums to test for glDrawBuffer (may not be required) */
9297 struct enumTestRec const ea_DrawBuffer[] = {{"End of List", -1}};
9298
TestCoverageGLCallDrawBuffer(void)9299 bool ApiCoverageTestCase::TestCoverageGLCallDrawBuffer(void)
9300 {
9301 GLuint i;
9302 bool success = true;
9303
9304 /* glDrawBuffer may need to loop over a set of enums doing something with them */
9305 for (i = 0; ea_DrawBuffer[i].value != -1; i++)
9306 {
9307 }
9308
9309 tcu_msg("ApiCoverageTestCase::DrawBuffer", "Coverage test not implemented yet");
9310
9311 return success;
9312 }
9313
9314 /* Coverage test for glClearDepth */
9315
9316 /* Enums to test for glClearDepth (may not be required) */
9317 struct enumTestRec const ea_ClearDepth[] = {{"End of List", -1}};
9318
TestCoverageGLCallClearDepth(void)9319 bool ApiCoverageTestCase::TestCoverageGLCallClearDepth(void)
9320 {
9321 GLuint i;
9322 bool success = true;
9323
9324 /* glClearDepth may need to loop over a set of enums doing something with them */
9325 for (i = 0; ea_ClearDepth[i].value != -1; i++)
9326 {
9327 }
9328
9329 tcu_msg("ApiCoverageTestCase::ClearDepth", "Coverage test not implemented yet");
9330
9331 return success;
9332 }
9333
9334 /* Coverage test for glLogicOp */
9335
9336 /* Enums to test for glLogicOp (may not be required) */
9337 struct enumTestRec const ea_LogicOp[] = {{"End of List", -1}};
9338
TestCoverageGLCallLogicOp(void)9339 bool ApiCoverageTestCase::TestCoverageGLCallLogicOp(void)
9340 {
9341 GLuint i;
9342 bool success = true;
9343
9344 /* glLogicOp may need to loop over a set of enums doing something with them */
9345 for (i = 0; ea_LogicOp[i].value != -1; i++)
9346 {
9347 }
9348
9349 tcu_msg("ApiCoverageTestCase::LogicOp", "Coverage test not implemented yet");
9350
9351 return success;
9352 }
9353
9354 /* Coverage test for glPixelStoref */
9355
9356 /* Enums to test for glPixelStoref (may not be required) */
9357 struct enumTestRec const ea_PixelStoref[] = {{"End of List", -1}};
9358
TestCoverageGLCallPixelStoref(void)9359 bool ApiCoverageTestCase::TestCoverageGLCallPixelStoref(void)
9360 {
9361 GLuint i;
9362 bool success = true;
9363
9364 /* glPixelStoref may need to loop over a set of enums doing something with them */
9365 for (i = 0; ea_PixelStoref[i].value != -1; i++)
9366 {
9367 }
9368
9369 tcu_msg("ApiCoverageTestCase::PixelStoref", "Coverage test not implemented yet");
9370
9371 return success;
9372 }
9373
9374 /* Coverage test for glGetDoublev */
9375
9376 /* Enums to test for glGetDoublev (may not be required) */
9377 struct enumTestRec const ea_GetDoublev[] = {{"End of List", -1}};
9378
TestCoverageGLCallGetDoublev(void)9379 bool ApiCoverageTestCase::TestCoverageGLCallGetDoublev(void)
9380 {
9381 GLuint i;
9382 bool success = true;
9383
9384 /* glGetDoublev may need to loop over a set of enums doing something with them */
9385 for (i = 0; ea_GetDoublev[i].value != -1; i++)
9386 {
9387 }
9388
9389 tcu_msg("ApiCoverageTestCase::GetDoublev", "Coverage test not implemented yet");
9390
9391 return success;
9392 }
9393
9394 /* Coverage test for glGetTexImage */
9395
9396 /* Enums to test for glGetTexImage (may not be required) */
9397 struct enumTestRec const ea_GetTexImage[] = {{"End of List", -1}};
9398
TestCoverageGLCallGetTexImage(void)9399 bool ApiCoverageTestCase::TestCoverageGLCallGetTexImage(void)
9400 {
9401 GLuint i;
9402 bool success = true;
9403
9404 /* glGetTexImage may need to loop over a set of enums doing something with them */
9405 for (i = 0; ea_GetTexImage[i].value != -1; i++)
9406 {
9407 }
9408
9409 tcu_msg("ApiCoverageTestCase::GetTexImage", "Coverage test not implemented yet");
9410
9411 return success;
9412 }
9413
9414 /* Coverage test for glGetTexLevelParameterfv */
9415
9416 /* Enums to test for glGetTexLevelParameterfv (may not be required) */
9417 struct enumTestRec const ea_GetTexLevelParameterfv[] = {{"End of List", -1}};
9418
TestCoverageGLCallGetTexLevelParameterfv(void)9419 bool ApiCoverageTestCase::TestCoverageGLCallGetTexLevelParameterfv(void)
9420 {
9421 GLuint i;
9422 bool success = true;
9423
9424 /* glGetTexLevelParameterfv may need to loop over a set of enums doing something with them */
9425 for (i = 0; ea_GetTexLevelParameterfv[i].value != -1; i++)
9426 {
9427 }
9428
9429 tcu_msg("ApiCoverageTestCase::GetTexLevelParameterfv", "Coverage test not implemented yet");
9430
9431 return success;
9432 }
9433
9434 /* Coverage test for glGetTexLevelParameteriv */
9435
9436 /* Enums to test for glGetTexLevelParameteriv (may not be required) */
9437 struct enumTestRec const ea_GetTexLevelParameteriv[] = {{"End of List", -1}};
9438
TestCoverageGLCallGetTexLevelParameteriv(void)9439 bool ApiCoverageTestCase::TestCoverageGLCallGetTexLevelParameteriv(void)
9440 {
9441 GLuint i;
9442 bool success = true;
9443
9444 /* glGetTexLevelParameteriv may need to loop over a set of enums doing something with them */
9445 for (i = 0; ea_GetTexLevelParameteriv[i].value != -1; i++)
9446 {
9447 }
9448
9449 tcu_msg("ApiCoverageTestCase::GetTexLevelParameteriv", "Coverage test not implemented yet");
9450
9451 return success;
9452 }
9453
9454 /* Coverage test for glDepthRange */
9455
9456 /* Enums to test for glDepthRange (may not be required) */
9457 struct enumTestRec const ea_DepthRange[] = {{"End of List", -1}};
9458
TestCoverageGLCallDepthRange(void)9459 bool ApiCoverageTestCase::TestCoverageGLCallDepthRange(void)
9460 {
9461 GLuint i;
9462 bool success = true;
9463
9464 /* glDepthRange may need to loop over a set of enums doing something with them */
9465 for (i = 0; ea_DepthRange[i].value != -1; i++)
9466 {
9467 }
9468
9469 tcu_msg("ApiCoverageTestCase::DepthRange", "Coverage test not implemented yet");
9470
9471 return success;
9472 }
9473
9474 /* Coverage test for glGetPointerv */
9475
9476 /* Enums to test for glGetPointerv (may not be required) */
9477 struct enumTestRec const ea_GetPointerv[] = {{"End of List", -1}};
9478
TestCoverageGLCallGetPointerv(void)9479 bool ApiCoverageTestCase::TestCoverageGLCallGetPointerv(void)
9480 {
9481 GLuint i;
9482 bool success = true;
9483
9484 /* glGetPointerv may need to loop over a set of enums doing something with them */
9485 for (i = 0; ea_GetPointerv[i].value != -1; i++)
9486 {
9487 }
9488
9489 tcu_msg("ApiCoverageTestCase::GetPointerv", "Coverage test not implemented yet");
9490
9491 return success;
9492 }
9493
9494 /* Coverage test for glCopyTexImage1D */
9495
9496 /* Enums to test for glCopyTexImage1D (may not be required) */
9497 struct enumTestRec const ea_CopyTexImage1D[] = {{"End of List", -1}};
9498
TestCoverageGLCallCopyTexImage1D(void)9499 bool ApiCoverageTestCase::TestCoverageGLCallCopyTexImage1D(void)
9500 {
9501 GLuint i;
9502 bool success = true;
9503
9504 /* glCopyTexImage1D may need to loop over a set of enums doing something with them */
9505 for (i = 0; ea_CopyTexImage1D[i].value != -1; i++)
9506 {
9507 }
9508
9509 tcu_msg("ApiCoverageTestCase::CopyTexImage1D", "Coverage test not implemented yet");
9510
9511 return success;
9512 }
9513
9514 /* Coverage test for glCopyTexSubImage1D */
9515
9516 /* Enums to test for glCopyTexSubImage1D (may not be required) */
9517 struct enumTestRec const ea_CopyTexSubImage1D[] = {{"End of List", -1}};
9518
TestCoverageGLCallCopyTexSubImage1D(void)9519 bool ApiCoverageTestCase::TestCoverageGLCallCopyTexSubImage1D(void)
9520 {
9521 GLuint i;
9522 bool success = true;
9523
9524 /* glCopyTexSubImage1D may need to loop over a set of enums doing something with them */
9525 for (i = 0; ea_CopyTexSubImage1D[i].value != -1; i++)
9526 {
9527 }
9528
9529 tcu_msg("ApiCoverageTestCase::CopyTexSubImage1D", "Coverage test not implemented yet");
9530
9531 return success;
9532 }
9533
9534 /* Coverage test for glTexSubImage1D */
9535
9536 /* Enums to test for glTexSubImage1D (may not be required) */
9537 struct enumTestRec const ea_TexSubImage1D[] = {{"End of List", -1}};
9538
TestCoverageGLCallTexSubImage1D(void)9539 bool ApiCoverageTestCase::TestCoverageGLCallTexSubImage1D(void)
9540 {
9541 GLuint i;
9542 bool success = true;
9543
9544 /* glTexSubImage1D may need to loop over a set of enums doing something with them */
9545 for (i = 0; ea_TexSubImage1D[i].value != -1; i++)
9546 {
9547 }
9548
9549 tcu_msg("ApiCoverageTestCase::TexSubImage1D", "Coverage test not implemented yet");
9550
9551 return success;
9552 }
9553
9554 /* Coverage test for glCompressedTexImage1D */
9555
9556 /* Enums to test for glCompressedTexImage1D (may not be required) */
9557 struct enumTestRec const ea_CompressedTexImage1D[] = {{"End of List", -1}};
9558
TestCoverageGLCallCompressedTexImage1D(void)9559 bool ApiCoverageTestCase::TestCoverageGLCallCompressedTexImage1D(void)
9560 {
9561 GLuint i;
9562 bool success = true;
9563
9564 /* glCompressedTexImage1D may need to loop over a set of enums doing something with them */
9565 for (i = 0; ea_CompressedTexImage1D[i].value != -1; i++)
9566 {
9567 }
9568
9569 tcu_msg("ApiCoverageTestCase::CompressedTexImage1D", "Coverage test not implemented yet");
9570
9571 return success;
9572 }
9573
9574 /* Coverage test for glCompressedTexSubImage1D */
9575
9576 /* Enums to test for glCompressedTexSubImage1D (may not be required) */
9577 struct enumTestRec const ea_CompressedTexSubImage1D[] = {{"End of List", -1}};
9578
TestCoverageGLCallCompressedTexSubImage1D(void)9579 bool ApiCoverageTestCase::TestCoverageGLCallCompressedTexSubImage1D(void)
9580 {
9581 GLuint i;
9582 bool success = true;
9583
9584 /* glCompressedTexSubImage1D may need to loop over a set of enums doing something with them */
9585 for (i = 0; ea_CompressedTexSubImage1D[i].value != -1; i++)
9586 {
9587 }
9588
9589 tcu_msg("ApiCoverageTestCase::CompressedTexSubImage1D", "Coverage test not implemented yet");
9590
9591 return success;
9592 }
9593
9594 /* Coverage test for glGetCompressedTexImage */
9595
9596 /* Enums to test for glGetCompressedTexImage (may not be required) */
9597 struct enumTestRec const ea_GetCompressedTexImage[] = {{"End of List", -1}};
9598
TestCoverageGLCallGetCompressedTexImage(void)9599 bool ApiCoverageTestCase::TestCoverageGLCallGetCompressedTexImage(void)
9600 {
9601 GLuint i;
9602 bool success = true;
9603
9604 /* glGetCompressedTexImage may need to loop over a set of enums doing something with them */
9605 for (i = 0; ea_GetCompressedTexImage[i].value != -1; i++)
9606 {
9607 }
9608
9609 tcu_msg("ApiCoverageTestCase::GetCompressedTexImage", "Coverage test not implemented yet");
9610
9611 return success;
9612 }
9613
9614 /* Coverage test for glMultiDrawArrays */
9615
9616 /* Enums to test for glMultiDrawArrays (may not be required) */
9617 struct enumTestRec const ea_MultiDrawArrays[] = {{"End of List", -1}};
9618
TestCoverageGLCallMultiDrawArrays(void)9619 bool ApiCoverageTestCase::TestCoverageGLCallMultiDrawArrays(void)
9620 {
9621 GLuint i;
9622 bool success = true;
9623
9624 /* glMultiDrawArrays may need to loop over a set of enums doing something with them */
9625 for (i = 0; ea_MultiDrawArrays[i].value != -1; i++)
9626 {
9627 }
9628
9629 tcu_msg("ApiCoverageTestCase::MultiDrawArrays", "Coverage test not implemented yet");
9630
9631 return success;
9632 }
9633
9634 /* Coverage test for glMultiDrawElements */
9635
9636 /* Enums to test for glMultiDrawElements (may not be required) */
9637 struct enumTestRec const ea_MultiDrawElements[] = {{"End of List", -1}};
9638
TestCoverageGLCallMultiDrawElements(void)9639 bool ApiCoverageTestCase::TestCoverageGLCallMultiDrawElements(void)
9640 {
9641 GLuint i;
9642 bool success = true;
9643
9644 /* glMultiDrawElements may need to loop over a set of enums doing something with them */
9645 for (i = 0; ea_MultiDrawElements[i].value != -1; i++)
9646 {
9647 }
9648
9649 tcu_msg("ApiCoverageTestCase::MultiDrawElements", "Coverage test not implemented yet");
9650
9651 return success;
9652 }
9653
9654 /* Coverage test for glPointParameterf */
9655
9656 /* Enums to test for glPointParameterf (may not be required) */
9657 struct enumTestRec const ea_PointParameterf[] = {{"End of List", -1}};
9658
TestCoverageGLCallPointParameterf(void)9659 bool ApiCoverageTestCase::TestCoverageGLCallPointParameterf(void)
9660 {
9661 GLuint i;
9662 bool success = true;
9663
9664 /* glPointParameterf may need to loop over a set of enums doing something with them */
9665 for (i = 0; ea_PointParameterf[i].value != -1; i++)
9666 {
9667 }
9668
9669 tcu_msg("ApiCoverageTestCase::PointParameterf", "Coverage test not implemented yet");
9670
9671 return success;
9672 }
9673
9674 /* Coverage test for glPointParameterfv */
9675
9676 /* Enums to test for glPointParameterfv (may not be required) */
9677 struct enumTestRec const ea_PointParameterfv[] = {{"End of List", -1}};
9678
TestCoverageGLCallPointParameterfv(void)9679 bool ApiCoverageTestCase::TestCoverageGLCallPointParameterfv(void)
9680 {
9681 GLuint i;
9682 bool success = true;
9683
9684 /* glPointParameterfv may need to loop over a set of enums doing something with them */
9685 for (i = 0; ea_PointParameterfv[i].value != -1; i++)
9686 {
9687 }
9688
9689 tcu_msg("ApiCoverageTestCase::PointParameterfv", "Coverage test not implemented yet");
9690
9691 return success;
9692 }
9693
9694 /* Coverage test for glPointParameteri */
9695
9696 /* Enums to test for glPointParameteri (may not be required) */
9697 struct enumTestRec const ea_PointParameteri[] = {{"End of List", -1}};
9698
TestCoverageGLCallPointParameteri(void)9699 bool ApiCoverageTestCase::TestCoverageGLCallPointParameteri(void)
9700 {
9701 GLuint i;
9702 bool success = true;
9703
9704 /* glPointParameteri may need to loop over a set of enums doing something with them */
9705 for (i = 0; ea_PointParameteri[i].value != -1; i++)
9706 {
9707 }
9708
9709 tcu_msg("ApiCoverageTestCase::PointParameteri", "Coverage test not implemented yet");
9710
9711 return success;
9712 }
9713
9714 /* Coverage test for glPointParameteriv */
9715
9716 /* Enums to test for glPointParameteriv (may not be required) */
9717 struct enumTestRec const ea_PointParameteriv[] = {{"End of List", -1}};
9718
TestCoverageGLCallPointParameteriv(void)9719 bool ApiCoverageTestCase::TestCoverageGLCallPointParameteriv(void)
9720 {
9721 GLuint i;
9722 bool success = true;
9723
9724 /* glPointParameteriv may need to loop over a set of enums doing something with them */
9725 for (i = 0; ea_PointParameteriv[i].value != -1; i++)
9726 {
9727 }
9728
9729 tcu_msg("ApiCoverageTestCase::PointParameteriv", "Coverage test not implemented yet");
9730
9731 return success;
9732 }
9733
9734 /* Coverage test for glGetQueryObjectiv */
9735
9736 /* Enums to test for glGetQueryObjectiv (may not be required) */
9737 struct enumTestRec const ea_GetQueryObjectiv[] = {{"End of List", -1}};
9738
TestCoverageGLCallGetQueryObjectiv(void)9739 bool ApiCoverageTestCase::TestCoverageGLCallGetQueryObjectiv(void)
9740 {
9741 GLuint i;
9742 bool success = true;
9743
9744 /* glGetQueryObjectiv may need to loop over a set of enums doing something with them */
9745 for (i = 0; ea_GetQueryObjectiv[i].value != -1; i++)
9746 {
9747 }
9748
9749 tcu_msg("ApiCoverageTestCase::GetQueryObjectiv", "Coverage test not implemented yet");
9750
9751 return success;
9752 }
9753
9754 /* Coverage test for glGetBufferSubData */
9755
9756 /* Enums to test for glGetBufferSubData (may not be required) */
9757 struct enumTestRec const ea_GetBufferSubData[] = {{"End of List", -1}};
9758
TestCoverageGLCallGetBufferSubData(void)9759 bool ApiCoverageTestCase::TestCoverageGLCallGetBufferSubData(void)
9760 {
9761 GLuint i;
9762 bool success = true;
9763
9764 /* glGetBufferSubData may need to loop over a set of enums doing something with them */
9765 for (i = 0; ea_GetBufferSubData[i].value != -1; i++)
9766 {
9767 }
9768
9769 tcu_msg("ApiCoverageTestCase::GetBufferSubData", "Coverage test not implemented yet");
9770
9771 return success;
9772 }
9773
9774 /* Coverage test for glMapBuffer */
9775
9776 /* Enums to test for glMapBuffer (may not be required) */
9777 struct enumTestRec const ea_MapBuffer[] = {{"End of List", -1}};
9778
TestCoverageGLCallMapBuffer(void)9779 bool ApiCoverageTestCase::TestCoverageGLCallMapBuffer(void)
9780 {
9781 GLuint i;
9782 bool success = true;
9783
9784 /* glMapBuffer may need to loop over a set of enums doing something with them */
9785 for (i = 0; ea_MapBuffer[i].value != -1; i++)
9786 {
9787 }
9788
9789 tcu_msg("ApiCoverageTestCase::MapBuffer", "Coverage test not implemented yet");
9790
9791 return success;
9792 }
9793
9794 /* Coverage test for glGetVertexAttribdv */
9795
9796 /* Enums to test for glGetVertexAttribdv (may not be required) */
9797 struct enumTestRec const ea_GetVertexAttribdv[] = {{"End of List", -1}};
9798
TestCoverageGLCallGetVertexAttribdv(void)9799 bool ApiCoverageTestCase::TestCoverageGLCallGetVertexAttribdv(void)
9800 {
9801 GLuint i;
9802 bool success = true;
9803
9804 /* glGetVertexAttribdv may need to loop over a set of enums doing something with them */
9805 for (i = 0; ea_GetVertexAttribdv[i].value != -1; i++)
9806 {
9807 }
9808
9809 tcu_msg("ApiCoverageTestCase::GetVertexAttribdv", "Coverage test not implemented yet");
9810
9811 return success;
9812 }
9813
9814 /* Coverage test for glVertexAttrib1d */
9815
9816 /* Enums to test for glVertexAttrib1d (may not be required) */
9817 struct enumTestRec const ea_VertexAttrib1d[] = {{"End of List", -1}};
9818
TestCoverageGLCallVertexAttrib1d(void)9819 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib1d(void)
9820 {
9821 GLuint i;
9822 bool success = true;
9823
9824 /* glVertexAttrib1d may need to loop over a set of enums doing something with them */
9825 for (i = 0; ea_VertexAttrib1d[i].value != -1; i++)
9826 {
9827 }
9828
9829 tcu_msg("ApiCoverageTestCase::VertexAttrib1d", "Coverage test not implemented yet");
9830
9831 return success;
9832 }
9833
9834 /* Coverage test for glVertexAttrib1dv */
9835
9836 /* Enums to test for glVertexAttrib1dv (may not be required) */
9837 struct enumTestRec const ea_VertexAttrib1dv[] = {{"End of List", -1}};
9838
TestCoverageGLCallVertexAttrib1dv(void)9839 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib1dv(void)
9840 {
9841 GLuint i;
9842 bool success = true;
9843
9844 /* glVertexAttrib1dv may need to loop over a set of enums doing something with them */
9845 for (i = 0; ea_VertexAttrib1dv[i].value != -1; i++)
9846 {
9847 }
9848
9849 tcu_msg("ApiCoverageTestCase::VertexAttrib1dv", "Coverage test not implemented yet");
9850
9851 return success;
9852 }
9853
9854 /* Coverage test for glVertexAttrib1s */
9855
9856 /* Enums to test for glVertexAttrib1s (may not be required) */
9857 struct enumTestRec const ea_VertexAttrib1s[] = {{"End of List", -1}};
9858
TestCoverageGLCallVertexAttrib1s(void)9859 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib1s(void)
9860 {
9861 GLuint i;
9862 bool success = true;
9863
9864 /* glVertexAttrib1s may need to loop over a set of enums doing something with them */
9865 for (i = 0; ea_VertexAttrib1s[i].value != -1; i++)
9866 {
9867 }
9868
9869 tcu_msg("ApiCoverageTestCase::VertexAttrib1s", "Coverage test not implemented yet");
9870
9871 return success;
9872 }
9873
9874 /* Coverage test for glVertexAttrib1sv */
9875
9876 /* Enums to test for glVertexAttrib1sv (may not be required) */
9877 struct enumTestRec const ea_VertexAttrib1sv[] = {{"End of List", -1}};
9878
TestCoverageGLCallVertexAttrib1sv(void)9879 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib1sv(void)
9880 {
9881 GLuint i;
9882 bool success = true;
9883
9884 /* glVertexAttrib1sv may need to loop over a set of enums doing something with them */
9885 for (i = 0; ea_VertexAttrib1sv[i].value != -1; i++)
9886 {
9887 }
9888
9889 tcu_msg("ApiCoverageTestCase::VertexAttrib1sv", "Coverage test not implemented yet");
9890
9891 return success;
9892 }
9893
9894 /* Coverage test for glVertexAttrib2d */
9895
9896 /* Enums to test for glVertexAttrib2d (may not be required) */
9897 struct enumTestRec const ea_VertexAttrib2d[] = {{"End of List", -1}};
9898
TestCoverageGLCallVertexAttrib2d(void)9899 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib2d(void)
9900 {
9901 GLuint i;
9902 bool success = true;
9903
9904 /* glVertexAttrib2d may need to loop over a set of enums doing something with them */
9905 for (i = 0; ea_VertexAttrib2d[i].value != -1; i++)
9906 {
9907 }
9908
9909 tcu_msg("ApiCoverageTestCase::VertexAttrib2d", "Coverage test not implemented yet");
9910
9911 return success;
9912 }
9913
9914 /* Coverage test for glVertexAttrib2dv */
9915
9916 /* Enums to test for glVertexAttrib2dv (may not be required) */
9917 struct enumTestRec const ea_VertexAttrib2dv[] = {{"End of List", -1}};
9918
TestCoverageGLCallVertexAttrib2dv(void)9919 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib2dv(void)
9920 {
9921 GLuint i;
9922 bool success = true;
9923
9924 /* glVertexAttrib2dv may need to loop over a set of enums doing something with them */
9925 for (i = 0; ea_VertexAttrib2dv[i].value != -1; i++)
9926 {
9927 }
9928
9929 tcu_msg("ApiCoverageTestCase::VertexAttrib2dv", "Coverage test not implemented yet");
9930
9931 return success;
9932 }
9933
9934 /* Coverage test for glVertexAttrib2s */
9935
9936 /* Enums to test for glVertexAttrib2s (may not be required) */
9937 struct enumTestRec const ea_VertexAttrib2s[] = {{"End of List", -1}};
9938
TestCoverageGLCallVertexAttrib2s(void)9939 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib2s(void)
9940 {
9941 GLuint i;
9942 bool success = true;
9943
9944 /* glVertexAttrib2s may need to loop over a set of enums doing something with them */
9945 for (i = 0; ea_VertexAttrib2s[i].value != -1; i++)
9946 {
9947 }
9948
9949 tcu_msg("ApiCoverageTestCase::VertexAttrib2s", "Coverage test not implemented yet");
9950
9951 return success;
9952 }
9953
9954 /* Coverage test for glVertexAttrib2sv */
9955
9956 /* Enums to test for glVertexAttrib2sv (may not be required) */
9957 struct enumTestRec const ea_VertexAttrib2sv[] = {{"End of List", -1}};
9958
TestCoverageGLCallVertexAttrib2sv(void)9959 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib2sv(void)
9960 {
9961 GLuint i;
9962 bool success = true;
9963
9964 /* glVertexAttrib2sv may need to loop over a set of enums doing something with them */
9965 for (i = 0; ea_VertexAttrib2sv[i].value != -1; i++)
9966 {
9967 }
9968
9969 tcu_msg("ApiCoverageTestCase::VertexAttrib2sv", "Coverage test not implemented yet");
9970
9971 return success;
9972 }
9973
9974 /* Coverage test for glVertexAttrib3d */
9975
9976 /* Enums to test for glVertexAttrib3d (may not be required) */
9977 struct enumTestRec const ea_VertexAttrib3d[] = {{"End of List", -1}};
9978
TestCoverageGLCallVertexAttrib3d(void)9979 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib3d(void)
9980 {
9981 GLuint i;
9982 bool success = true;
9983
9984 /* glVertexAttrib3d may need to loop over a set of enums doing something with them */
9985 for (i = 0; ea_VertexAttrib3d[i].value != -1; i++)
9986 {
9987 }
9988
9989 tcu_msg("ApiCoverageTestCase::VertexAttrib3d", "Coverage test not implemented yet");
9990
9991 return success;
9992 }
9993
9994 /* Coverage test for glVertexAttrib3dv */
9995
9996 /* Enums to test for glVertexAttrib3dv (may not be required) */
9997 struct enumTestRec const ea_VertexAttrib3dv[] = {{"End of List", -1}};
9998
TestCoverageGLCallVertexAttrib3dv(void)9999 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib3dv(void)
10000 {
10001 GLuint i;
10002 bool success = true;
10003
10004 /* glVertexAttrib3dv may need to loop over a set of enums doing something with them */
10005 for (i = 0; ea_VertexAttrib3dv[i].value != -1; i++)
10006 {
10007 }
10008
10009 tcu_msg("ApiCoverageTestCase::VertexAttrib3dv", "Coverage test not implemented yet");
10010
10011 return success;
10012 }
10013
10014 /* Coverage test for glVertexAttrib3s */
10015
10016 /* Enums to test for glVertexAttrib3s (may not be required) */
10017 struct enumTestRec const ea_VertexAttrib3s[] = {{"End of List", -1}};
10018
TestCoverageGLCallVertexAttrib3s(void)10019 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib3s(void)
10020 {
10021 GLuint i;
10022 bool success = true;
10023
10024 /* glVertexAttrib3s may need to loop over a set of enums doing something with them */
10025 for (i = 0; ea_VertexAttrib3s[i].value != -1; i++)
10026 {
10027 }
10028
10029 tcu_msg("ApiCoverageTestCase::VertexAttrib3s", "Coverage test not implemented yet");
10030
10031 return success;
10032 }
10033
10034 /* Coverage test for glVertexAttrib3sv */
10035
10036 /* Enums to test for glVertexAttrib3sv (may not be required) */
10037 struct enumTestRec const ea_VertexAttrib3sv[] = {{"End of List", -1}};
10038
TestCoverageGLCallVertexAttrib3sv(void)10039 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib3sv(void)
10040 {
10041 GLuint i;
10042 bool success = true;
10043
10044 /* glVertexAttrib3sv may need to loop over a set of enums doing something with them */
10045 for (i = 0; ea_VertexAttrib3sv[i].value != -1; i++)
10046 {
10047 }
10048
10049 tcu_msg("ApiCoverageTestCase::VertexAttrib3sv", "Coverage test not implemented yet");
10050
10051 return success;
10052 }
10053
10054 /* Coverage test for glVertexAttrib4Nbv */
10055
10056 /* Enums to test for glVertexAttrib4Nbv (may not be required) */
10057 struct enumTestRec const ea_VertexAttrib4Nbv[] = {{"End of List", -1}};
10058
TestCoverageGLCallVertexAttrib4Nbv(void)10059 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4Nbv(void)
10060 {
10061 GLuint i;
10062 bool success = true;
10063
10064 /* glVertexAttrib4Nbv may need to loop over a set of enums doing something with them */
10065 for (i = 0; ea_VertexAttrib4Nbv[i].value != -1; i++)
10066 {
10067 }
10068
10069 tcu_msg("ApiCoverageTestCase::VertexAttrib4Nbv", "Coverage test not implemented yet");
10070
10071 return success;
10072 }
10073
10074 /* Coverage test for glVertexAttrib4Niv */
10075
10076 /* Enums to test for glVertexAttrib4Niv (may not be required) */
10077 struct enumTestRec const ea_VertexAttrib4Niv[] = {{"End of List", -1}};
10078
TestCoverageGLCallVertexAttrib4Niv(void)10079 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4Niv(void)
10080 {
10081 GLuint i;
10082 bool success = true;
10083
10084 /* glVertexAttrib4Niv may need to loop over a set of enums doing something with them */
10085 for (i = 0; ea_VertexAttrib4Niv[i].value != -1; i++)
10086 {
10087 }
10088
10089 tcu_msg("ApiCoverageTestCase::VertexAttrib4Niv", "Coverage test not implemented yet");
10090
10091 return success;
10092 }
10093
10094 /* Coverage test for glVertexAttrib4Nsv */
10095
10096 /* Enums to test for glVertexAttrib4Nsv (may not be required) */
10097 struct enumTestRec const ea_VertexAttrib4Nsv[] = {{"End of List", -1}};
10098
TestCoverageGLCallVertexAttrib4Nsv(void)10099 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4Nsv(void)
10100 {
10101 GLuint i;
10102 bool success = true;
10103
10104 /* glVertexAttrib4Nsv may need to loop over a set of enums doing something with them */
10105 for (i = 0; ea_VertexAttrib4Nsv[i].value != -1; i++)
10106 {
10107 }
10108
10109 tcu_msg("ApiCoverageTestCase::VertexAttrib4Nsv", "Coverage test not implemented yet");
10110
10111 return success;
10112 }
10113
10114 /* Coverage test for glVertexAttrib4Nub */
10115
10116 /* Enums to test for glVertexAttrib4Nub (may not be required) */
10117 struct enumTestRec const ea_VertexAttrib4Nub[] = {{"End of List", -1}};
10118
TestCoverageGLCallVertexAttrib4Nub(void)10119 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4Nub(void)
10120 {
10121 GLuint i;
10122 bool success = true;
10123
10124 /* glVertexAttrib4Nub may need to loop over a set of enums doing something with them */
10125 for (i = 0; ea_VertexAttrib4Nub[i].value != -1; i++)
10126 {
10127 }
10128
10129 tcu_msg("ApiCoverageTestCase::VertexAttrib4Nub", "Coverage test not implemented yet");
10130
10131 return success;
10132 }
10133
10134 /* Coverage test for glVertexAttrib4Nubv */
10135
10136 /* Enums to test for glVertexAttrib4Nubv (may not be required) */
10137 struct enumTestRec const ea_VertexAttrib4Nubv[] = {{"End of List", -1}};
10138
TestCoverageGLCallVertexAttrib4Nubv(void)10139 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4Nubv(void)
10140 {
10141 GLuint i;
10142 bool success = true;
10143
10144 /* glVertexAttrib4Nubv may need to loop over a set of enums doing something with them */
10145 for (i = 0; ea_VertexAttrib4Nubv[i].value != -1; i++)
10146 {
10147 }
10148
10149 tcu_msg("ApiCoverageTestCase::VertexAttrib4Nubv", "Coverage test not implemented yet");
10150
10151 return success;
10152 }
10153
10154 /* Coverage test for glVertexAttrib4Nuiv */
10155
10156 /* Enums to test for glVertexAttrib4Nuiv (may not be required) */
10157 struct enumTestRec const ea_VertexAttrib4Nuiv[] = {{"End of List", -1}};
10158
TestCoverageGLCallVertexAttrib4Nuiv(void)10159 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4Nuiv(void)
10160 {
10161 GLuint i;
10162 bool success = true;
10163
10164 /* glVertexAttrib4Nuiv may need to loop over a set of enums doing something with them */
10165 for (i = 0; ea_VertexAttrib4Nuiv[i].value != -1; i++)
10166 {
10167 }
10168
10169 tcu_msg("ApiCoverageTestCase::VertexAttrib4Nuiv", "Coverage test not implemented yet");
10170
10171 return success;
10172 }
10173
10174 /* Coverage test for glVertexAttrib4Nusv */
10175
10176 /* Enums to test for glVertexAttrib4Nusv (may not be required) */
10177 struct enumTestRec const ea_VertexAttrib4Nusv[] = {{"End of List", -1}};
10178
TestCoverageGLCallVertexAttrib4Nusv(void)10179 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4Nusv(void)
10180 {
10181 GLuint i;
10182 bool success = true;
10183
10184 /* glVertexAttrib4Nusv may need to loop over a set of enums doing something with them */
10185 for (i = 0; ea_VertexAttrib4Nusv[i].value != -1; i++)
10186 {
10187 }
10188
10189 tcu_msg("ApiCoverageTestCase::VertexAttrib4Nusv", "Coverage test not implemented yet");
10190
10191 return success;
10192 }
10193
10194 /* Coverage test for glVertexAttrib4bv */
10195
10196 /* Enums to test for glVertexAttrib4bv (may not be required) */
10197 struct enumTestRec const ea_VertexAttrib4bv[] = {{"End of List", -1}};
10198
TestCoverageGLCallVertexAttrib4bv(void)10199 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4bv(void)
10200 {
10201 GLuint i;
10202 bool success = true;
10203
10204 /* glVertexAttrib4bv may need to loop over a set of enums doing something with them */
10205 for (i = 0; ea_VertexAttrib4bv[i].value != -1; i++)
10206 {
10207 }
10208
10209 tcu_msg("ApiCoverageTestCase::VertexAttrib4bv", "Coverage test not implemented yet");
10210
10211 return success;
10212 }
10213
10214 /* Coverage test for glVertexAttrib4d */
10215
10216 /* Enums to test for glVertexAttrib4d (may not be required) */
10217 struct enumTestRec const ea_VertexAttrib4d[] = {{"End of List", -1}};
10218
TestCoverageGLCallVertexAttrib4d(void)10219 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4d(void)
10220 {
10221 GLuint i;
10222 bool success = true;
10223
10224 /* glVertexAttrib4d may need to loop over a set of enums doing something with them */
10225 for (i = 0; ea_VertexAttrib4d[i].value != -1; i++)
10226 {
10227 }
10228
10229 tcu_msg("ApiCoverageTestCase::VertexAttrib4d", "Coverage test not implemented yet");
10230
10231 return success;
10232 }
10233
10234 /* Coverage test for glVertexAttrib4dv */
10235
10236 /* Enums to test for glVertexAttrib4dv (may not be required) */
10237 struct enumTestRec const ea_VertexAttrib4dv[] = {{"End of List", -1}};
10238
TestCoverageGLCallVertexAttrib4dv(void)10239 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4dv(void)
10240 {
10241 GLuint i;
10242 bool success = true;
10243
10244 /* glVertexAttrib4dv may need to loop over a set of enums doing something with them */
10245 for (i = 0; ea_VertexAttrib4dv[i].value != -1; i++)
10246 {
10247 }
10248
10249 tcu_msg("ApiCoverageTestCase::VertexAttrib4dv", "Coverage test not implemented yet");
10250
10251 return success;
10252 }
10253
10254 /* Coverage test for glVertexAttrib4iv */
10255
10256 /* Enums to test for glVertexAttrib4iv (may not be required) */
10257 struct enumTestRec const ea_VertexAttrib4iv[] = {{"End of List", -1}};
10258
TestCoverageGLCallVertexAttrib4iv(void)10259 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4iv(void)
10260 {
10261 GLuint i;
10262 bool success = true;
10263
10264 /* glVertexAttrib4iv may need to loop over a set of enums doing something with them */
10265 for (i = 0; ea_VertexAttrib4iv[i].value != -1; i++)
10266 {
10267 }
10268
10269 tcu_msg("ApiCoverageTestCase::VertexAttrib4iv", "Coverage test not implemented yet");
10270
10271 return success;
10272 }
10273
10274 /* Coverage test for glVertexAttrib4s */
10275
10276 /* Enums to test for glVertexAttrib4s (may not be required) */
10277 struct enumTestRec const ea_VertexAttrib4s[] = {{"End of List", -1}};
10278
TestCoverageGLCallVertexAttrib4s(void)10279 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4s(void)
10280 {
10281 GLuint i;
10282 bool success = true;
10283
10284 /* glVertexAttrib4s may need to loop over a set of enums doing something with them */
10285 for (i = 0; ea_VertexAttrib4s[i].value != -1; i++)
10286 {
10287 }
10288
10289 tcu_msg("ApiCoverageTestCase::VertexAttrib4s", "Coverage test not implemented yet");
10290
10291 return success;
10292 }
10293
10294 /* Coverage test for glVertexAttrib4sv */
10295
10296 /* Enums to test for glVertexAttrib4sv (may not be required) */
10297 struct enumTestRec const ea_VertexAttrib4sv[] = {{"End of List", -1}};
10298
TestCoverageGLCallVertexAttrib4sv(void)10299 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4sv(void)
10300 {
10301 GLuint i;
10302 bool success = true;
10303
10304 /* glVertexAttrib4sv may need to loop over a set of enums doing something with them */
10305 for (i = 0; ea_VertexAttrib4sv[i].value != -1; i++)
10306 {
10307 }
10308
10309 tcu_msg("ApiCoverageTestCase::VertexAttrib4sv", "Coverage test not implemented yet");
10310
10311 return success;
10312 }
10313
10314 /* Coverage test for glVertexAttrib4ubv */
10315
10316 /* Enums to test for glVertexAttrib4ubv (may not be required) */
10317 struct enumTestRec const ea_VertexAttrib4ubv[] = {{"End of List", -1}};
10318
TestCoverageGLCallVertexAttrib4ubv(void)10319 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4ubv(void)
10320 {
10321 GLuint i;
10322 bool success = true;
10323
10324 /* glVertexAttrib4ubv may need to loop over a set of enums doing something with them */
10325 for (i = 0; ea_VertexAttrib4ubv[i].value != -1; i++)
10326 {
10327 }
10328
10329 tcu_msg("ApiCoverageTestCase::VertexAttrib4ubv", "Coverage test not implemented yet");
10330
10331 return success;
10332 }
10333
10334 /* Coverage test for glVertexAttrib4uiv */
10335
10336 /* Enums to test for glVertexAttrib4uiv (may not be required) */
10337 struct enumTestRec const ea_VertexAttrib4uiv[] = {{"End of List", -1}};
10338
TestCoverageGLCallVertexAttrib4uiv(void)10339 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4uiv(void)
10340 {
10341 GLuint i;
10342 bool success = true;
10343
10344 /* glVertexAttrib4uiv may need to loop over a set of enums doing something with them */
10345 for (i = 0; ea_VertexAttrib4uiv[i].value != -1; i++)
10346 {
10347 }
10348
10349 tcu_msg("ApiCoverageTestCase::VertexAttrib4uiv", "Coverage test not implemented yet");
10350
10351 return success;
10352 }
10353
10354 /* Coverage test for glVertexAttrib4usv */
10355
10356 /* Enums to test for glVertexAttrib4usv (may not be required) */
10357 struct enumTestRec const ea_VertexAttrib4usv[] = {{"End of List", -1}};
10358
TestCoverageGLCallVertexAttrib4usv(void)10359 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttrib4usv(void)
10360 {
10361 GLuint i;
10362 bool success = true;
10363
10364 /* glVertexAttrib4usv may need to loop over a set of enums doing something with them */
10365 for (i = 0; ea_VertexAttrib4usv[i].value != -1; i++)
10366 {
10367 }
10368
10369 tcu_msg("ApiCoverageTestCase::VertexAttrib4usv", "Coverage test not implemented yet");
10370
10371 return success;
10372 }
10373
10374 /* Coverage test for glUniformMatrix2x3fv */
10375
10376 /* Enums to test for glUniformMatrix2x3fv (may not be required) */
10377 struct enumTestRec const ea_UniformMatrix2x3fv[] = {{"End of List", -1}};
10378
TestCoverageGLCallUniformMatrix2x3fv(void)10379 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix2x3fv(void)
10380 {
10381 GLuint i;
10382 bool success = true;
10383
10384 /* glUniformMatrix2x3fv may need to loop over a set of enums doing something with them */
10385 for (i = 0; ea_UniformMatrix2x3fv[i].value != -1; i++)
10386 {
10387 }
10388
10389 tcu_msg("ApiCoverageTestCase::UniformMatrix2x3fv", "Coverage test not implemented yet");
10390
10391 return success;
10392 }
10393
10394 /* Coverage test for glUniformMatrix3x2fv */
10395
10396 /* Enums to test for glUniformMatrix3x2fv (may not be required) */
10397 struct enumTestRec const ea_UniformMatrix3x2fv[] = {{"End of List", -1}};
10398
TestCoverageGLCallUniformMatrix3x2fv(void)10399 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix3x2fv(void)
10400 {
10401 GLuint i;
10402 bool success = true;
10403
10404 /* glUniformMatrix3x2fv may need to loop over a set of enums doing something with them */
10405 for (i = 0; ea_UniformMatrix3x2fv[i].value != -1; i++)
10406 {
10407 }
10408
10409 tcu_msg("ApiCoverageTestCase::UniformMatrix3x2fv", "Coverage test not implemented yet");
10410
10411 return success;
10412 }
10413
10414 /* Coverage test for glUniformMatrix4x2fv */
10415
10416 /* Enums to test for glUniformMatrix4x2fv (may not be required) */
10417 struct enumTestRec const ea_UniformMatrix4x2fv[] = {{"End of List", -1}};
10418
TestCoverageGLCallUniformMatrix4x2fv(void)10419 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix4x2fv(void)
10420 {
10421 GLuint i;
10422 bool success = true;
10423
10424 /* glUniformMatrix4x2fv may need to loop over a set of enums doing something with them */
10425 for (i = 0; ea_UniformMatrix4x2fv[i].value != -1; i++)
10426 {
10427 }
10428
10429 tcu_msg("ApiCoverageTestCase::UniformMatrix4x2fv", "Coverage test not implemented yet");
10430
10431 return success;
10432 }
10433
10434 /* Coverage test for glUniformMatrix3x4fv */
10435
10436 /* Enums to test for glUniformMatrix3x4fv (may not be required) */
10437 struct enumTestRec const ea_UniformMatrix3x4fv[] = {{"End of List", -1}};
10438
TestCoverageGLCallUniformMatrix3x4fv(void)10439 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix3x4fv(void)
10440 {
10441 GLuint i;
10442 bool success = true;
10443
10444 /* glUniformMatrix3x4fv may need to loop over a set of enums doing something with them */
10445 for (i = 0; ea_UniformMatrix3x4fv[i].value != -1; i++)
10446 {
10447 }
10448
10449 tcu_msg("ApiCoverageTestCase::UniformMatrix3x4fv", "Coverage test not implemented yet");
10450
10451 return success;
10452 }
10453
10454 /* Coverage test for glUniformMatrix4x3fv */
10455
10456 /* Enums to test for glUniformMatrix4x3fv (may not be required) */
10457 struct enumTestRec const ea_UniformMatrix4x3fv[] = {{"End of List", -1}};
10458
TestCoverageGLCallUniformMatrix4x3fv(void)10459 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix4x3fv(void)
10460 {
10461 GLuint i;
10462 bool success = true;
10463
10464 /* glUniformMatrix4x3fv may need to loop over a set of enums doing something with them */
10465 for (i = 0; ea_UniformMatrix4x3fv[i].value != -1; i++)
10466 {
10467 }
10468
10469 tcu_msg("ApiCoverageTestCase::UniformMatrix4x3fv", "Coverage test not implemented yet");
10470
10471 return success;
10472 }
10473
10474 /* OpenGL 3.0 entry points */
10475
10476 /* Coverage test for glColorMaski */
10477
10478 /* Enums to test for glColorMaski (may not be required) */
10479 struct enumTestRec const ea_ColorMaski[] = {{"End of List", -1}};
10480
TestCoverageGLCallColorMaski(void)10481 bool ApiCoverageTestCase::TestCoverageGLCallColorMaski(void)
10482 {
10483 GLuint i;
10484 bool success = true;
10485
10486 /* glColorMaski may need to loop over a set of enums doing something with them */
10487 for (i = 0; ea_ColorMaski[i].value != -1; i++)
10488 {
10489 }
10490
10491 tcu_msg("ApiCoverageTestCase::ColorMaski", "Coverage test not implemented yet");
10492
10493 return success;
10494 }
10495
10496 /* Coverage test for glGetBooleani_v */
10497
10498 /* Enums to test for glGetBooleani_v (may not be required) */
10499 struct enumTestRec const ea_GetBooleani_v[] = {{"End of List", -1}};
10500
TestCoverageGLCallGetBooleani_v(void)10501 bool ApiCoverageTestCase::TestCoverageGLCallGetBooleani_v(void)
10502 {
10503 GLuint i;
10504 bool success = true;
10505
10506 /* glGetBooleani_v may need to loop over a set of enums doing something with them */
10507 for (i = 0; ea_GetBooleani_v[i].value != -1; i++)
10508 {
10509 }
10510
10511 tcu_msg("ApiCoverageTestCase::GetBooleani_v", "Coverage test not implemented yet");
10512
10513 return success;
10514 }
10515
10516 /* Coverage test for glGetIntegeri_v */
10517
10518 /* Enums to test for glGetIntegeri_v (may not be required) */
10519 struct enumTestRec const ea_GetIntegeri_v[] = {{"End of List", -1}};
10520
TestCoverageGLCallGetIntegeri_v(void)10521 bool ApiCoverageTestCase::TestCoverageGLCallGetIntegeri_v(void)
10522 {
10523 GLuint i;
10524 bool success = true;
10525
10526 /* glGetIntegeri_v may need to loop over a set of enums doing something with them */
10527 for (i = 0; ea_GetIntegeri_v[i].value != -1; i++)
10528 {
10529 }
10530
10531 tcu_msg("ApiCoverageTestCase::GetIntegeri_v", "Coverage test not implemented yet");
10532
10533 return success;
10534 }
10535
10536 /* Coverage test for glEnablei */
10537
10538 /* Enums to test for glEnablei (may not be required) */
10539 struct enumTestRec const ea_Enablei[] = {{"End of List", -1}};
10540
TestCoverageGLCallEnablei(void)10541 bool ApiCoverageTestCase::TestCoverageGLCallEnablei(void)
10542 {
10543 GLuint i;
10544 bool success = true;
10545
10546 /* glEnablei may need to loop over a set of enums doing something with them */
10547 for (i = 0; ea_Enablei[i].value != -1; i++)
10548 {
10549 }
10550
10551 tcu_msg("ApiCoverageTestCase::Enablei", "Coverage test not implemented yet");
10552
10553 return success;
10554 }
10555
10556 /* Coverage test for glDisablei */
10557
10558 /* Enums to test for glDisablei (may not be required) */
10559 struct enumTestRec const ea_Disablei[] = {{"End of List", -1}};
10560
TestCoverageGLCallDisablei(void)10561 bool ApiCoverageTestCase::TestCoverageGLCallDisablei(void)
10562 {
10563 GLuint i;
10564 bool success = true;
10565
10566 /* glDisablei may need to loop over a set of enums doing something with them */
10567 for (i = 0; ea_Disablei[i].value != -1; i++)
10568 {
10569 }
10570
10571 tcu_msg("ApiCoverageTestCase::Disablei", "Coverage test not implemented yet");
10572
10573 return success;
10574 }
10575
10576 /* Coverage test for glIsEnabledi */
10577
10578 /* Enums to test for glIsEnabledi (may not be required) */
10579 struct enumTestRec const ea_IsEnabledi[] = {{"End of List", -1}};
10580
TestCoverageGLCallIsEnabledi(void)10581 bool ApiCoverageTestCase::TestCoverageGLCallIsEnabledi(void)
10582 {
10583 GLuint i;
10584 bool success = true;
10585
10586 /* glIsEnabledi may need to loop over a set of enums doing something with them */
10587 for (i = 0; ea_IsEnabledi[i].value != -1; i++)
10588 {
10589 }
10590
10591 tcu_msg("ApiCoverageTestCase::IsEnabledi", "Coverage test not implemented yet");
10592
10593 return success;
10594 }
10595
10596 /* Coverage test for glClampColor */
10597
10598 /* Enums to test for glClampColor (may not be required) */
10599 struct enumTestRec const ea_ClampColor[] = {{"End of List", -1}};
10600
TestCoverageGLCallClampColor(void)10601 bool ApiCoverageTestCase::TestCoverageGLCallClampColor(void)
10602 {
10603 GLuint i;
10604 bool success = true;
10605
10606 /* glClampColor may need to loop over a set of enums doing something with them */
10607 for (i = 0; ea_ClampColor[i].value != -1; i++)
10608 {
10609 }
10610
10611 tcu_msg("ApiCoverageTestCase::ClampColor", "Coverage test not implemented yet");
10612
10613 return success;
10614 }
10615
10616 /* Coverage test for glBeginConditionalRender */
10617
10618 /* Enums to test for glBeginConditionalRender (may not be required) */
10619 struct enumTestRec const ea_BeginConditionalRender[] = {{"End of List", -1}};
10620
TestCoverageGLCallBeginConditionalRender(void)10621 bool ApiCoverageTestCase::TestCoverageGLCallBeginConditionalRender(void)
10622 {
10623 GLuint i;
10624 bool success = true;
10625
10626 /* glBeginConditionalRender may need to loop over a set of enums doing something with them */
10627 for (i = 0; ea_BeginConditionalRender[i].value != -1; i++)
10628 {
10629 }
10630
10631 tcu_msg("ApiCoverageTestCase::BeginConditionalRender", "Coverage test not implemented yet");
10632
10633 return success;
10634 }
10635
10636 /* Coverage test for glEndConditionalRender */
10637
10638 /* Enums to test for glEndConditionalRender (may not be required) */
10639 struct enumTestRec const ea_EndConditionalRender[] = {{"End of List", -1}};
10640
TestCoverageGLCallEndConditionalRender(void)10641 bool ApiCoverageTestCase::TestCoverageGLCallEndConditionalRender(void)
10642 {
10643 GLuint i;
10644 bool success = true;
10645
10646 /* glEndConditionalRender may need to loop over a set of enums doing something with them */
10647 for (i = 0; ea_EndConditionalRender[i].value != -1; i++)
10648 {
10649 }
10650
10651 tcu_msg("ApiCoverageTestCase::EndConditionalRender", "Coverage test not implemented yet");
10652
10653 return success;
10654 }
10655
10656 /* Coverage test for glVertexAttribI1i */
10657
10658 /* Enums to test for glVertexAttribI1i (may not be required) */
10659 struct enumTestRec const ea_VertexAttribI1i[] = {{"End of List", -1}};
10660
TestCoverageGLCallVertexAttribI1i(void)10661 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI1i(void)
10662 {
10663 GLuint i;
10664 bool success = true;
10665
10666 /* glVertexAttribI1i may need to loop over a set of enums doing something with them */
10667 for (i = 0; ea_VertexAttribI1i[i].value != -1; i++)
10668 {
10669 }
10670
10671 tcu_msg("ApiCoverageTestCase::VertexAttribI1i", "Coverage test not implemented yet");
10672
10673 return success;
10674 }
10675
10676 /* Coverage test for glVertexAttribI2i */
10677
10678 /* Enums to test for glVertexAttribI2i (may not be required) */
10679 struct enumTestRec const ea_VertexAttribI2i[] = {{"End of List", -1}};
10680
TestCoverageGLCallVertexAttribI2i(void)10681 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI2i(void)
10682 {
10683 GLuint i;
10684 bool success = true;
10685
10686 /* glVertexAttribI2i may need to loop over a set of enums doing something with them */
10687 for (i = 0; ea_VertexAttribI2i[i].value != -1; i++)
10688 {
10689 }
10690
10691 tcu_msg("ApiCoverageTestCase::VertexAttribI2i", "Coverage test not implemented yet");
10692
10693 return success;
10694 }
10695
10696 /* Coverage test for glVertexAttribI3i */
10697
10698 /* Enums to test for glVertexAttribI3i (may not be required) */
10699 struct enumTestRec const ea_VertexAttribI3i[] = {{"End of List", -1}};
10700
TestCoverageGLCallVertexAttribI3i(void)10701 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI3i(void)
10702 {
10703 GLuint i;
10704 bool success = true;
10705
10706 /* glVertexAttribI3i may need to loop over a set of enums doing something with them */
10707 for (i = 0; ea_VertexAttribI3i[i].value != -1; i++)
10708 {
10709 }
10710
10711 tcu_msg("ApiCoverageTestCase::VertexAttribI3i", "Coverage test not implemented yet");
10712
10713 return success;
10714 }
10715
10716 /* Coverage test for glVertexAttribI1ui */
10717
10718 /* Enums to test for glVertexAttribI1ui (may not be required) */
10719 struct enumTestRec const ea_VertexAttribI1ui[] = {{"End of List", -1}};
10720
TestCoverageGLCallVertexAttribI1ui(void)10721 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI1ui(void)
10722 {
10723 GLuint i;
10724 bool success = true;
10725
10726 /* glVertexAttribI1ui may need to loop over a set of enums doing something with them */
10727 for (i = 0; ea_VertexAttribI1ui[i].value != -1; i++)
10728 {
10729 }
10730
10731 tcu_msg("ApiCoverageTestCase::VertexAttribI1ui", "Coverage test not implemented yet");
10732
10733 return success;
10734 }
10735
10736 /* Coverage test for glVertexAttribI2ui */
10737
10738 /* Enums to test for glVertexAttribI2ui (may not be required) */
10739 struct enumTestRec const ea_VertexAttribI2ui[] = {{"End of List", -1}};
10740
TestCoverageGLCallVertexAttribI2ui(void)10741 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI2ui(void)
10742 {
10743 GLuint i;
10744 bool success = true;
10745
10746 /* glVertexAttribI2ui may need to loop over a set of enums doing something with them */
10747 for (i = 0; ea_VertexAttribI2ui[i].value != -1; i++)
10748 {
10749 }
10750
10751 tcu_msg("ApiCoverageTestCase::VertexAttribI2ui", "Coverage test not implemented yet");
10752
10753 return success;
10754 }
10755
10756 /* Coverage test for glVertexAttribI3ui */
10757
10758 /* Enums to test for glVertexAttribI3ui (may not be required) */
10759 struct enumTestRec const ea_VertexAttribI3ui[] = {{"End of List", -1}};
10760
TestCoverageGLCallVertexAttribI3ui(void)10761 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI3ui(void)
10762 {
10763 GLuint i;
10764 bool success = true;
10765
10766 /* glVertexAttribI3ui may need to loop over a set of enums doing something with them */
10767 for (i = 0; ea_VertexAttribI3ui[i].value != -1; i++)
10768 {
10769 }
10770
10771 tcu_msg("ApiCoverageTestCase::VertexAttribI3ui", "Coverage test not implemented yet");
10772
10773 return success;
10774 }
10775
10776 /* Coverage test for glVertexAttribI1iv */
10777
10778 /* Enums to test for glVertexAttribI1iv (may not be required) */
10779 struct enumTestRec const ea_VertexAttribI1iv[] = {{"End of List", -1}};
10780
TestCoverageGLCallVertexAttribI1iv(void)10781 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI1iv(void)
10782 {
10783 GLuint i;
10784 bool success = true;
10785
10786 /* glVertexAttribI1iv may need to loop over a set of enums doing something with them */
10787 for (i = 0; ea_VertexAttribI1iv[i].value != -1; i++)
10788 {
10789 }
10790
10791 tcu_msg("ApiCoverageTestCase::VertexAttribI1iv", "Coverage test not implemented yet");
10792
10793 return success;
10794 }
10795
10796 /* Coverage test for glVertexAttribI2iv */
10797
10798 /* Enums to test for glVertexAttribI2iv (may not be required) */
10799 struct enumTestRec const ea_VertexAttribI2iv[] = {{"End of List", -1}};
10800
TestCoverageGLCallVertexAttribI2iv(void)10801 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI2iv(void)
10802 {
10803 GLuint i;
10804 bool success = true;
10805
10806 /* glVertexAttribI2iv may need to loop over a set of enums doing something with them */
10807 for (i = 0; ea_VertexAttribI2iv[i].value != -1; i++)
10808 {
10809 }
10810
10811 tcu_msg("ApiCoverageTestCase::VertexAttribI2iv", "Coverage test not implemented yet");
10812
10813 return success;
10814 }
10815
10816 /* Coverage test for glVertexAttribI3iv */
10817
10818 /* Enums to test for glVertexAttribI3iv (may not be required) */
10819 struct enumTestRec const ea_VertexAttribI3iv[] = {{"End of List", -1}};
10820
TestCoverageGLCallVertexAttribI3iv(void)10821 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI3iv(void)
10822 {
10823 GLuint i;
10824 bool success = true;
10825
10826 /* glVertexAttribI3iv may need to loop over a set of enums doing something with them */
10827 for (i = 0; ea_VertexAttribI3iv[i].value != -1; i++)
10828 {
10829 }
10830
10831 tcu_msg("ApiCoverageTestCase::VertexAttribI3iv", "Coverage test not implemented yet");
10832
10833 return success;
10834 }
10835
10836 /* Coverage test for glVertexAttribI1uiv */
10837
10838 /* Enums to test for glVertexAttribI1uiv (may not be required) */
10839 struct enumTestRec const ea_VertexAttribI1uiv[] = {{"End of List", -1}};
10840
TestCoverageGLCallVertexAttribI1uiv(void)10841 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI1uiv(void)
10842 {
10843 GLuint i;
10844 bool success = true;
10845
10846 /* glVertexAttribI1uiv may need to loop over a set of enums doing something with them */
10847 for (i = 0; ea_VertexAttribI1uiv[i].value != -1; i++)
10848 {
10849 }
10850
10851 tcu_msg("ApiCoverageTestCase::VertexAttribI1uiv", "Coverage test not implemented yet");
10852
10853 return success;
10854 }
10855
10856 /* Coverage test for glVertexAttribI2uiv */
10857
10858 /* Enums to test for glVertexAttribI2uiv (may not be required) */
10859 struct enumTestRec const ea_VertexAttribI2uiv[] = {{"End of List", -1}};
10860
TestCoverageGLCallVertexAttribI2uiv(void)10861 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI2uiv(void)
10862 {
10863 GLuint i;
10864 bool success = true;
10865
10866 /* glVertexAttribI2uiv may need to loop over a set of enums doing something with them */
10867 for (i = 0; ea_VertexAttribI2uiv[i].value != -1; i++)
10868 {
10869 }
10870
10871 tcu_msg("ApiCoverageTestCase::VertexAttribI2uiv", "Coverage test not implemented yet");
10872
10873 return success;
10874 }
10875
10876 /* Coverage test for glVertexAttribI3uiv */
10877
10878 /* Enums to test for glVertexAttribI3uiv (may not be required) */
10879 struct enumTestRec const ea_VertexAttribI3uiv[] = {{"End of List", -1}};
10880
TestCoverageGLCallVertexAttribI3uiv(void)10881 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI3uiv(void)
10882 {
10883 GLuint i;
10884 bool success = true;
10885
10886 /* glVertexAttribI3uiv may need to loop over a set of enums doing something with them */
10887 for (i = 0; ea_VertexAttribI3uiv[i].value != -1; i++)
10888 {
10889 }
10890
10891 tcu_msg("ApiCoverageTestCase::VertexAttribI3uiv", "Coverage test not implemented yet");
10892
10893 return success;
10894 }
10895
10896 /* Coverage test for glVertexAttribI4bv */
10897
10898 /* Enums to test for glVertexAttribI4bv (may not be required) */
10899 struct enumTestRec const ea_VertexAttribI4bv[] = {{"End of List", -1}};
10900
TestCoverageGLCallVertexAttribI4bv(void)10901 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4bv(void)
10902 {
10903 GLuint i;
10904 bool success = true;
10905
10906 /* glVertexAttribI4bv may need to loop over a set of enums doing something with them */
10907 for (i = 0; ea_VertexAttribI4bv[i].value != -1; i++)
10908 {
10909 }
10910
10911 tcu_msg("ApiCoverageTestCase::VertexAttribI4bv", "Coverage test not implemented yet");
10912
10913 return success;
10914 }
10915
10916 /* Coverage test for glVertexAttribI4sv */
10917
10918 /* Enums to test for glVertexAttribI4sv (may not be required) */
10919 struct enumTestRec const ea_VertexAttribI4sv[] = {{"End of List", -1}};
10920
TestCoverageGLCallVertexAttribI4sv(void)10921 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4sv(void)
10922 {
10923 GLuint i;
10924 bool success = true;
10925
10926 /* glVertexAttribI4sv may need to loop over a set of enums doing something with them */
10927 for (i = 0; ea_VertexAttribI4sv[i].value != -1; i++)
10928 {
10929 }
10930
10931 tcu_msg("ApiCoverageTestCase::VertexAttribI4sv", "Coverage test not implemented yet");
10932
10933 return success;
10934 }
10935
10936 /* Coverage test for glVertexAttribI4ubv */
10937
10938 /* Enums to test for glVertexAttribI4ubv (may not be required) */
10939 struct enumTestRec const ea_VertexAttribI4ubv[] = {{"End of List", -1}};
10940
TestCoverageGLCallVertexAttribI4ubv(void)10941 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4ubv(void)
10942 {
10943 GLuint i;
10944 bool success = true;
10945
10946 /* glVertexAttribI4ubv may need to loop over a set of enums doing something with them */
10947 for (i = 0; ea_VertexAttribI4ubv[i].value != -1; i++)
10948 {
10949 }
10950
10951 tcu_msg("ApiCoverageTestCase::VertexAttribI4ubv", "Coverage test not implemented yet");
10952
10953 return success;
10954 }
10955
10956 /* Coverage test for glVertexAttribI4usv */
10957
10958 /* Enums to test for glVertexAttribI4usv (may not be required) */
10959 struct enumTestRec const ea_VertexAttribI4usv[] = {{"End of List", -1}};
10960
TestCoverageGLCallVertexAttribI4usv(void)10961 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribI4usv(void)
10962 {
10963 GLuint i;
10964 bool success = true;
10965
10966 /* glVertexAttribI4usv may need to loop over a set of enums doing something with them */
10967 for (i = 0; ea_VertexAttribI4usv[i].value != -1; i++)
10968 {
10969 }
10970
10971 tcu_msg("ApiCoverageTestCase::VertexAttribI4usv", "Coverage test not implemented yet");
10972
10973 return success;
10974 }
10975
10976 /* Coverage test for glBindFragDataLocation */
10977
10978 /* Enums to test for glBindFragDataLocation (may not be required) */
10979 struct enumTestRec const ea_BindFragDataLocation[] = {{"End of List", -1}};
10980
TestCoverageGLCallBindFragDataLocation(void)10981 bool ApiCoverageTestCase::TestCoverageGLCallBindFragDataLocation(void)
10982 {
10983 GLuint i;
10984 bool success = true;
10985
10986 /* glBindFragDataLocation may need to loop over a set of enums doing something with them */
10987 for (i = 0; ea_BindFragDataLocation[i].value != -1; i++)
10988 {
10989 }
10990
10991 tcu_msg("ApiCoverageTestCase::BindFragDataLocation", "Coverage test not implemented yet");
10992
10993 return success;
10994 }
10995
10996 /* Coverage test for glUniform1ui */
10997
10998 /* Enums to test for glUniform1ui (may not be required) */
10999 struct enumTestRec const ea_Uniform1ui[] = {{"End of List", -1}};
11000
TestCoverageGLCallUniform1ui(void)11001 bool ApiCoverageTestCase::TestCoverageGLCallUniform1ui(void)
11002 {
11003 GLuint i;
11004 bool success = true;
11005
11006 /* glUniform1ui may need to loop over a set of enums doing something with them */
11007 for (i = 0; ea_Uniform1ui[i].value != -1; i++)
11008 {
11009 }
11010
11011 tcu_msg("ApiCoverageTestCase::Uniform1ui", "Coverage test not implemented yet");
11012
11013 return success;
11014 }
11015
11016 /* Coverage test for glUniform3ui */
11017
11018 /* Enums to test for glUniform3ui (may not be required) */
11019 struct enumTestRec const ea_Uniform3ui[] = {{"End of List", -1}};
11020
TestCoverageGLCallUniform3ui(void)11021 bool ApiCoverageTestCase::TestCoverageGLCallUniform3ui(void)
11022 {
11023 GLuint i;
11024 bool success = true;
11025
11026 /* glUniform3ui may need to loop over a set of enums doing something with them */
11027 for (i = 0; ea_Uniform3ui[i].value != -1; i++)
11028 {
11029 }
11030
11031 tcu_msg("ApiCoverageTestCase::Uniform3ui", "Coverage test not implemented yet");
11032
11033 return success;
11034 }
11035
11036 /* Coverage test for glUniform4ui */
11037
11038 /* Enums to test for glUniform4ui (may not be required) */
11039 struct enumTestRec const ea_Uniform4ui[] = {{"End of List", -1}};
11040
TestCoverageGLCallUniform4ui(void)11041 bool ApiCoverageTestCase::TestCoverageGLCallUniform4ui(void)
11042 {
11043 GLuint i;
11044 bool success = true;
11045
11046 /* glUniform4ui may need to loop over a set of enums doing something with them */
11047 for (i = 0; ea_Uniform4ui[i].value != -1; i++)
11048 {
11049 }
11050
11051 tcu_msg("ApiCoverageTestCase::Uniform4ui", "Coverage test not implemented yet");
11052
11053 return success;
11054 }
11055
11056 /* Coverage test for glUniform1uiv */
11057
11058 /* Enums to test for glUniform1uiv (may not be required) */
11059 struct enumTestRec const ea_Uniform1uiv[] = {{"End of List", -1}};
11060
TestCoverageGLCallUniform1uiv(void)11061 bool ApiCoverageTestCase::TestCoverageGLCallUniform1uiv(void)
11062 {
11063 GLuint i;
11064 bool success = true;
11065
11066 /* glUniform1uiv may need to loop over a set of enums doing something with them */
11067 for (i = 0; ea_Uniform1uiv[i].value != -1; i++)
11068 {
11069 }
11070
11071 tcu_msg("ApiCoverageTestCase::Uniform1uiv", "Coverage test not implemented yet");
11072
11073 return success;
11074 }
11075
11076 /* Coverage test for glUniform3uiv */
11077
11078 /* Enums to test for glUniform3uiv (may not be required) */
11079 struct enumTestRec const ea_Uniform3uiv[] = {{"End of List", -1}};
11080
TestCoverageGLCallUniform3uiv(void)11081 bool ApiCoverageTestCase::TestCoverageGLCallUniform3uiv(void)
11082 {
11083 GLuint i;
11084 bool success = true;
11085
11086 /* glUniform3uiv may need to loop over a set of enums doing something with them */
11087 for (i = 0; ea_Uniform3uiv[i].value != -1; i++)
11088 {
11089 }
11090
11091 tcu_msg("ApiCoverageTestCase::Uniform3uiv", "Coverage test not implemented yet");
11092
11093 return success;
11094 }
11095
11096 /* Coverage test for glUniform4uiv */
11097
11098 /* Enums to test for glUniform4uiv (may not be required) */
11099 struct enumTestRec const ea_Uniform4uiv[] = {{"End of List", -1}};
11100
TestCoverageGLCallUniform4uiv(void)11101 bool ApiCoverageTestCase::TestCoverageGLCallUniform4uiv(void)
11102 {
11103 GLuint i;
11104 bool success = true;
11105
11106 /* glUniform4uiv may need to loop over a set of enums doing something with them */
11107 for (i = 0; ea_Uniform4uiv[i].value != -1; i++)
11108 {
11109 }
11110
11111 tcu_msg("ApiCoverageTestCase::Uniform4uiv", "Coverage test not implemented yet");
11112
11113 return success;
11114 }
11115
11116 /* Coverage test for glTexParameterIiv */
11117
11118 /* Enums to test for glTexParameterIiv (may not be required) */
11119 struct enumTestRec const ea_TexParameterIiv[] = {{"End of List", -1}};
11120
TestCoverageGLCallTexParameterIiv(void)11121 bool ApiCoverageTestCase::TestCoverageGLCallTexParameterIiv(void)
11122 {
11123 GLuint i;
11124 bool success = true;
11125
11126 /* glTexParameterIiv may need to loop over a set of enums doing something with them */
11127 for (i = 0; ea_TexParameterIiv[i].value != -1; i++)
11128 {
11129 }
11130
11131 tcu_msg("ApiCoverageTestCase::TexParameterIiv", "Coverage test not implemented yet");
11132
11133 return success;
11134 }
11135
11136 /* Coverage test for glTexParameterIuiv */
11137
11138 /* Enums to test for glTexParameterIuiv (may not be required) */
11139 struct enumTestRec const ea_TexParameterIuiv[] = {{"End of List", -1}};
11140
TestCoverageGLCallTexParameterIuiv(void)11141 bool ApiCoverageTestCase::TestCoverageGLCallTexParameterIuiv(void)
11142 {
11143 GLuint i;
11144 bool success = true;
11145
11146 /* glTexParameterIuiv may need to loop over a set of enums doing something with them */
11147 for (i = 0; ea_TexParameterIuiv[i].value != -1; i++)
11148 {
11149 }
11150
11151 tcu_msg("ApiCoverageTestCase::TexParameterIuiv", "Coverage test not implemented yet");
11152
11153 return success;
11154 }
11155
11156 /* Coverage test for glGetTexParameterIiv */
11157
11158 /* Enums to test for glGetTexParameterIiv (may not be required) */
11159 struct enumTestRec const ea_GetTexParameterIiv[] = {{"End of List", -1}};
11160
TestCoverageGLCallGetTexParameterIiv(void)11161 bool ApiCoverageTestCase::TestCoverageGLCallGetTexParameterIiv(void)
11162 {
11163 GLuint i;
11164 bool success = true;
11165
11166 /* glGetTexParameterIiv may need to loop over a set of enums doing something with them */
11167 for (i = 0; ea_GetTexParameterIiv[i].value != -1; i++)
11168 {
11169 }
11170
11171 tcu_msg("ApiCoverageTestCase::GetTexParameterIiv", "Coverage test not implemented yet");
11172
11173 return success;
11174 }
11175
11176 /* Coverage test for glGetTexParameterIuiv */
11177
11178 /* Enums to test for glGetTexParameterIuiv (may not be required) */
11179 struct enumTestRec const ea_GetTexParameterIuiv[] = {{"End of List", -1}};
11180
TestCoverageGLCallGetTexParameterIuiv(void)11181 bool ApiCoverageTestCase::TestCoverageGLCallGetTexParameterIuiv(void)
11182 {
11183 GLuint i;
11184 bool success = true;
11185
11186 /* glGetTexParameterIuiv may need to loop over a set of enums doing something with them */
11187 for (i = 0; ea_GetTexParameterIuiv[i].value != -1; i++)
11188 {
11189 }
11190
11191 tcu_msg("ApiCoverageTestCase::GetTexParameterIuiv", "Coverage test not implemented yet");
11192
11193 return success;
11194 }
11195
11196 /* Coverage test for glFramebufferTexture1D */
11197
11198 /* Enums to test for glFramebufferTexture1D (may not be required) */
11199 struct enumTestRec const ea_FramebufferTexture1D[] = {{"End of List", -1}};
11200
TestCoverageGLCallFramebufferTexture1D(void)11201 bool ApiCoverageTestCase::TestCoverageGLCallFramebufferTexture1D(void)
11202 {
11203 GLuint i;
11204 bool success = true;
11205
11206 /* glFramebufferTexture1D may need to loop over a set of enums doing something with them */
11207 for (i = 0; ea_FramebufferTexture1D[i].value != -1; i++)
11208 {
11209 }
11210
11211 tcu_msg("ApiCoverageTestCase::FramebufferTexture1D", "Coverage test not implemented yet");
11212
11213 return success;
11214 }
11215
11216 /* Coverage test for glFramebufferTexture3D */
11217
11218 /* Enums to test for glFramebufferTexture3D (may not be required) */
11219 struct enumTestRec const ea_FramebufferTexture3D[] = {{"End of List", -1}};
11220
TestCoverageGLCallFramebufferTexture3D(void)11221 bool ApiCoverageTestCase::TestCoverageGLCallFramebufferTexture3D(void)
11222 {
11223 GLuint i;
11224 bool success = true;
11225
11226 /* glFramebufferTexture3D may need to loop over a set of enums doing something with them */
11227 for (i = 0; ea_FramebufferTexture3D[i].value != -1; i++)
11228 {
11229 }
11230
11231 tcu_msg("ApiCoverageTestCase::FramebufferTexture3D", "Coverage test not implemented yet");
11232
11233 return success;
11234 }
11235
11236 /* OpenGL 3.1 entry points */
11237
11238 /* Coverage test for glTexBuffer */
11239
11240 /* Enums to test for glTexBuffer (may not be required) */
11241 struct enumTestRec const ea_TexBuffer[] = {{"End of List", -1}};
11242
TestCoverageGLCallTexBuffer(void)11243 bool ApiCoverageTestCase::TestCoverageGLCallTexBuffer(void)
11244 {
11245 GLuint i;
11246 bool success = true;
11247
11248 /* glTexBuffer may need to loop over a set of enums doing something with them */
11249 for (i = 0; ea_TexBuffer[i].value != -1; i++)
11250 {
11251 }
11252
11253 tcu_msg("ApiCoverageTestCase::TexBuffer", "Coverage test not implemented yet");
11254
11255 return success;
11256 }
11257
11258 /* Coverage test for glPrimitiveRestartIndex */
11259
11260 /* Enums to test for glPrimitiveRestartIndex (may not be required) */
11261 struct enumTestRec const ea_PrimitiveRestartIndex[] = {{"End of List", -1}};
11262
TestCoverageGLCallPrimitiveRestartIndex(void)11263 bool ApiCoverageTestCase::TestCoverageGLCallPrimitiveRestartIndex(void)
11264 {
11265 GLuint i;
11266 bool success = true;
11267
11268 /* glPrimitiveRestartIndex may need to loop over a set of enums doing something with them */
11269 for (i = 0; ea_PrimitiveRestartIndex[i].value != -1; i++)
11270 {
11271 }
11272
11273 tcu_msg("ApiCoverageTestCase::PrimitiveRestartIndex", "Coverage test not implemented yet");
11274
11275 return success;
11276 }
11277
11278 /* Coverage test for glGetActiveUniformName */
11279
11280 /* Enums to test for glGetActiveUniformName (may not be required) */
11281 struct enumTestRec const ea_GetActiveUniformName[] = {{"End of List", -1}};
11282
TestCoverageGLCallGetActiveUniformName(void)11283 bool ApiCoverageTestCase::TestCoverageGLCallGetActiveUniformName(void)
11284 {
11285 GLuint i;
11286 bool success = true;
11287
11288 /* glGetActiveUniformName may need to loop over a set of enums doing something with them */
11289 for (i = 0; ea_GetActiveUniformName[i].value != -1; i++)
11290 {
11291 }
11292
11293 tcu_msg("ApiCoverageTestCase::GetActiveUniformName", "Coverage test not implemented yet");
11294
11295 return success;
11296 }
11297
11298 /* OpenGL 3.2 entry points */
11299
11300 /* Coverage test for glGetInteger64i_v */
11301
11302 /* Enums to test for glGetInteger64i_v (may not be required) */
11303 struct enumTestRec const ea_GetInteger64i_v[] = {{"End of List", -1}};
11304
TestCoverageGLCallGetInteger64i_v(void)11305 bool ApiCoverageTestCase::TestCoverageGLCallGetInteger64i_v(void)
11306 {
11307 GLuint i;
11308 bool success = true;
11309
11310 /* glGetInteger64i_v may need to loop over a set of enums doing something with them */
11311 for (i = 0; ea_GetInteger64i_v[i].value != -1; i++)
11312 {
11313 }
11314
11315 tcu_msg("ApiCoverageTestCase::GetInteger64i_v", "Coverage test not implemented yet");
11316
11317 return success;
11318 }
11319
11320 /* Coverage test for glFramebufferTexture */
11321
11322 /* Enums to test for glFramebufferTexture (may not be required) */
11323 struct enumTestRec const ea_FramebufferTexture[] = {{"End of List", -1}};
11324
TestCoverageGLCallFramebufferTexture(void)11325 bool ApiCoverageTestCase::TestCoverageGLCallFramebufferTexture(void)
11326 {
11327 GLuint i;
11328 bool success = true;
11329
11330 /* glFramebufferTexture may need to loop over a set of enums doing something with them */
11331 for (i = 0; ea_FramebufferTexture[i].value != -1; i++)
11332 {
11333 }
11334
11335 tcu_msg("ApiCoverageTestCase::FramebufferTexture", "Coverage test not implemented yet");
11336
11337 return success;
11338 }
11339
11340 /* Coverage test for glDrawElementsBaseVertex */
11341
11342 /* Enums to test for glDrawElementsBaseVertex (may not be required) */
11343 struct enumTestRec const ea_DrawElementsBaseVertex[] = {{"End of List", -1}};
11344
TestCoverageGLCallDrawElementsBaseVertex(void)11345 bool ApiCoverageTestCase::TestCoverageGLCallDrawElementsBaseVertex(void)
11346 {
11347 GLuint i;
11348 bool success = true;
11349
11350 /* glDrawElementsBaseVertex may need to loop over a set of enums doing something with them */
11351 for (i = 0; ea_DrawElementsBaseVertex[i].value != -1; i++)
11352 {
11353 }
11354
11355 tcu_msg("ApiCoverageTestCase::DrawElementsBaseVertex", "Coverage test not implemented yet");
11356
11357 return success;
11358 }
11359
11360 /* Coverage test for glDrawRangeElementsBaseVertex */
11361
11362 /* Enums to test for glDrawRangeElementsBaseVertex (may not be required) */
11363 struct enumTestRec const ea_DrawRangeElementsBaseVertex[] = {{"End of List", -1}};
11364
TestCoverageGLCallDrawRangeElementsBaseVertex(void)11365 bool ApiCoverageTestCase::TestCoverageGLCallDrawRangeElementsBaseVertex(void)
11366 {
11367 GLuint i;
11368 bool success = true;
11369
11370 /* glDrawRangeElementsBaseVertex may need to loop over a set of enums doing something with them */
11371 for (i = 0; ea_DrawRangeElementsBaseVertex[i].value != -1; i++)
11372 {
11373 }
11374
11375 tcu_msg("ApiCoverageTestCase::DrawRangeElementsBaseVertex", "Coverage test not implemented yet");
11376
11377 return success;
11378 }
11379
11380 /* Coverage test for glDrawElementsInstancedBaseVertex */
11381
11382 /* Enums to test for glDrawElementsInstancedBaseVertex (may not be required) */
11383 struct enumTestRec const ea_DrawElementsInstancedBaseVertex[] = {{"End of List", -1}};
11384
TestCoverageGLCallDrawElementsInstancedBaseVertex(void)11385 bool ApiCoverageTestCase::TestCoverageGLCallDrawElementsInstancedBaseVertex(void)
11386 {
11387 GLuint i;
11388 bool success = true;
11389
11390 /* glDrawElementsInstancedBaseVertex may need to loop over a set of enums doing something with them */
11391 for (i = 0; ea_DrawElementsInstancedBaseVertex[i].value != -1; i++)
11392 {
11393 }
11394
11395 tcu_msg("ApiCoverageTestCase::DrawElementsInstancedBaseVertex", "Coverage test not implemented yet");
11396
11397 return success;
11398 }
11399
11400 /* Coverage test for glMultiDrawElementsBaseVertex */
11401
11402 /* Enums to test for glMultiDrawElementsBaseVertex (may not be required) */
11403 struct enumTestRec const ea_MultiDrawElementsBaseVertex[] = {{"End of List", -1}};
11404
TestCoverageGLCallMultiDrawElementsBaseVertex(void)11405 bool ApiCoverageTestCase::TestCoverageGLCallMultiDrawElementsBaseVertex(void)
11406 {
11407 GLuint i;
11408 bool success = true;
11409
11410 /* glMultiDrawElementsBaseVertex may need to loop over a set of enums doing something with them */
11411 for (i = 0; ea_MultiDrawElementsBaseVertex[i].value != -1; i++)
11412 {
11413 }
11414
11415 tcu_msg("ApiCoverageTestCase::MultiDrawElementsBaseVertex", "Coverage test not implemented yet");
11416
11417 return success;
11418 }
11419
11420 /* Coverage test for glProvokingVertex */
11421
11422 /* Enums to test for glProvokingVertex (may not be required) */
11423 struct enumTestRec const ea_ProvokingVertex[] = {{"End of List", -1}};
11424
TestCoverageGLCallProvokingVertex(void)11425 bool ApiCoverageTestCase::TestCoverageGLCallProvokingVertex(void)
11426 {
11427 GLuint i;
11428 bool success = true;
11429
11430 /* glProvokingVertex may need to loop over a set of enums doing something with them */
11431 for (i = 0; ea_ProvokingVertex[i].value != -1; i++)
11432 {
11433 }
11434
11435 tcu_msg("ApiCoverageTestCase::ProvokingVertex", "Coverage test not implemented yet");
11436
11437 return success;
11438 }
11439
11440 /* Coverage test for glTexImage2DMultisample */
11441
11442 /* Enums to test for glTexImage2DMultisample (may not be required) */
11443 struct enumTestRec const ea_TexImage2DMultisample[] = {{"End of List", -1}};
11444
TestCoverageGLCallTexImage2DMultisample(void)11445 bool ApiCoverageTestCase::TestCoverageGLCallTexImage2DMultisample(void)
11446 {
11447 GLuint i;
11448 bool success = true;
11449
11450 /* glTexImage2DMultisample may need to loop over a set of enums doing something with them */
11451 for (i = 0; ea_TexImage2DMultisample[i].value != -1; i++)
11452 {
11453 }
11454
11455 tcu_msg("ApiCoverageTestCase::TexImage2DMultisample", "Coverage test not implemented yet");
11456
11457 return success;
11458 }
11459
11460 /* Coverage test for glTexImage3DMultisample */
11461
11462 /* Enums to test for glTexImage3DMultisample (may not be required) */
11463 struct enumTestRec const ea_TexImage3DMultisample[] = {{"End of List", -1}};
11464
TestCoverageGLCallTexImage3DMultisample(void)11465 bool ApiCoverageTestCase::TestCoverageGLCallTexImage3DMultisample(void)
11466 {
11467 GLuint i;
11468 bool success = true;
11469
11470 /* glTexImage3DMultisample may need to loop over a set of enums doing something with them */
11471 for (i = 0; ea_TexImage3DMultisample[i].value != -1; i++)
11472 {
11473 }
11474
11475 tcu_msg("ApiCoverageTestCase::TexImage3DMultisample", "Coverage test not implemented yet");
11476
11477 return success;
11478 }
11479
11480 /* Coverage test for glGetMultisamplefv */
11481
11482 /* Enums to test for glGetMultisamplefv (may not be required) */
11483 struct enumTestRec const ea_GetMultisamplefv[] = {{"End of List", -1}};
11484
TestCoverageGLCallGetMultisamplefv(void)11485 bool ApiCoverageTestCase::TestCoverageGLCallGetMultisamplefv(void)
11486 {
11487 GLuint i;
11488 bool success = true;
11489
11490 /* glGetMultisamplefv may need to loop over a set of enums doing something with them */
11491 for (i = 0; ea_GetMultisamplefv[i].value != -1; i++)
11492 {
11493 }
11494
11495 tcu_msg("ApiCoverageTestCase::GetMultisamplefv", "Coverage test not implemented yet");
11496
11497 return success;
11498 }
11499
11500 /* Coverage test for glSampleMaski */
11501
11502 /* Enums to test for glSampleMaski (may not be required) */
11503 struct enumTestRec const ea_SampleMaski[] = {{"End of List", -1}};
11504
TestCoverageGLCallSampleMaski(void)11505 bool ApiCoverageTestCase::TestCoverageGLCallSampleMaski(void)
11506 {
11507 GLuint i;
11508 bool success = true;
11509
11510 /* glSampleMaski may need to loop over a set of enums doing something with them */
11511 for (i = 0; ea_SampleMaski[i].value != -1; i++)
11512 {
11513 }
11514
11515 tcu_msg("ApiCoverageTestCase::SampleMaski", "Coverage test not implemented yet");
11516
11517 return success;
11518 }
11519
11520 /* OpenGL 3.3 entry points */
11521
11522 /* Coverage test for glBindFragDataLocationIndexed */
11523
11524 /* Enums to test for glBindFragDataLocationIndexed (may not be required) */
11525 struct enumTestRec const ea_BindFragDataLocationIndexed[] = {{"End of List", -1}};
11526
TestCoverageGLCallBindFragDataLocationIndexed(void)11527 bool ApiCoverageTestCase::TestCoverageGLCallBindFragDataLocationIndexed(void)
11528 {
11529 GLuint i;
11530 bool success = true;
11531
11532 /* glBindFragDataLocationIndexed may need to loop over a set of enums doing something with them */
11533 for (i = 0; ea_BindFragDataLocationIndexed[i].value != -1; i++)
11534 {
11535 }
11536
11537 tcu_msg("ApiCoverageTestCase::BindFragDataLocationIndexed", "Coverage test not implemented yet");
11538
11539 return success;
11540 }
11541
11542 /* Coverage test for glGetFragDataIndex */
11543
11544 /* Enums to test for glGetFragDataIndex (may not be required) */
11545 struct enumTestRec const ea_GetFragDataIndex[] = {{"End of List", -1}};
11546
TestCoverageGLCallGetFragDataIndex(void)11547 bool ApiCoverageTestCase::TestCoverageGLCallGetFragDataIndex(void)
11548 {
11549 GLuint i;
11550 bool success = true;
11551
11552 /* glGetFragDataIndex may need to loop over a set of enums doing something with them */
11553 for (i = 0; ea_GetFragDataIndex[i].value != -1; i++)
11554 {
11555 }
11556
11557 tcu_msg("ApiCoverageTestCase::GetFragDataIndex", "Coverage test not implemented yet");
11558
11559 return success;
11560 }
11561
11562 /* Coverage test for glSamplerParameterIiv */
11563
11564 /* Enums to test for glSamplerParameterIiv (may not be required) */
11565 struct enumTestRec const ea_SamplerParameterIiv[] = {{"End of List", -1}};
11566
TestCoverageGLCallSamplerParameterIiv(void)11567 bool ApiCoverageTestCase::TestCoverageGLCallSamplerParameterIiv(void)
11568 {
11569 GLuint i;
11570 bool success = true;
11571
11572 /* glSamplerParameterIiv may need to loop over a set of enums doing something with them */
11573 for (i = 0; ea_SamplerParameterIiv[i].value != -1; i++)
11574 {
11575 }
11576
11577 tcu_msg("ApiCoverageTestCase::SamplerParameterIiv", "Coverage test not implemented yet");
11578
11579 return success;
11580 }
11581
11582 /* Coverage test for glSamplerParameterIuiv */
11583
11584 /* Enums to test for glSamplerParameterIuiv (may not be required) */
11585 struct enumTestRec const ea_SamplerParameterIuiv[] = {{"End of List", -1}};
11586
TestCoverageGLCallSamplerParameterIuiv(void)11587 bool ApiCoverageTestCase::TestCoverageGLCallSamplerParameterIuiv(void)
11588 {
11589 GLuint i;
11590 bool success = true;
11591
11592 /* glSamplerParameterIuiv may need to loop over a set of enums doing something with them */
11593 for (i = 0; ea_SamplerParameterIuiv[i].value != -1; i++)
11594 {
11595 }
11596
11597 tcu_msg("ApiCoverageTestCase::SamplerParameterIuiv", "Coverage test not implemented yet");
11598
11599 return success;
11600 }
11601
11602 /* Coverage test for glGetSamplerParameterIiv */
11603
11604 /* Enums to test for glGetSamplerParameterIiv (may not be required) */
11605 struct enumTestRec const ea_GetSamplerParameterIiv[] = {{"End of List", -1}};
11606
TestCoverageGLCallGetSamplerParameterIiv(void)11607 bool ApiCoverageTestCase::TestCoverageGLCallGetSamplerParameterIiv(void)
11608 {
11609 GLuint i;
11610 bool success = true;
11611
11612 /* glGetSamplerParameterIiv may need to loop over a set of enums doing something with them */
11613 for (i = 0; ea_GetSamplerParameterIiv[i].value != -1; i++)
11614 {
11615 }
11616
11617 tcu_msg("ApiCoverageTestCase::GetSamplerParameterIiv", "Coverage test not implemented yet");
11618
11619 return success;
11620 }
11621
11622 /* Coverage test for glGetSamplerParameterIfv */
11623
11624 /* Enums to test for glGetSamplerParameterIfv (may not be required) */
11625 struct enumTestRec const ea_GetSamplerParameterIfv[] = {{"End of List", -1}};
11626
TestCoverageGLCallGetSamplerParameterIfv(void)11627 bool ApiCoverageTestCase::TestCoverageGLCallGetSamplerParameterIfv(void)
11628 {
11629 GLuint i;
11630 bool success = true;
11631
11632 /* glGetSamplerParameterIfv may need to loop over a set of enums doing something with them */
11633 for (i = 0; ea_GetSamplerParameterIfv[i].value != -1; i++)
11634 {
11635 }
11636
11637 tcu_msg("ApiCoverageTestCase::GetSamplerParameterIfv", "Coverage test not implemented yet");
11638
11639 return success;
11640 }
11641
11642 /* Coverage test for glQueryCounter */
11643
11644 /* Enums to test for glQueryCounter (may not be required) */
11645 struct enumTestRec const ea_QueryCounter[] = {{"End of List", -1}};
11646
TestCoverageGLCallQueryCounter(void)11647 bool ApiCoverageTestCase::TestCoverageGLCallQueryCounter(void)
11648 {
11649 GLuint i;
11650 bool success = true;
11651
11652 /* glQueryCounter may need to loop over a set of enums doing something with them */
11653 for (i = 0; ea_QueryCounter[i].value != -1; i++)
11654 {
11655 }
11656
11657 tcu_msg("ApiCoverageTestCase::QueryCounter", "Coverage test not implemented yet");
11658
11659 return success;
11660 }
11661
11662 /* Coverage test for glGetQueryObjecti64v */
11663
11664 /* Enums to test for glGetQueryObjecti64v (may not be required) */
11665 struct enumTestRec const ea_GetQueryObjecti64v[] = {{"End of List", -1}};
11666
TestCoverageGLCallGetQueryObjecti64v(void)11667 bool ApiCoverageTestCase::TestCoverageGLCallGetQueryObjecti64v(void)
11668 {
11669 GLuint i;
11670 bool success = true;
11671
11672 /* glGetQueryObjecti64v may need to loop over a set of enums doing something with them */
11673 for (i = 0; ea_GetQueryObjecti64v[i].value != -1; i++)
11674 {
11675 }
11676
11677 tcu_msg("ApiCoverageTestCase::GetQueryObjecti64v", "Coverage test not implemented yet");
11678
11679 return success;
11680 }
11681
11682 /* Coverage test for glGetQueryObjectui64v */
11683
11684 /* Enums to test for glGetQueryObjectui64v (may not be required) */
11685 struct enumTestRec const ea_GetQueryObjectui64v[] = {{"End of List", -1}};
11686
TestCoverageGLCallGetQueryObjectui64v(void)11687 bool ApiCoverageTestCase::TestCoverageGLCallGetQueryObjectui64v(void)
11688 {
11689 GLuint i;
11690 bool success = true;
11691
11692 /* glGetQueryObjectui64v may need to loop over a set of enums doing something with them */
11693 for (i = 0; ea_GetQueryObjectui64v[i].value != -1; i++)
11694 {
11695 }
11696
11697 tcu_msg("ApiCoverageTestCase::GetQueryObjectui64v", "Coverage test not implemented yet");
11698
11699 return success;
11700 }
11701
11702 /* Coverage test for glVertexP2ui */
11703
11704 /* Enums to test for glVertexP2ui (may not be required) */
11705 struct enumTestRec const ea_VertexP2ui[] = {{"End of List", -1}};
11706
TestCoverageGLCallVertexP2ui(void)11707 bool ApiCoverageTestCase::TestCoverageGLCallVertexP2ui(void)
11708 {
11709 GLuint i;
11710 bool success = true;
11711
11712 /* glVertexP2ui may need to loop over a set of enums doing something with them */
11713 for (i = 0; ea_VertexP2ui[i].value != -1; i++)
11714 {
11715 }
11716
11717 tcu_msg("ApiCoverageTestCase::VertexP2ui", "Coverage test not implemented yet");
11718
11719 return success;
11720 }
11721
11722 /* Coverage test for glVertexP2uiv */
11723
11724 /* Enums to test for glVertexP2uiv (may not be required) */
11725 struct enumTestRec const ea_VertexP2uiv[] = {{"End of List", -1}};
11726
TestCoverageGLCallVertexP2uiv(void)11727 bool ApiCoverageTestCase::TestCoverageGLCallVertexP2uiv(void)
11728 {
11729 GLuint i;
11730 bool success = true;
11731
11732 /* glVertexP2uiv may need to loop over a set of enums doing something with them */
11733 for (i = 0; ea_VertexP2uiv[i].value != -1; i++)
11734 {
11735 }
11736
11737 tcu_msg("ApiCoverageTestCase::VertexP2uiv", "Coverage test not implemented yet");
11738
11739 return success;
11740 }
11741
11742 /* Coverage test for glVertexP3ui */
11743
11744 /* Enums to test for glVertexP3ui (may not be required) */
11745 struct enumTestRec const ea_VertexP3ui[] = {{"End of List", -1}};
11746
TestCoverageGLCallVertexP3ui(void)11747 bool ApiCoverageTestCase::TestCoverageGLCallVertexP3ui(void)
11748 {
11749 GLuint i;
11750 bool success = true;
11751
11752 /* glVertexP3ui may need to loop over a set of enums doing something with them */
11753 for (i = 0; ea_VertexP3ui[i].value != -1; i++)
11754 {
11755 }
11756
11757 tcu_msg("ApiCoverageTestCase::VertexP3ui", "Coverage test not implemented yet");
11758
11759 return success;
11760 }
11761
11762 /* Coverage test for glVertexP3uiv */
11763
11764 /* Enums to test for glVertexP3uiv (may not be required) */
11765 struct enumTestRec const ea_VertexP3uiv[] = {{"End of List", -1}};
11766
TestCoverageGLCallVertexP3uiv(void)11767 bool ApiCoverageTestCase::TestCoverageGLCallVertexP3uiv(void)
11768 {
11769 GLuint i;
11770 bool success = true;
11771
11772 /* glVertexP3uiv may need to loop over a set of enums doing something with them */
11773 for (i = 0; ea_VertexP3uiv[i].value != -1; i++)
11774 {
11775 }
11776
11777 tcu_msg("ApiCoverageTestCase::VertexP3uiv", "Coverage test not implemented yet");
11778
11779 return success;
11780 }
11781
11782 /* Coverage test for glVertexP4ui */
11783
11784 /* Enums to test for glVertexP4ui (may not be required) */
11785 struct enumTestRec const ea_VertexP4ui[] = {{"End of List", -1}};
11786
TestCoverageGLCallVertexP4ui(void)11787 bool ApiCoverageTestCase::TestCoverageGLCallVertexP4ui(void)
11788 {
11789 GLuint i;
11790 bool success = true;
11791
11792 /* glVertexP4ui may need to loop over a set of enums doing something with them */
11793 for (i = 0; ea_VertexP4ui[i].value != -1; i++)
11794 {
11795 }
11796
11797 tcu_msg("ApiCoverageTestCase::VertexP4ui", "Coverage test not implemented yet");
11798
11799 return success;
11800 }
11801
11802 /* Coverage test for glVertexP4uiv */
11803
11804 /* Enums to test for glVertexP4uiv (may not be required) */
11805 struct enumTestRec const ea_VertexP4uiv[] = {{"End of List", -1}};
11806
TestCoverageGLCallVertexP4uiv(void)11807 bool ApiCoverageTestCase::TestCoverageGLCallVertexP4uiv(void)
11808 {
11809 GLuint i;
11810 bool success = true;
11811
11812 /* glVertexP4uiv may need to loop over a set of enums doing something with them */
11813 for (i = 0; ea_VertexP4uiv[i].value != -1; i++)
11814 {
11815 }
11816
11817 tcu_msg("ApiCoverageTestCase::VertexP4uiv", "Coverage test not implemented yet");
11818
11819 return success;
11820 }
11821
11822 /* Coverage test for glTexCoordP1ui */
11823
11824 /* Enums to test for glTexCoordP1ui (may not be required) */
11825 struct enumTestRec const ea_TexCoordP1ui[] = {{"End of List", -1}};
11826
TestCoverageGLCallTexCoordP1ui(void)11827 bool ApiCoverageTestCase::TestCoverageGLCallTexCoordP1ui(void)
11828 {
11829 GLuint i;
11830 bool success = true;
11831
11832 /* glTexCoordP1ui may need to loop over a set of enums doing something with them */
11833 for (i = 0; ea_TexCoordP1ui[i].value != -1; i++)
11834 {
11835 }
11836
11837 tcu_msg("ApiCoverageTestCase::TexCoordP1ui", "Coverage test not implemented yet");
11838
11839 return success;
11840 }
11841
11842 /* Coverage test for glTexCoordP1uiv */
11843
11844 /* Enums to test for glTexCoordP1uiv (may not be required) */
11845 struct enumTestRec const ea_TexCoordP1uiv[] = {{"End of List", -1}};
11846
TestCoverageGLCallTexCoordP1uiv(void)11847 bool ApiCoverageTestCase::TestCoverageGLCallTexCoordP1uiv(void)
11848 {
11849 GLuint i;
11850 bool success = true;
11851
11852 /* glTexCoordP1uiv may need to loop over a set of enums doing something with them */
11853 for (i = 0; ea_TexCoordP1uiv[i].value != -1; i++)
11854 {
11855 }
11856
11857 tcu_msg("ApiCoverageTestCase::TexCoordP1uiv", "Coverage test not implemented yet");
11858
11859 return success;
11860 }
11861
11862 /* Coverage test for glTexCoordP2ui */
11863
11864 /* Enums to test for glTexCoordP2ui (may not be required) */
11865 struct enumTestRec const ea_TexCoordP2ui[] = {{"End of List", -1}};
11866
TestCoverageGLCallTexCoordP2ui(void)11867 bool ApiCoverageTestCase::TestCoverageGLCallTexCoordP2ui(void)
11868 {
11869 GLuint i;
11870 bool success = true;
11871
11872 /* glTexCoordP2ui may need to loop over a set of enums doing something with them */
11873 for (i = 0; ea_TexCoordP2ui[i].value != -1; i++)
11874 {
11875 }
11876
11877 tcu_msg("ApiCoverageTestCase::TexCoordP2ui", "Coverage test not implemented yet");
11878
11879 return success;
11880 }
11881
11882 /* Coverage test for glTexCoordP2uiv */
11883
11884 /* Enums to test for glTexCoordP2uiv (may not be required) */
11885 struct enumTestRec const ea_TexCoordP2uiv[] = {{"End of List", -1}};
11886
TestCoverageGLCallTexCoordP2uiv(void)11887 bool ApiCoverageTestCase::TestCoverageGLCallTexCoordP2uiv(void)
11888 {
11889 GLuint i;
11890 bool success = true;
11891
11892 /* glTexCoordP2uiv may need to loop over a set of enums doing something with them */
11893 for (i = 0; ea_TexCoordP2uiv[i].value != -1; i++)
11894 {
11895 }
11896
11897 tcu_msg("ApiCoverageTestCase::TexCoordP2uiv", "Coverage test not implemented yet");
11898
11899 return success;
11900 }
11901
11902 /* Coverage test for glTexCoordP3ui */
11903
11904 /* Enums to test for glTexCoordP3ui (may not be required) */
11905 struct enumTestRec const ea_TexCoordP3ui[] = {{"End of List", -1}};
11906
TestCoverageGLCallTexCoordP3ui(void)11907 bool ApiCoverageTestCase::TestCoverageGLCallTexCoordP3ui(void)
11908 {
11909 GLuint i;
11910 bool success = true;
11911
11912 /* glTexCoordP3ui may need to loop over a set of enums doing something with them */
11913 for (i = 0; ea_TexCoordP3ui[i].value != -1; i++)
11914 {
11915 }
11916
11917 tcu_msg("ApiCoverageTestCase::TexCoordP3ui", "Coverage test not implemented yet");
11918
11919 return success;
11920 }
11921
11922 /* Coverage test for glTexCoordP3uiv */
11923
11924 /* Enums to test for glTexCoordP3uiv (may not be required) */
11925 struct enumTestRec const ea_TexCoordP3uiv[] = {{"End of List", -1}};
11926
TestCoverageGLCallTexCoordP3uiv(void)11927 bool ApiCoverageTestCase::TestCoverageGLCallTexCoordP3uiv(void)
11928 {
11929 GLuint i;
11930 bool success = true;
11931
11932 /* glTexCoordP3uiv may need to loop over a set of enums doing something with them */
11933 for (i = 0; ea_TexCoordP3uiv[i].value != -1; i++)
11934 {
11935 }
11936
11937 tcu_msg("ApiCoverageTestCase::TexCoordP3uiv", "Coverage test not implemented yet");
11938
11939 return success;
11940 }
11941
11942 /* Coverage test for glTexCoordP4ui */
11943
11944 /* Enums to test for glTexCoordP4ui (may not be required) */
11945 struct enumTestRec const ea_TexCoordP4ui[] = {{"End of List", -1}};
11946
TestCoverageGLCallTexCoordP4ui(void)11947 bool ApiCoverageTestCase::TestCoverageGLCallTexCoordP4ui(void)
11948 {
11949 GLuint i;
11950 bool success = true;
11951
11952 /* glTexCoordP4ui may need to loop over a set of enums doing something with them */
11953 for (i = 0; ea_TexCoordP4ui[i].value != -1; i++)
11954 {
11955 }
11956
11957 tcu_msg("ApiCoverageTestCase::TexCoordP4ui", "Coverage test not implemented yet");
11958
11959 return success;
11960 }
11961
11962 /* Coverage test for glTexCoordP4uiv */
11963
11964 /* Enums to test for glTexCoordP4uiv (may not be required) */
11965 struct enumTestRec const ea_TexCoordP4uiv[] = {{"End of List", -1}};
11966
TestCoverageGLCallTexCoordP4uiv(void)11967 bool ApiCoverageTestCase::TestCoverageGLCallTexCoordP4uiv(void)
11968 {
11969 GLuint i;
11970 bool success = true;
11971
11972 /* glTexCoordP4uiv may need to loop over a set of enums doing something with them */
11973 for (i = 0; ea_TexCoordP4uiv[i].value != -1; i++)
11974 {
11975 }
11976
11977 tcu_msg("ApiCoverageTestCase::TexCoordP4uiv", "Coverage test not implemented yet");
11978
11979 return success;
11980 }
11981
11982 /* Coverage test for glMultiTexCoordP1ui */
11983
11984 /* Enums to test for glMultiTexCoordP1ui (may not be required) */
11985 struct enumTestRec const ea_MultiTexCoordP1ui[] = {{"End of List", -1}};
11986
TestCoverageGLCallMultiTexCoordP1ui(void)11987 bool ApiCoverageTestCase::TestCoverageGLCallMultiTexCoordP1ui(void)
11988 {
11989 GLuint i;
11990 bool success = true;
11991
11992 /* glMultiTexCoordP1ui may need to loop over a set of enums doing something with them */
11993 for (i = 0; ea_MultiTexCoordP1ui[i].value != -1; i++)
11994 {
11995 }
11996
11997 tcu_msg("ApiCoverageTestCase::MultiTexCoordP1ui", "Coverage test not implemented yet");
11998
11999 return success;
12000 }
12001
12002 /* Coverage test for glMultiTexCoordP1uiv */
12003
12004 /* Enums to test for glMultiTexCoordP1uiv (may not be required) */
12005 struct enumTestRec const ea_MultiTexCoordP1uiv[] = {{"End of List", -1}};
12006
TestCoverageGLCallMultiTexCoordP1uiv(void)12007 bool ApiCoverageTestCase::TestCoverageGLCallMultiTexCoordP1uiv(void)
12008 {
12009 GLuint i;
12010 bool success = true;
12011
12012 /* glMultiTexCoordP1uiv may need to loop over a set of enums doing something with them */
12013 for (i = 0; ea_MultiTexCoordP1uiv[i].value != -1; i++)
12014 {
12015 }
12016
12017 tcu_msg("ApiCoverageTestCase::MultiTexCoordP1uiv", "Coverage test not implemented yet");
12018
12019 return success;
12020 }
12021
12022 /* Coverage test for glMultiTexCoordP2ui */
12023
12024 /* Enums to test for glMultiTexCoordP2ui (may not be required) */
12025 struct enumTestRec const ea_MultiTexCoordP2ui[] = {{"End of List", -1}};
12026
TestCoverageGLCallMultiTexCoordP2ui(void)12027 bool ApiCoverageTestCase::TestCoverageGLCallMultiTexCoordP2ui(void)
12028 {
12029 GLuint i;
12030 bool success = true;
12031
12032 /* glMultiTexCoordP2ui may need to loop over a set of enums doing something with them */
12033 for (i = 0; ea_MultiTexCoordP2ui[i].value != -1; i++)
12034 {
12035 }
12036
12037 tcu_msg("ApiCoverageTestCase::MultiTexCoordP2ui", "Coverage test not implemented yet");
12038
12039 return success;
12040 }
12041
12042 /* Coverage test for glMultiTexCoordP2uiv */
12043
12044 /* Enums to test for glMultiTexCoordP2uiv (may not be required) */
12045 struct enumTestRec const ea_MultiTexCoordP2uiv[] = {{"End of List", -1}};
12046
TestCoverageGLCallMultiTexCoordP2uiv(void)12047 bool ApiCoverageTestCase::TestCoverageGLCallMultiTexCoordP2uiv(void)
12048 {
12049 GLuint i;
12050 bool success = true;
12051
12052 /* glMultiTexCoordP2uiv may need to loop over a set of enums doing something with them */
12053 for (i = 0; ea_MultiTexCoordP2uiv[i].value != -1; i++)
12054 {
12055 }
12056
12057 tcu_msg("ApiCoverageTestCase::MultiTexCoordP2uiv", "Coverage test not implemented yet");
12058
12059 return success;
12060 }
12061
12062 /* Coverage test for glMultiTexCoordP3ui */
12063
12064 /* Enums to test for glMultiTexCoordP3ui (may not be required) */
12065 struct enumTestRec const ea_MultiTexCoordP3ui[] = {{"End of List", -1}};
12066
TestCoverageGLCallMultiTexCoordP3ui(void)12067 bool ApiCoverageTestCase::TestCoverageGLCallMultiTexCoordP3ui(void)
12068 {
12069 GLuint i;
12070 bool success = true;
12071
12072 /* glMultiTexCoordP3ui may need to loop over a set of enums doing something with them */
12073 for (i = 0; ea_MultiTexCoordP3ui[i].value != -1; i++)
12074 {
12075 }
12076
12077 tcu_msg("ApiCoverageTestCase::MultiTexCoordP3ui", "Coverage test not implemented yet");
12078
12079 return success;
12080 }
12081
12082 /* Coverage test for glMultiTexCoordP3uiv */
12083
12084 /* Enums to test for glMultiTexCoordP3uiv (may not be required) */
12085 struct enumTestRec const ea_MultiTexCoordP3uiv[] = {{"End of List", -1}};
12086
TestCoverageGLCallMultiTexCoordP3uiv(void)12087 bool ApiCoverageTestCase::TestCoverageGLCallMultiTexCoordP3uiv(void)
12088 {
12089 GLuint i;
12090 bool success = true;
12091
12092 /* glMultiTexCoordP3uiv may need to loop over a set of enums doing something with them */
12093 for (i = 0; ea_MultiTexCoordP3uiv[i].value != -1; i++)
12094 {
12095 }
12096
12097 tcu_msg("ApiCoverageTestCase::MultiTexCoordP3uiv", "Coverage test not implemented yet");
12098
12099 return success;
12100 }
12101
12102 /* Coverage test for glMultiTexCoordP4ui */
12103
12104 /* Enums to test for glMultiTexCoordP4ui (may not be required) */
12105 struct enumTestRec const ea_MultiTexCoordP4ui[] = {{"End of List", -1}};
12106
TestCoverageGLCallMultiTexCoordP4ui(void)12107 bool ApiCoverageTestCase::TestCoverageGLCallMultiTexCoordP4ui(void)
12108 {
12109 GLuint i;
12110 bool success = true;
12111
12112 /* glMultiTexCoordP4ui may need to loop over a set of enums doing something with them */
12113 for (i = 0; ea_MultiTexCoordP4ui[i].value != -1; i++)
12114 {
12115 }
12116
12117 tcu_msg("ApiCoverageTestCase::MultiTexCoordP4ui", "Coverage test not implemented yet");
12118
12119 return success;
12120 }
12121
12122 /* Coverage test for glMultiTexCoordP4uiv */
12123
12124 /* Enums to test for glMultiTexCoordP4uiv (may not be required) */
12125 struct enumTestRec const ea_MultiTexCoordP4uiv[] = {{"End of List", -1}};
12126
TestCoverageGLCallMultiTexCoordP4uiv(void)12127 bool ApiCoverageTestCase::TestCoverageGLCallMultiTexCoordP4uiv(void)
12128 {
12129 GLuint i;
12130 bool success = true;
12131
12132 /* glMultiTexCoordP4uiv may need to loop over a set of enums doing something with them */
12133 for (i = 0; ea_MultiTexCoordP4uiv[i].value != -1; i++)
12134 {
12135 }
12136
12137 tcu_msg("ApiCoverageTestCase::MultiTexCoordP4uiv", "Coverage test not implemented yet");
12138
12139 return success;
12140 }
12141
12142 /* Coverage test for glNormalP3ui */
12143
12144 /* Enums to test for glNormalP3ui (may not be required) */
12145 struct enumTestRec const ea_NormalP3ui[] = {{"End of List", -1}};
12146
TestCoverageGLCallNormalP3ui(void)12147 bool ApiCoverageTestCase::TestCoverageGLCallNormalP3ui(void)
12148 {
12149 GLuint i;
12150 bool success = true;
12151
12152 /* glNormalP3ui may need to loop over a set of enums doing something with them */
12153 for (i = 0; ea_NormalP3ui[i].value != -1; i++)
12154 {
12155 }
12156
12157 tcu_msg("ApiCoverageTestCase::NormalP3ui", "Coverage test not implemented yet");
12158
12159 return success;
12160 }
12161
12162 /* Coverage test for glNormalP3uiv */
12163
12164 /* Enums to test for glNormalP3uiv (may not be required) */
12165 struct enumTestRec const ea_NormalP3uiv[] = {{"End of List", -1}};
12166
TestCoverageGLCallNormalP3uiv(void)12167 bool ApiCoverageTestCase::TestCoverageGLCallNormalP3uiv(void)
12168 {
12169 GLuint i;
12170 bool success = true;
12171
12172 /* glNormalP3uiv may need to loop over a set of enums doing something with them */
12173 for (i = 0; ea_NormalP3uiv[i].value != -1; i++)
12174 {
12175 }
12176
12177 tcu_msg("ApiCoverageTestCase::NormalP3uiv", "Coverage test not implemented yet");
12178
12179 return success;
12180 }
12181
12182 /* Coverage test for glColorP3ui */
12183
12184 /* Enums to test for glColorP3ui (may not be required) */
12185 struct enumTestRec const ea_ColorP3ui[] = {{"End of List", -1}};
12186
TestCoverageGLCallColorP3ui(void)12187 bool ApiCoverageTestCase::TestCoverageGLCallColorP3ui(void)
12188 {
12189 GLuint i;
12190 bool success = true;
12191
12192 /* glColorP3ui may need to loop over a set of enums doing something with them */
12193 for (i = 0; ea_ColorP3ui[i].value != -1; i++)
12194 {
12195 }
12196
12197 tcu_msg("ApiCoverageTestCase::ColorP3ui", "Coverage test not implemented yet");
12198
12199 return success;
12200 }
12201
12202 /* Coverage test for glColorP3uiv */
12203
12204 /* Enums to test for glColorP3uiv (may not be required) */
12205 struct enumTestRec const ea_ColorP3uiv[] = {{"End of List", -1}};
12206
TestCoverageGLCallColorP3uiv(void)12207 bool ApiCoverageTestCase::TestCoverageGLCallColorP3uiv(void)
12208 {
12209 GLuint i;
12210 bool success = true;
12211
12212 /* glColorP3uiv may need to loop over a set of enums doing something with them */
12213 for (i = 0; ea_ColorP3uiv[i].value != -1; i++)
12214 {
12215 }
12216
12217 tcu_msg("ApiCoverageTestCase::ColorP3uiv", "Coverage test not implemented yet");
12218
12219 return success;
12220 }
12221
12222 /* Coverage test for glColorP4ui */
12223
12224 /* Enums to test for glColorP4ui (may not be required) */
12225 struct enumTestRec const ea_ColorP4ui[] = {{"End of List", -1}};
12226
TestCoverageGLCallColorP4ui(void)12227 bool ApiCoverageTestCase::TestCoverageGLCallColorP4ui(void)
12228 {
12229 GLuint i;
12230 bool success = true;
12231
12232 /* glColorP4ui may need to loop over a set of enums doing something with them */
12233 for (i = 0; ea_ColorP4ui[i].value != -1; i++)
12234 {
12235 }
12236
12237 tcu_msg("ApiCoverageTestCase::ColorP4ui", "Coverage test not implemented yet");
12238
12239 return success;
12240 }
12241
12242 /* Coverage test for glColorP4uiv */
12243
12244 /* Enums to test for glColorP4uiv (may not be required) */
12245 struct enumTestRec const ea_ColorP4uiv[] = {{"End of List", -1}};
12246
TestCoverageGLCallColorP4uiv(void)12247 bool ApiCoverageTestCase::TestCoverageGLCallColorP4uiv(void)
12248 {
12249 GLuint i;
12250 bool success = true;
12251
12252 /* glColorP4uiv may need to loop over a set of enums doing something with them */
12253 for (i = 0; ea_ColorP4uiv[i].value != -1; i++)
12254 {
12255 }
12256
12257 tcu_msg("ApiCoverageTestCase::ColorP4uiv", "Coverage test not implemented yet");
12258
12259 return success;
12260 }
12261
12262 /* Coverage test for glSecondaryColorP3ui */
12263
12264 /* Enums to test for glSecondaryColorP3ui (may not be required) */
12265 struct enumTestRec const ea_SecondaryColorP3ui[] = {{"End of List", -1}};
12266
TestCoverageGLCallSecondaryColorP3ui(void)12267 bool ApiCoverageTestCase::TestCoverageGLCallSecondaryColorP3ui(void)
12268 {
12269 GLuint i;
12270 bool success = true;
12271
12272 /* glSecondaryColorP3ui may need to loop over a set of enums doing something with them */
12273 for (i = 0; ea_SecondaryColorP3ui[i].value != -1; i++)
12274 {
12275 }
12276
12277 tcu_msg("ApiCoverageTestCase::SecondaryColorP3ui", "Coverage test not implemented yet");
12278
12279 return success;
12280 }
12281
12282 /* Coverage test for glSecondaryColorP3uiv */
12283
12284 /* Enums to test for glSecondaryColorP3uiv (may not be required) */
12285 struct enumTestRec const ea_SecondaryColorP3uiv[] = {{"End of List", -1}};
12286
TestCoverageGLCallSecondaryColorP3uiv(void)12287 bool ApiCoverageTestCase::TestCoverageGLCallSecondaryColorP3uiv(void)
12288 {
12289 GLuint i;
12290 bool success = true;
12291
12292 /* glSecondaryColorP3uiv may need to loop over a set of enums doing something with them */
12293 for (i = 0; ea_SecondaryColorP3uiv[i].value != -1; i++)
12294 {
12295 }
12296
12297 tcu_msg("ApiCoverageTestCase::SecondaryColorP3uiv", "Coverage test not implemented yet");
12298
12299 return success;
12300 }
12301
12302 /* Coverage test for glVertexAttribP1ui */
12303
12304 /* Enums to test for glVertexAttribP1ui (may not be required) */
12305 struct enumTestRec const ea_VertexAttribP1ui[] = {{"End of List", -1}};
12306
TestCoverageGLCallVertexAttribP1ui(void)12307 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribP1ui(void)
12308 {
12309 GLuint i;
12310 bool success = true;
12311
12312 /* glVertexAttribP1ui may need to loop over a set of enums doing something with them */
12313 for (i = 0; ea_VertexAttribP1ui[i].value != -1; i++)
12314 {
12315 }
12316
12317 tcu_msg("ApiCoverageTestCase::VertexAttribP1ui", "Coverage test not implemented yet");
12318
12319 return success;
12320 }
12321
12322 /* Coverage test for glVertexAttribP1uiv */
12323
12324 /* Enums to test for glVertexAttribP1uiv (may not be required) */
12325 struct enumTestRec const ea_VertexAttribP1uiv[] = {{"End of List", -1}};
12326
TestCoverageGLCallVertexAttribP1uiv(void)12327 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribP1uiv(void)
12328 {
12329 GLuint i;
12330 bool success = true;
12331
12332 /* glVertexAttribP1uiv may need to loop over a set of enums doing something with them */
12333 for (i = 0; ea_VertexAttribP1uiv[i].value != -1; i++)
12334 {
12335 }
12336
12337 tcu_msg("ApiCoverageTestCase::VertexAttribP1uiv", "Coverage test not implemented yet");
12338
12339 return success;
12340 }
12341
12342 /* Coverage test for glVertexAttribP2ui */
12343
12344 /* Enums to test for glVertexAttribP2ui (may not be required) */
12345 struct enumTestRec const ea_VertexAttribP2ui[] = {{"End of List", -1}};
12346
TestCoverageGLCallVertexAttribP2ui(void)12347 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribP2ui(void)
12348 {
12349 GLuint i;
12350 bool success = true;
12351
12352 /* glVertexAttribP2ui may need to loop over a set of enums doing something with them */
12353 for (i = 0; ea_VertexAttribP2ui[i].value != -1; i++)
12354 {
12355 }
12356
12357 tcu_msg("ApiCoverageTestCase::VertexAttribP2ui", "Coverage test not implemented yet");
12358
12359 return success;
12360 }
12361
12362 /* Coverage test for glVertexAttribP2uiv */
12363
12364 /* Enums to test for glVertexAttribP2uiv (may not be required) */
12365 struct enumTestRec const ea_VertexAttribP2uiv[] = {{"End of List", -1}};
12366
TestCoverageGLCallVertexAttribP2uiv(void)12367 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribP2uiv(void)
12368 {
12369 GLuint i;
12370 bool success = true;
12371
12372 /* glVertexAttribP2uiv may need to loop over a set of enums doing something with them */
12373 for (i = 0; ea_VertexAttribP2uiv[i].value != -1; i++)
12374 {
12375 }
12376
12377 tcu_msg("ApiCoverageTestCase::VertexAttribP2uiv", "Coverage test not implemented yet");
12378
12379 return success;
12380 }
12381
12382 /* Coverage test for glVertexAttribP3ui */
12383
12384 /* Enums to test for glVertexAttribP3ui (may not be required) */
12385 struct enumTestRec const ea_VertexAttribP3ui[] = {{"End of List", -1}};
12386
TestCoverageGLCallVertexAttribP3ui(void)12387 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribP3ui(void)
12388 {
12389 GLuint i;
12390 bool success = true;
12391
12392 /* glVertexAttribP3ui may need to loop over a set of enums doing something with them */
12393 for (i = 0; ea_VertexAttribP3ui[i].value != -1; i++)
12394 {
12395 }
12396
12397 tcu_msg("ApiCoverageTestCase::VertexAttribP3ui", "Coverage test not implemented yet");
12398
12399 return success;
12400 }
12401
12402 /* Coverage test for glVertexAttribP3uiv */
12403
12404 /* Enums to test for glVertexAttribP3uiv (may not be required) */
12405 struct enumTestRec const ea_VertexAttribP3uiv[] = {{"End of List", -1}};
12406
TestCoverageGLCallVertexAttribP3uiv(void)12407 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribP3uiv(void)
12408 {
12409 GLuint i;
12410 bool success = true;
12411
12412 /* glVertexAttribP3uiv may need to loop over a set of enums doing something with them */
12413 for (i = 0; ea_VertexAttribP3uiv[i].value != -1; i++)
12414 {
12415 }
12416
12417 tcu_msg("ApiCoverageTestCase::VertexAttribP3uiv", "Coverage test not implemented yet");
12418
12419 return success;
12420 }
12421
12422 /* Coverage test for glVertexAttribP4ui */
12423
12424 /* Enums to test for glVertexAttribP4ui (may not be required) */
12425 struct enumTestRec const ea_VertexAttribP4ui[] = {{"End of List", -1}};
12426
TestCoverageGLCallVertexAttribP4ui(void)12427 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribP4ui(void)
12428 {
12429 GLuint i;
12430 bool success = true;
12431
12432 /* glVertexAttribP4ui may need to loop over a set of enums doing something with them */
12433 for (i = 0; ea_VertexAttribP4ui[i].value != -1; i++)
12434 {
12435 }
12436
12437 tcu_msg("ApiCoverageTestCase::VertexAttribP4ui", "Coverage test not implemented yet");
12438
12439 return success;
12440 }
12441
12442 /* Coverage test for glVertexAttribP4uiv */
12443
12444 /* Enums to test for glVertexAttribP4uiv (may not be required) */
12445 struct enumTestRec const ea_VertexAttribP4uiv[] = {{"End of List", -1}};
12446
TestCoverageGLCallVertexAttribP4uiv(void)12447 bool ApiCoverageTestCase::TestCoverageGLCallVertexAttribP4uiv(void)
12448 {
12449 GLuint i;
12450 bool success = true;
12451
12452 /* glVertexAttribP4uiv may need to loop over a set of enums doing something with them */
12453 for (i = 0; ea_VertexAttribP4uiv[i].value != -1; i++)
12454 {
12455 }
12456
12457 tcu_msg("ApiCoverageTestCase::VertexAttribP4uiv", "Coverage test not implemented yet");
12458
12459 return success;
12460 }
12461
12462 /* OpenGL 4.0 entry points */
12463
12464 /* Coverage test for glDrawArraysIndirect */
12465
12466 /* Enums to test for glDrawArraysIndirect (may not be required) */
12467 struct enumTestRec const ea_DrawArraysIndirect[] = {{"End of List", -1}};
12468
TestCoverageGLCallDrawArraysIndirect(void)12469 bool ApiCoverageTestCase::TestCoverageGLCallDrawArraysIndirect(void)
12470 {
12471 GLuint i;
12472 bool success = true;
12473
12474 /* glDrawArraysIndirect may need to loop over a set of enums doing something with them */
12475 for (i = 0; ea_DrawArraysIndirect[i].value != -1; i++)
12476 {
12477 }
12478
12479 tcu_msg("ApiCoverageTestCase::DrawArraysIndirect", "Coverage test not implemented yet");
12480
12481 return success;
12482 }
12483
12484 /* Coverage test for glDrawElementsIndirect */
12485
12486 /* Enums to test for glDrawElementsIndirect (may not be required) */
12487 struct enumTestRec const ea_DrawElementsIndirect[] = {{"End of List", -1}};
12488
TestCoverageGLCallDrawElementsIndirect(void)12489 bool ApiCoverageTestCase::TestCoverageGLCallDrawElementsIndirect(void)
12490 {
12491 GLuint i;
12492 bool success = true;
12493
12494 /* glDrawElementsIndirect may need to loop over a set of enums doing something with them */
12495 for (i = 0; ea_DrawElementsIndirect[i].value != -1; i++)
12496 {
12497 }
12498
12499 tcu_msg("ApiCoverageTestCase::DrawElementsIndirect", "Coverage test not implemented yet");
12500
12501 return success;
12502 }
12503
12504 /* Coverage test for glUniform1d */
12505
12506 /* Enums to test for glUniform1d (may not be required) */
12507 struct enumTestRec const ea_Uniform1d[] = {{"End of List", -1}};
12508
TestCoverageGLCallUniform1d(void)12509 bool ApiCoverageTestCase::TestCoverageGLCallUniform1d(void)
12510 {
12511 GLuint i;
12512 bool success = true;
12513
12514 /* glUniform1d may need to loop over a set of enums doing something with them */
12515 for (i = 0; ea_Uniform1d[i].value != -1; i++)
12516 {
12517 }
12518
12519 tcu_msg("ApiCoverageTestCase::Uniform1d", "Coverage test not implemented yet");
12520
12521 return success;
12522 }
12523
12524 /* Coverage test for glUniform2d */
12525
12526 /* Enums to test for glUniform2d (may not be required) */
12527 struct enumTestRec const ea_Uniform2d[] = {{"End of List", -1}};
12528
TestCoverageGLCallUniform2d(void)12529 bool ApiCoverageTestCase::TestCoverageGLCallUniform2d(void)
12530 {
12531 GLuint i;
12532 bool success = true;
12533
12534 /* glUniform2d may need to loop over a set of enums doing something with them */
12535 for (i = 0; ea_Uniform2d[i].value != -1; i++)
12536 {
12537 }
12538
12539 tcu_msg("ApiCoverageTestCase::Uniform2d", "Coverage test not implemented yet");
12540
12541 return success;
12542 }
12543
12544 /* Coverage test for glUniform3d */
12545
12546 /* Enums to test for glUniform3d (may not be required) */
12547 struct enumTestRec const ea_Uniform3d[] = {{"End of List", -1}};
12548
TestCoverageGLCallUniform3d(void)12549 bool ApiCoverageTestCase::TestCoverageGLCallUniform3d(void)
12550 {
12551 GLuint i;
12552 bool success = true;
12553
12554 /* glUniform3d may need to loop over a set of enums doing something with them */
12555 for (i = 0; ea_Uniform3d[i].value != -1; i++)
12556 {
12557 }
12558
12559 tcu_msg("ApiCoverageTestCase::Uniform3d", "Coverage test not implemented yet");
12560
12561 return success;
12562 }
12563
12564 /* Coverage test for glUniform4d */
12565
12566 /* Enums to test for glUniform4d (may not be required) */
12567 struct enumTestRec const ea_Uniform4d[] = {{"End of List", -1}};
12568
TestCoverageGLCallUniform4d(void)12569 bool ApiCoverageTestCase::TestCoverageGLCallUniform4d(void)
12570 {
12571 GLuint i;
12572 bool success = true;
12573
12574 /* glUniform4d may need to loop over a set of enums doing something with them */
12575 for (i = 0; ea_Uniform4d[i].value != -1; i++)
12576 {
12577 }
12578
12579 tcu_msg("ApiCoverageTestCase::Uniform4d", "Coverage test not implemented yet");
12580
12581 return success;
12582 }
12583
12584 /* Coverage test for glUniform1dv */
12585
12586 /* Enums to test for glUniform1dv (may not be required) */
12587 struct enumTestRec const ea_Uniform1dv[] = {{"End of List", -1}};
12588
TestCoverageGLCallUniform1dv(void)12589 bool ApiCoverageTestCase::TestCoverageGLCallUniform1dv(void)
12590 {
12591 GLuint i;
12592 bool success = true;
12593
12594 /* glUniform1dv may need to loop over a set of enums doing something with them */
12595 for (i = 0; ea_Uniform1dv[i].value != -1; i++)
12596 {
12597 }
12598
12599 tcu_msg("ApiCoverageTestCase::Uniform1dv", "Coverage test not implemented yet");
12600
12601 return success;
12602 }
12603
12604 /* Coverage test for glUniform2dv */
12605
12606 /* Enums to test for glUniform2dv (may not be required) */
12607 struct enumTestRec const ea_Uniform2dv[] = {{"End of List", -1}};
12608
TestCoverageGLCallUniform2dv(void)12609 bool ApiCoverageTestCase::TestCoverageGLCallUniform2dv(void)
12610 {
12611 GLuint i;
12612 bool success = true;
12613
12614 /* glUniform2dv may need to loop over a set of enums doing something with them */
12615 for (i = 0; ea_Uniform2dv[i].value != -1; i++)
12616 {
12617 }
12618
12619 tcu_msg("ApiCoverageTestCase::Uniform2dv", "Coverage test not implemented yet");
12620
12621 return success;
12622 }
12623
12624 /* Coverage test for glUniform3dv */
12625
12626 /* Enums to test for glUniform3dv (may not be required) */
12627 struct enumTestRec const ea_Uniform3dv[] = {{"End of List", -1}};
12628
TestCoverageGLCallUniform3dv(void)12629 bool ApiCoverageTestCase::TestCoverageGLCallUniform3dv(void)
12630 {
12631 GLuint i;
12632 bool success = true;
12633
12634 /* glUniform3dv may need to loop over a set of enums doing something with them */
12635 for (i = 0; ea_Uniform3dv[i].value != -1; i++)
12636 {
12637 }
12638
12639 tcu_msg("ApiCoverageTestCase::Uniform3dv", "Coverage test not implemented yet");
12640
12641 return success;
12642 }
12643
12644 /* Coverage test for glUniform4dv */
12645
12646 /* Enums to test for glUniform4dv (may not be required) */
12647 struct enumTestRec const ea_Uniform4dv[] = {{"End of List", -1}};
12648
TestCoverageGLCallUniform4dv(void)12649 bool ApiCoverageTestCase::TestCoverageGLCallUniform4dv(void)
12650 {
12651 GLuint i;
12652 bool success = true;
12653
12654 /* glUniform4dv may need to loop over a set of enums doing something with them */
12655 for (i = 0; ea_Uniform4dv[i].value != -1; i++)
12656 {
12657 }
12658
12659 tcu_msg("ApiCoverageTestCase::Uniform4dv", "Coverage test not implemented yet");
12660
12661 return success;
12662 }
12663
12664 /* Coverage test for glUniformMatrix2dv */
12665
12666 /* Enums to test for glUniformMatrix2dv (may not be required) */
12667 struct enumTestRec const ea_UniformMatrix2dv[] = {{"End of List", -1}};
12668
TestCoverageGLCallUniformMatrix2dv(void)12669 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix2dv(void)
12670 {
12671 GLuint i;
12672 bool success = true;
12673
12674 /* glUniformMatrix2dv may need to loop over a set of enums doing something with them */
12675 for (i = 0; ea_UniformMatrix2dv[i].value != -1; i++)
12676 {
12677 }
12678
12679 tcu_msg("ApiCoverageTestCase::UniformMatrix2dv", "Coverage test not implemented yet");
12680
12681 return success;
12682 }
12683
12684 /* Coverage test for glUniformMatrix3dv */
12685
12686 /* Enums to test for glUniformMatrix3dv (may not be required) */
12687 struct enumTestRec const ea_UniformMatrix3dv[] = {{"End of List", -1}};
12688
TestCoverageGLCallUniformMatrix3dv(void)12689 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix3dv(void)
12690 {
12691 GLuint i;
12692 bool success = true;
12693
12694 /* glUniformMatrix3dv may need to loop over a set of enums doing something with them */
12695 for (i = 0; ea_UniformMatrix3dv[i].value != -1; i++)
12696 {
12697 }
12698
12699 tcu_msg("ApiCoverageTestCase::UniformMatrix3dv", "Coverage test not implemented yet");
12700
12701 return success;
12702 }
12703
12704 /* Coverage test for glUniformMatrix4dv */
12705
12706 /* Enums to test for glUniformMatrix4dv (may not be required) */
12707 struct enumTestRec const ea_UniformMatrix4dv[] = {{"End of List", -1}};
12708
TestCoverageGLCallUniformMatrix4dv(void)12709 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix4dv(void)
12710 {
12711 GLuint i;
12712 bool success = true;
12713
12714 /* glUniformMatrix4dv may need to loop over a set of enums doing something with them */
12715 for (i = 0; ea_UniformMatrix4dv[i].value != -1; i++)
12716 {
12717 }
12718
12719 tcu_msg("ApiCoverageTestCase::UniformMatrix4dv", "Coverage test not implemented yet");
12720
12721 return success;
12722 }
12723
12724 /* Coverage test for glUniformMatrix2x3dv */
12725
12726 /* Enums to test for glUniformMatrix2x3dv (may not be required) */
12727 struct enumTestRec const ea_UniformMatrix2x3dv[] = {{"End of List", -1}};
12728
TestCoverageGLCallUniformMatrix2x3dv(void)12729 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix2x3dv(void)
12730 {
12731 GLuint i;
12732 bool success = true;
12733
12734 /* glUniformMatrix2x3dv may need to loop over a set of enums doing something with them */
12735 for (i = 0; ea_UniformMatrix2x3dv[i].value != -1; i++)
12736 {
12737 }
12738
12739 tcu_msg("ApiCoverageTestCase::UniformMatrix2x3dv", "Coverage test not implemented yet");
12740
12741 return success;
12742 }
12743
12744 /* Coverage test for glUniformMatrix2x4dv */
12745
12746 /* Enums to test for glUniformMatrix2x4dv (may not be required) */
12747 struct enumTestRec const ea_UniformMatrix2x4dv[] = {{"End of List", -1}};
12748
TestCoverageGLCallUniformMatrix2x4dv(void)12749 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix2x4dv(void)
12750 {
12751 GLuint i;
12752 bool success = true;
12753
12754 /* glUniformMatrix2x4dv may need to loop over a set of enums doing something with them */
12755 for (i = 0; ea_UniformMatrix2x4dv[i].value != -1; i++)
12756 {
12757 }
12758
12759 tcu_msg("ApiCoverageTestCase::UniformMatrix2x4dv", "Coverage test not implemented yet");
12760
12761 return success;
12762 }
12763
12764 /* Coverage test for glUniformMatrix3x2dv */
12765
12766 /* Enums to test for glUniformMatrix3x2dv (may not be required) */
12767 struct enumTestRec const ea_UniformMatrix3x2dv[] = {{"End of List", -1}};
12768
TestCoverageGLCallUniformMatrix3x2dv(void)12769 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix3x2dv(void)
12770 {
12771 GLuint i;
12772 bool success = true;
12773
12774 /* glUniformMatrix3x2dv may need to loop over a set of enums doing something with them */
12775 for (i = 0; ea_UniformMatrix3x2dv[i].value != -1; i++)
12776 {
12777 }
12778
12779 tcu_msg("ApiCoverageTestCase::UniformMatrix3x2dv", "Coverage test not implemented yet");
12780
12781 return success;
12782 }
12783
12784 /* Coverage test for glUniformMatrix3x4dv */
12785
12786 /* Enums to test for glUniformMatrix3x4dv (may not be required) */
12787 struct enumTestRec const ea_UniformMatrix3x4dv[] = {{"End of List", -1}};
12788
TestCoverageGLCallUniformMatrix3x4dv(void)12789 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix3x4dv(void)
12790 {
12791 GLuint i;
12792 bool success = true;
12793
12794 /* glUniformMatrix3x4dv may need to loop over a set of enums doing something with them */
12795 for (i = 0; ea_UniformMatrix3x4dv[i].value != -1; i++)
12796 {
12797 }
12798
12799 tcu_msg("ApiCoverageTestCase::UniformMatrix3x4dv", "Coverage test not implemented yet");
12800
12801 return success;
12802 }
12803
12804 /* Coverage test for glUniformMatrix4x2dv */
12805
12806 /* Enums to test for glUniformMatrix4x2dv (may not be required) */
12807 struct enumTestRec const ea_UniformMatrix4x2dv[] = {{"End of List", -1}};
12808
TestCoverageGLCallUniformMatrix4x2dv(void)12809 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix4x2dv(void)
12810 {
12811 GLuint i;
12812 bool success = true;
12813
12814 /* glUniformMatrix4x2dv may need to loop over a set of enums doing something with them */
12815 for (i = 0; ea_UniformMatrix4x2dv[i].value != -1; i++)
12816 {
12817 }
12818
12819 tcu_msg("ApiCoverageTestCase::UniformMatrix4x2dv", "Coverage test not implemented yet");
12820
12821 return success;
12822 }
12823
12824 /* Coverage test for glUniformMatrix4x3dv */
12825
12826 /* Enums to test for glUniformMatrix4x3dv (may not be required) */
12827 struct enumTestRec const ea_UniformMatrix4x3dv[] = {{"End of List", -1}};
12828
TestCoverageGLCallUniformMatrix4x3dv(void)12829 bool ApiCoverageTestCase::TestCoverageGLCallUniformMatrix4x3dv(void)
12830 {
12831 GLuint i;
12832 bool success = true;
12833
12834 /* glUniformMatrix4x3dv may need to loop over a set of enums doing something with them */
12835 for (i = 0; ea_UniformMatrix4x3dv[i].value != -1; i++)
12836 {
12837 }
12838
12839 tcu_msg("ApiCoverageTestCase::UniformMatrix4x3dv", "Coverage test not implemented yet");
12840
12841 return success;
12842 }
12843
12844 /* Coverage test for glGetUniformdv */
12845
12846 /* Enums to test for glGetUniformdv (may not be required) */
12847 struct enumTestRec const ea_GetUniformdv[] = {{"End of List", -1}};
12848
TestCoverageGLCallGetUniformdv(void)12849 bool ApiCoverageTestCase::TestCoverageGLCallGetUniformdv(void)
12850 {
12851 GLuint i;
12852 bool success = true;
12853
12854 /* glGetUniformdv may need to loop over a set of enums doing something with them */
12855 for (i = 0; ea_GetUniformdv[i].value != -1; i++)
12856 {
12857 }
12858
12859 tcu_msg("ApiCoverageTestCase::GetUniformdv", "Coverage test not implemented yet");
12860
12861 return success;
12862 }
12863
12864 /* Coverage test for glProgramUniform1dEXT */
12865
12866 /* Enums to test for glProgramUniform1dEXT (may not be required) */
12867 struct enumTestRec const ea_ProgramUniform1dEXT[] = {{"End of List", -1}};
12868
TestCoverageGLCallProgramUniform1dEXT(void)12869 bool ApiCoverageTestCase::TestCoverageGLCallProgramUniform1dEXT(void)
12870 {
12871 GLuint i;
12872 bool success = true;
12873
12874 /* glProgramUniform1dEXT may need to loop over a set of enums doing something with them */
12875 for (i = 0; ea_ProgramUniform1dEXT[i].value != -1; i++)
12876 {
12877 }
12878
12879 tcu_msg("ApiCoverageTestCase::ProgramUniform1dEXT", "Coverage test not implemented yet");
12880
12881 return success;
12882 }
12883
12884 /* Coverage test for glProgramUniform2dEXT */
12885
12886 /* Enums to test for glProgramUniform2dEXT (may not be required) */
12887 struct enumTestRec const ea_ProgramUniform2dEXT[] = {{"End of List", -1}};
12888
TestCoverageGLCallProgramUniform2dEXT(void)12889 bool ApiCoverageTestCase::TestCoverageGLCallProgramUniform2dEXT(void)
12890 {
12891 GLuint i;
12892 bool success = true;
12893
12894 /* glProgramUniform2dEXT may need to loop over a set of enums doing something with them */
12895 for (i = 0; ea_ProgramUniform2dEXT[i].value != -1; i++)
12896 {
12897 }
12898
12899 tcu_msg("ApiCoverageTestCase::ProgramUniform2dEXT", "Coverage test not implemented yet");
12900
12901 return success;
12902 }
12903
12904 /* Coverage test for glProgramUniform3dEXT */
12905
12906 /* Enums to test for glProgramUniform3dEXT (may not be required) */
12907 struct enumTestRec const ea_ProgramUniform3dEXT[] = {{"End of List", -1}};
12908
TestCoverageGLCallProgramUniform3dEXT(void)12909 bool ApiCoverageTestCase::TestCoverageGLCallProgramUniform3dEXT(void)
12910 {
12911 GLuint i;
12912 bool success = true;
12913
12914 /* glProgramUniform3dEXT may need to loop over a set of enums doing something with them */
12915 for (i = 0; ea_ProgramUniform3dEXT[i].value != -1; i++)
12916 {
12917 }
12918
12919 tcu_msg("ApiCoverageTestCase::ProgramUniform3dEXT", "Coverage test not implemented yet");
12920
12921 return success;
12922 }
12923
12924 /* Coverage test for glProgramUniform4dEXT */
12925
12926 /* Enums to test for glProgramUniform4dEXT (may not be required) */
12927 struct enumTestRec const ea_ProgramUniform4dEXT[] = {{"End of List", -1}};
12928
TestCoverageGLCallProgramUniform4dEXT(void)12929 bool ApiCoverageTestCase::TestCoverageGLCallProgramUniform4dEXT(void)
12930 {
12931 GLuint i;
12932 bool success = true;
12933
12934 /* glProgramUniform4dEXT may need to loop over a set of enums doing something with them */
12935 for (i = 0; ea_ProgramUniform4dEXT[i].value != -1; i++)
12936 {
12937 }
12938
12939 tcu_msg("ApiCoverageTestCase::ProgramUniform4dEXT", "Coverage test not implemented yet");
12940
12941 return success;
12942 }
12943
12944 /* Coverage test for glProgramUniform1dvEXT */
12945
12946 /* Enums to test for glProgramUniform1dvEXT (may not be required) */
12947 struct enumTestRec const ea_ProgramUniform1dvEXT[] = {{"End of List", -1}};
12948
TestCoverageGLCallProgramUniform1dvEXT(void)12949 bool ApiCoverageTestCase::TestCoverageGLCallProgramUniform1dvEXT(void)
12950 {
12951 GLuint i;
12952 bool success = true;
12953
12954 /* glProgramUniform1dvEXT may need to loop over a set of enums doing something with them */
12955 for (i = 0; ea_ProgramUniform1dvEXT[i].value != -1; i++)
12956 {
12957 }
12958
12959 tcu_msg("ApiCoverageTestCase::ProgramUniform1dvEXT", "Coverage test not implemented yet");
12960
12961 return success;
12962 }
12963
12964 /* Coverage test for glProgramUniform2dvEXT */
12965
12966 /* Enums to test for glProgramUniform2dvEXT (may not be required) */
12967 struct enumTestRec const ea_ProgramUniform2dvEXT[] = {{"End of List", -1}};
12968
TestCoverageGLCallProgramUniform2dvEXT(void)12969 bool ApiCoverageTestCase::TestCoverageGLCallProgramUniform2dvEXT(void)
12970 {
12971 GLuint i;
12972 bool success = true;
12973
12974 /* glProgramUniform2dvEXT may need to loop over a set of enums doing something with them */
12975 for (i = 0; ea_ProgramUniform2dvEXT[i].value != -1; i++)
12976 {
12977 }
12978
12979 tcu_msg("ApiCoverageTestCase::ProgramUniform2dvEXT", "Coverage test not implemented yet");
12980
12981 return success;
12982 }
12983
12984 /* Coverage test for glProgramUniform3dvEXT */
12985
12986 /* Enums to test for glProgramUniform3dvEXT (may not be required) */
12987 struct enumTestRec const ea_ProgramUniform3dvEXT[] = {{"End of List", -1}};
12988
TestCoverageGLCallProgramUniform3dvEXT(void)12989 bool ApiCoverageTestCase::TestCoverageGLCallProgramUniform3dvEXT(void)
12990 {
12991 GLuint i;
12992 bool success = true;
12993
12994 /* glProgramUniform3dvEXT may need to loop over a set of enums doing something with them */
12995 for (i = 0; ea_ProgramUniform3dvEXT[i].value != -1; i++)
12996 {
12997 }
12998
12999 tcu_msg("ApiCoverageTestCase::ProgramUniform3dvEXT", "Coverage test not implemented yet");
13000
13001 return success;
13002 }
13003
13004 /* Coverage test for glProgramUniform4dvEXT */
13005
13006 /* Enums to test for glProgramUniform4dvEXT (may not be required) */
13007 struct enumTestRec const ea_ProgramUniform4dvEXT[] = {{"End of List", -1}};
13008
TestCoverageGLCallProgramUniform4dvEXT(void)13009 bool ApiCoverageTestCase::TestCoverageGLCallProgramUniform4dvEXT(void)
13010 {
13011 GLuint i;
13012 bool success = true;
13013
13014 /* glProgramUniform4dvEXT may need to loop over a set of enums doing something with them */
13015 for (i = 0; ea_ProgramUniform4dvEXT[i].value != -1; i++)
13016 {
13017 }
13018
13019 tcu_msg("ApiCoverageTestCase::ProgramUniform4dvEXT", "Coverage test not implemented yet");
13020
13021 return success;
13022 }
13023
13024 /* Coverage test for glProgramUniformMatrix2dvEXT */
13025
13026 /* Enums to test for glProgramUniformMatrix2dvEXT (may not be required) */
13027 struct enumTestRec const ea_ProgramUniformMatrix2dvEXT[] = {{"End of List", -1}};
13028
TestCoverageGLCallProgramUniformMatrix2dvEXT(void)13029 bool ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix2dvEXT(void)
13030 {
13031 GLuint i;
13032 bool success = true;
13033
13034 /* glProgramUniformMatrix2dvEXT may need to loop over a set of enums doing something with them */
13035 for (i = 0; ea_ProgramUniformMatrix2dvEXT[i].value != -1; i++)
13036 {
13037 }
13038
13039 tcu_msg("ApiCoverageTestCase::ProgramUniformMatrix2dvEXT", "Coverage test not implemented yet");
13040
13041 return success;
13042 }
13043
13044 /* Coverage test for glProgramUniformMatrix3dvEXT */
13045
13046 /* Enums to test for glProgramUniformMatrix3dvEXT (may not be required) */
13047 struct enumTestRec const ea_ProgramUniformMatrix3dvEXT[] = {{"End of List", -1}};
13048
TestCoverageGLCallProgramUniformMatrix3dvEXT(void)13049 bool ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix3dvEXT(void)
13050 {
13051 GLuint i;
13052 bool success = true;
13053
13054 /* glProgramUniformMatrix3dvEXT may need to loop over a set of enums doing something with them */
13055 for (i = 0; ea_ProgramUniformMatrix3dvEXT[i].value != -1; i++)
13056 {
13057 }
13058
13059 tcu_msg("ApiCoverageTestCase::ProgramUniformMatrix3dvEXT", "Coverage test not implemented yet");
13060
13061 return success;
13062 }
13063
13064 /* Coverage test for glProgramUniformMatrix4dvEXT */
13065
13066 /* Enums to test for glProgramUniformMatrix4dvEXT (may not be required) */
13067 struct enumTestRec const ea_ProgramUniformMatrix4dvEXT[] = {{"End of List", -1}};
13068
TestCoverageGLCallProgramUniformMatrix4dvEXT(void)13069 bool ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix4dvEXT(void)
13070 {
13071 GLuint i;
13072 bool success = true;
13073
13074 /* glProgramUniformMatrix4dvEXT may need to loop over a set of enums doing something with them */
13075 for (i = 0; ea_ProgramUniformMatrix4dvEXT[i].value != -1; i++)
13076 {
13077 }
13078
13079 tcu_msg("ApiCoverageTestCase::ProgramUniformMatrix4dvEXT", "Coverage test not implemented yet");
13080
13081 return success;
13082 }
13083
13084 /* Coverage test for glProgramUniformMatrix2x3dvEXT */
13085
13086 /* Enums to test for glProgramUniformMatrix2x3dvEXT (may not be required) */
13087 struct enumTestRec const ea_ProgramUniformMatrix2x3dvEXT[] = {{"End of List", -1}};
13088
TestCoverageGLCallProgramUniformMatrix2x3dvEXT(void)13089 bool ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix2x3dvEXT(void)
13090 {
13091 GLuint i;
13092 bool success = true;
13093
13094 /* glProgramUniformMatrix2x3dvEXT may need to loop over a set of enums doing something with them */
13095 for (i = 0; ea_ProgramUniformMatrix2x3dvEXT[i].value != -1; i++)
13096 {
13097 }
13098
13099 tcu_msg("ApiCoverageTestCase::ProgramUniformMatrix2x3dvEXT", "Coverage test not implemented yet");
13100
13101 return success;
13102 }
13103
13104 /* Coverage test for glProgramUniformMatrix2x4dvEXT */
13105
13106 /* Enums to test for glProgramUniformMatrix2x4dvEXT (may not be required) */
13107 struct enumTestRec const ea_ProgramUniformMatrix2x4dvEXT[] = {{"End of List", -1}};
13108
TestCoverageGLCallProgramUniformMatrix2x4dvEXT(void)13109 bool ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix2x4dvEXT(void)
13110 {
13111 GLuint i;
13112 bool success = true;
13113
13114 /* glProgramUniformMatrix2x4dvEXT may need to loop over a set of enums doing something with them */
13115 for (i = 0; ea_ProgramUniformMatrix2x4dvEXT[i].value != -1; i++)
13116 {
13117 }
13118
13119 tcu_msg("ApiCoverageTestCase::ProgramUniformMatrix2x4dvEXT", "Coverage test not implemented yet");
13120
13121 return success;
13122 }
13123
13124 /* Coverage test for glProgramUniformMatrix3x2dvEXT */
13125
13126 /* Enums to test for glProgramUniformMatrix3x2dvEXT (may not be required) */
13127 struct enumTestRec const ea_ProgramUniformMatrix3x2dvEXT[] = {{"End of List", -1}};
13128
TestCoverageGLCallProgramUniformMatrix3x2dvEXT(void)13129 bool ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix3x2dvEXT(void)
13130 {
13131 GLuint i;
13132 bool success = true;
13133
13134 /* glProgramUniformMatrix3x2dvEXT may need to loop over a set of enums doing something with them */
13135 for (i = 0; ea_ProgramUniformMatrix3x2dvEXT[i].value != -1; i++)
13136 {
13137 }
13138
13139 tcu_msg("ApiCoverageTestCase::ProgramUniformMatrix3x2dvEXT", "Coverage test not implemented yet");
13140
13141 return success;
13142 }
13143
13144 /* Coverage test for glProgramUniformMatrix3x4dvEXT */
13145
13146 /* Enums to test for glProgramUniformMatrix3x4dvEXT (may not be required) */
13147 struct enumTestRec const ea_ProgramUniformMatrix3x4dvEXT[] = {{"End of List", -1}};
13148
TestCoverageGLCallProgramUniformMatrix3x4dvEXT(void)13149 bool ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix3x4dvEXT(void)
13150 {
13151 GLuint i;
13152 bool success = true;
13153
13154 /* glProgramUniformMatrix3x4dvEXT may need to loop over a set of enums doing something with them */
13155 for (i = 0; ea_ProgramUniformMatrix3x4dvEXT[i].value != -1; i++)
13156 {
13157 }
13158
13159 tcu_msg("ApiCoverageTestCase::ProgramUniformMatrix3x4dvEXT", "Coverage test not implemented yet");
13160
13161 return success;
13162 }
13163
13164 /* Coverage test for glProgramUniformMatrix4x2dvEXT */
13165
13166 /* Enums to test for glProgramUniformMatrix4x2dvEXT (may not be required) */
13167 struct enumTestRec const ea_ProgramUniformMatrix4x2dvEXT[] = {{"End of List", -1}};
13168
TestCoverageGLCallProgramUniformMatrix4x2dvEXT(void)13169 bool ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix4x2dvEXT(void)
13170 {
13171 GLuint i;
13172 bool success = true;
13173
13174 /* glProgramUniformMatrix4x2dvEXT may need to loop over a set of enums doing something with them */
13175 for (i = 0; ea_ProgramUniformMatrix4x2dvEXT[i].value != -1; i++)
13176 {
13177 }
13178
13179 tcu_msg("ApiCoverageTestCase::ProgramUniformMatrix4x2dvEXT", "Coverage test not implemented yet");
13180
13181 return success;
13182 }
13183
13184 /* Coverage test for glProgramUniformMatrix4x3dvEXT */
13185
13186 /* Enums to test for glProgramUniformMatrix4x3dvEXT (may not be required) */
13187 struct enumTestRec const ea_ProgramUniformMatrix4x3dvEXT[] = {{"End of List", -1}};
13188
TestCoverageGLCallProgramUniformMatrix4x3dvEXT(void)13189 bool ApiCoverageTestCase::TestCoverageGLCallProgramUniformMatrix4x3dvEXT(void)
13190 {
13191 GLuint i;
13192 bool success = true;
13193
13194 /* glProgramUniformMatrix4x3dvEXT may need to loop over a set of enums doing something with them */
13195 for (i = 0; ea_ProgramUniformMatrix4x3dvEXT[i].value != -1; i++)
13196 {
13197 }
13198
13199 tcu_msg("ApiCoverageTestCase::ProgramUniformMatrix4x3dvEXT", "Coverage test not implemented yet");
13200
13201 return success;
13202 }
13203
13204 /* Coverage test for glGetSubroutineUniformLocation */
13205
13206 /* Enums to test for glGetSubroutineUniformLocation (may not be required) */
13207 struct enumTestRec const ea_GetSubroutineUniformLocation[] = {{"End of List", -1}};
13208
TestCoverageGLCallGetSubroutineUniformLocation(void)13209 bool ApiCoverageTestCase::TestCoverageGLCallGetSubroutineUniformLocation(void)
13210 {
13211 GLuint i;
13212 bool success = true;
13213
13214 /* glGetSubroutineUniformLocation may need to loop over a set of enums doing something with them */
13215 for (i = 0; ea_GetSubroutineUniformLocation[i].value != -1; i++)
13216 {
13217 }
13218
13219 tcu_msg("ApiCoverageTestCase::GetSubroutineUniformLocation", "Coverage test not implemented yet");
13220
13221 return success;
13222 }
13223
13224 /* Coverage test for glGetSubroutineIndex */
13225
13226 /* Enums to test for glGetSubroutineIndex (may not be required) */
13227 struct enumTestRec const ea_GetSubroutineIndex[] = {{"End of List", -1}};
13228
TestCoverageGLCallGetSubroutineIndex(void)13229 bool ApiCoverageTestCase::TestCoverageGLCallGetSubroutineIndex(void)
13230 {
13231 GLuint i;
13232 bool success = true;
13233
13234 /* glGetSubroutineIndex may need to loop over a set of enums doing something with them */
13235 for (i = 0; ea_GetSubroutineIndex[i].value != -1; i++)
13236 {
13237 }
13238
13239 tcu_msg("ApiCoverageTestCase::GetSubroutineIndex", "Coverage test not implemented yet");
13240
13241 return success;
13242 }
13243
13244 /* Coverage test for glGetActiveSubroutineUniformiv */
13245
13246 /* Enums to test for glGetActiveSubroutineUniformiv (may not be required) */
13247 struct enumTestRec const ea_GetActiveSubroutineUniformiv[] = {{"End of List", -1}};
13248
TestCoverageGLCallGetActiveSubroutineUniformiv(void)13249 bool ApiCoverageTestCase::TestCoverageGLCallGetActiveSubroutineUniformiv(void)
13250 {
13251 GLuint i;
13252 bool success = true;
13253
13254 /* glGetActiveSubroutineUniformiv may need to loop over a set of enums doing something with them */
13255 for (i = 0; ea_GetActiveSubroutineUniformiv[i].value != -1; i++)
13256 {
13257 }
13258
13259 tcu_msg("ApiCoverageTestCase::GetActiveSubroutineUniformiv", "Coverage test not implemented yet");
13260
13261 return success;
13262 }
13263
13264 /* Coverage test for glGetActiveSubroutineUniformName */
13265
13266 /* Enums to test for glGetActiveSubroutineUniformName (may not be required) */
13267 struct enumTestRec const ea_GetActiveSubroutineUniformName[] = {{"End of List", -1}};
13268
TestCoverageGLCallGetActiveSubroutineUniformName(void)13269 bool ApiCoverageTestCase::TestCoverageGLCallGetActiveSubroutineUniformName(void)
13270 {
13271 GLuint i;
13272 bool success = true;
13273
13274 /* glGetActiveSubroutineUniformName may need to loop over a set of enums doing something with them */
13275 for (i = 0; ea_GetActiveSubroutineUniformName[i].value != -1; i++)
13276 {
13277 }
13278
13279 tcu_msg("ApiCoverageTestCase::GetActiveSubroutineUniformName", "Coverage test not implemented yet");
13280
13281 return success;
13282 }
13283
13284 /* Coverage test for glGetActiveSubroutineName */
13285
13286 /* Enums to test for glGetActiveSubroutineName (may not be required) */
13287 struct enumTestRec const ea_GetActiveSubroutineName[] = {{"End of List", -1}};
13288
TestCoverageGLCallGetActiveSubroutineName(void)13289 bool ApiCoverageTestCase::TestCoverageGLCallGetActiveSubroutineName(void)
13290 {
13291 GLuint i;
13292 bool success = true;
13293
13294 /* glGetActiveSubroutineName may need to loop over a set of enums doing something with them */
13295 for (i = 0; ea_GetActiveSubroutineName[i].value != -1; i++)
13296 {
13297 }
13298
13299 tcu_msg("ApiCoverageTestCase::GetActiveSubroutineName", "Coverage test not implemented yet");
13300
13301 return success;
13302 }
13303
13304 /* Coverage test for glUniformSubroutinesuiv */
13305
13306 /* Enums to test for glUniformSubroutinesuiv (may not be required) */
13307 struct enumTestRec const ea_UniformSubroutinesuiv[] = {{"End of List", -1}};
13308
TestCoverageGLCallUniformSubroutinesuiv(void)13309 bool ApiCoverageTestCase::TestCoverageGLCallUniformSubroutinesuiv(void)
13310 {
13311 GLuint i;
13312 bool success = true;
13313
13314 /* glUniformSubroutinesuiv may need to loop over a set of enums doing something with them */
13315 for (i = 0; ea_UniformSubroutinesuiv[i].value != -1; i++)
13316 {
13317 }
13318
13319 tcu_msg("ApiCoverageTestCase::UniformSubroutinesuiv", "Coverage test not implemented yet");
13320
13321 return success;
13322 }
13323
13324 /* Coverage test for glGetUniformSubroutineuiv */
13325
13326 /* Enums to test for glGetUniformSubroutineuiv (may not be required) */
13327 struct enumTestRec const ea_GetUniformSubroutineuiv[] = {{"End of List", -1}};
13328
TestCoverageGLCallGetUniformSubroutineuiv(void)13329 bool ApiCoverageTestCase::TestCoverageGLCallGetUniformSubroutineuiv(void)
13330 {
13331 GLuint i;
13332 bool success = true;
13333
13334 /* glGetUniformSubroutineuiv may need to loop over a set of enums doing something with them */
13335 for (i = 0; ea_GetUniformSubroutineuiv[i].value != -1; i++)
13336 {
13337 }
13338
13339 tcu_msg("ApiCoverageTestCase::GetUniformSubroutineuiv", "Coverage test not implemented yet");
13340
13341 return success;
13342 }
13343
13344 /* Coverage test for glGetProgramStageiv */
13345
13346 /* Enums to test for glGetProgramStageiv (may not be required) */
13347 struct enumTestRec const ea_GetProgramStageiv[] = {{"End of List", -1}};
13348
TestCoverageGLCallGetProgramStageiv(void)13349 bool ApiCoverageTestCase::TestCoverageGLCallGetProgramStageiv(void)
13350 {
13351 GLuint i;
13352 bool success = true;
13353
13354 /* glGetProgramStageiv may need to loop over a set of enums doing something with them */
13355 for (i = 0; ea_GetProgramStageiv[i].value != -1; i++)
13356 {
13357 }
13358
13359 tcu_msg("ApiCoverageTestCase::GetProgramStageiv", "Coverage test not implemented yet");
13360
13361 return success;
13362 }
13363
13364 /* Coverage test for glPatchParameteri */
13365
13366 /* Enums to test for glPatchParameteri (may not be required) */
13367 struct enumTestRec const ea_PatchParameteri[] = {{"End of List", -1}};
13368
TestCoverageGLCallPatchParameteri(void)13369 bool ApiCoverageTestCase::TestCoverageGLCallPatchParameteri(void)
13370 {
13371 GLuint i;
13372 bool success = true;
13373
13374 /* glPatchParameteri may need to loop over a set of enums doing something with them */
13375 for (i = 0; ea_PatchParameteri[i].value != -1; i++)
13376 {
13377 }
13378
13379 tcu_msg("ApiCoverageTestCase::PatchParameteri", "Coverage test not implemented yet");
13380
13381 return success;
13382 }
13383
13384 /* Coverage test for glPatchParameterfv */
13385
13386 /* Enums to test for glPatchParameterfv (may not be required) */
13387 struct enumTestRec const ea_PatchParameterfv[] = {{"End of List", -1}};
13388
TestCoverageGLCallPatchParameterfv(void)13389 bool ApiCoverageTestCase::TestCoverageGLCallPatchParameterfv(void)
13390 {
13391 GLuint i;
13392 bool success = true;
13393
13394 /* glPatchParameterfv may need to loop over a set of enums doing something with them */
13395 for (i = 0; ea_PatchParameterfv[i].value != -1; i++)
13396 {
13397 }
13398
13399 tcu_msg("ApiCoverageTestCase::PatchParameterfv", "Coverage test not implemented yet");
13400
13401 return success;
13402 }
13403
13404 /* Coverage test for glDrawTransformFeedback */
13405
13406 /* Enums to test for glDrawTransformFeedback (may not be required) */
13407 struct enumTestRec const ea_DrawTransformFeedback[] = {{"End of List", -1}};
13408
TestCoverageGLCallDrawTransformFeedback(void)13409 bool ApiCoverageTestCase::TestCoverageGLCallDrawTransformFeedback(void)
13410 {
13411 GLuint i;
13412 bool success = true;
13413
13414 /* glDrawTransformFeedback may need to loop over a set of enums doing something with them */
13415 for (i = 0; ea_DrawTransformFeedback[i].value != -1; i++)
13416 {
13417 }
13418
13419 tcu_msg("ApiCoverageTestCase::DrawTransformFeedback", "Coverage test not implemented yet");
13420
13421 return success;
13422 }
13423
13424 /* Coverage test for glDrawTransformFeedbackStream */
13425
13426 /* Enums to test for glDrawTransformFeedbackStream (may not be required) */
13427 struct enumTestRec const ea_DrawTransformFeedbackStream[] = {{"End of List", -1}};
13428
TestCoverageGLCallDrawTransformFeedbackStream(void)13429 bool ApiCoverageTestCase::TestCoverageGLCallDrawTransformFeedbackStream(void)
13430 {
13431 GLuint i;
13432 bool success = true;
13433
13434 /* glDrawTransformFeedbackStream may need to loop over a set of enums doing something with them */
13435 for (i = 0; ea_DrawTransformFeedbackStream[i].value != -1; i++)
13436 {
13437 }
13438
13439 tcu_msg("ApiCoverageTestCase::DrawTransformFeedbackStream", "Coverage test not implemented yet");
13440
13441 return success;
13442 }
13443
13444 /* Coverage test for glBeginQueryIndexed */
13445
13446 /* Enums to test for glBeginQueryIndexed (may not be required) */
13447 struct enumTestRec const ea_BeginQueryIndexed[] = {{"End of List", -1}};
13448
TestCoverageGLCallBeginQueryIndexed(void)13449 bool ApiCoverageTestCase::TestCoverageGLCallBeginQueryIndexed(void)
13450 {
13451 GLuint i;
13452 bool success = true;
13453
13454 /* glBeginQueryIndexed may need to loop over a set of enums doing something with them */
13455 for (i = 0; ea_BeginQueryIndexed[i].value != -1; i++)
13456 {
13457 }
13458
13459 tcu_msg("ApiCoverageTestCase::BeginQueryIndexed", "Coverage test not implemented yet");
13460
13461 return success;
13462 }
13463
13464 /* Coverage test for glEndQueryIndexed */
13465
13466 /* Enums to test for glEndQueryIndexed (may not be required) */
13467 struct enumTestRec const ea_EndQueryIndexed[] = {{"End of List", -1}};
13468
TestCoverageGLCallEndQueryIndexed(void)13469 bool ApiCoverageTestCase::TestCoverageGLCallEndQueryIndexed(void)
13470 {
13471 GLuint i;
13472 bool success = true;
13473
13474 /* glEndQueryIndexed may need to loop over a set of enums doing something with them */
13475 for (i = 0; ea_EndQueryIndexed[i].value != -1; i++)
13476 {
13477 }
13478
13479 tcu_msg("ApiCoverageTestCase::EndQueryIndexed", "Coverage test not implemented yet");
13480
13481 return success;
13482 }
13483
13484 /* Coverage test for glGetQueryIndexediv */
13485
13486 /* Enums to test for glGetQueryIndexediv (may not be required) */
13487 struct enumTestRec const ea_GetQueryIndexediv[] = {{"End of List", -1}};
13488
TestCoverageGLCallGetQueryIndexediv(void)13489 bool ApiCoverageTestCase::TestCoverageGLCallGetQueryIndexediv(void)
13490 {
13491 GLuint i;
13492 bool success = true;
13493
13494 /* glGetQueryIndexediv may need to loop over a set of enums doing something with them */
13495 for (i = 0; ea_GetQueryIndexediv[i].value != -1; i++)
13496 {
13497 }
13498
13499 tcu_msg("ApiCoverageTestCase::GetQueryIndexediv", "Coverage test not implemented yet");
13500
13501 return success;
13502 }
13503
13504 /** Constructor.
13505 *
13506 * @param context Rendering context.
13507 */
ApiCoverageTests(deqp::Context & context)13508 ApiCoverageTests::ApiCoverageTests(deqp::Context &context)
13509 : TestCaseGroup(context, "api", "Verifies OpenGL API coverage functionality")
13510 {
13511 }
13512
13513 /** Initializes the test group contents. */
init()13514 void ApiCoverageTests::init()
13515 {
13516 addChild(new ApiCoverageTestCase(m_context));
13517 }
13518
13519 } // namespace glcts
13520