chromium/ui/gl/gl_bindings_autogen_mock.cc

// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// This file is auto-generated from
// ui/gl/generate_bindings.py
// It's formatted by clang-format using chromium coding style:
//    clang-format -i -style=chromium filename
// DO NOT EDIT!

#include <string.h>

#include "base/notreached.h"
#include "ui/gl/gl_mock.h"

namespace {
// This is called mainly to prevent the compiler combining the code of mock
// functions with identical contents, so that their function pointers will be
// different.
void MakeGlMockFunctionUnique(const char* func_name) { … }
}  // namespace

namespace gl {

void GL_BINDING_CALL
MockGLInterface::Mock_glAcquireTexturesANGLE(GLuint numTextures,
                                             const GLuint* textures,
                                             const GLenum* layouts) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glActiveShaderProgram(GLuint pipeline, GLuint program) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glActiveTexture(GLenum texture) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glAttachShader(GLuint program,
                                                          GLuint shader) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBeginPixelLocalStorageANGLE(GLsizei n,
                                                    const GLenum* loadops) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBeginQuery(GLenum target,
                                                        GLuint id) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBeginQueryEXT(GLenum target,
                                                           GLuint id) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBeginTransformFeedback(GLenum primitiveMode) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBindAttribLocation(GLuint program,
                                           GLuint index,
                                           const char* name) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBindBuffer(GLenum target,
                                                        GLuint buffer) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBindBufferBase(GLenum target,
                                                            GLuint index,
                                                            GLuint buffer) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBindBufferRange(GLenum target,
                                                             GLuint index,
                                                             GLuint buffer,
                                                             GLintptr offset,
                                                             GLsizeiptr size) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBindFragDataLocationEXT(GLuint program,
                                                GLuint colorNumber,
                                                const char* name) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBindFragDataLocationIndexedEXT(GLuint program,
                                                       GLuint colorNumber,
                                                       GLuint index,
                                                       const char* name) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBindFramebuffer(GLenum target, GLuint framebuffer) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBindImageTexture(GLuint index,
                                                              GLuint texture,
                                                              GLint level,
                                                              GLboolean layered,
                                                              GLint layer,
                                                              GLenum access,
                                                              GLint format) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBindImageTextureEXT(GLuint index,
                                            GLuint texture,
                                            GLint level,
                                            GLboolean layered,
                                            GLint layer,
                                            GLenum access,
                                            GLint format) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBindProgramPipeline(GLuint pipeline) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBindRenderbuffer(GLenum target, GLuint renderbuffer) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBindSampler(GLuint unit,
                                                         GLuint sampler) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBindTexture(GLenum target,
                                                         GLuint texture) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBindTransformFeedback(GLenum target, GLuint id) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBindUniformLocationCHROMIUM(GLuint program,
                                                    GLint location,
                                                    const char* name) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBindVertexArray(GLuint array) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBindVertexArrayOES(GLuint array) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBindVertexBuffer(GLuint bindingindex,
                                         GLuint buffer,
                                         GLintptr offset,
                                         GLsizei stride) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBlendBarrierKHR(void) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBlendBarrierNV(void) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBlendColor(GLclampf red,
                                                        GLclampf green,
                                                        GLclampf blue,
                                                        GLclampf alpha) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBlendEquation(GLenum mode) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBlendEquationSeparate(GLenum modeRGB,
                                              GLenum modeAlpha) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBlendEquationSeparatei(GLuint buf,
                                               GLenum modeRGB,
                                               GLenum modeAlpha) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBlendEquationSeparateiOES(GLuint buf,
                                                  GLenum modeRGB,
                                                  GLenum modeAlpha) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBlendEquationi(GLuint buf,
                                                            GLenum mode) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBlendEquationiOES(GLuint buf,
                                                               GLenum mode) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBlendFunc(GLenum sfactor,
                                                       GLenum dfactor) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBlendFuncSeparate(GLenum srcRGB,
                                          GLenum dstRGB,
                                          GLenum srcAlpha,
                                          GLenum dstAlpha) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBlendFuncSeparatei(GLuint buf,
                                           GLenum srcRGB,
                                           GLenum dstRGB,
                                           GLenum srcAlpha,
                                           GLenum dstAlpha) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBlendFuncSeparateiOES(GLuint buf,
                                              GLenum srcRGB,
                                              GLenum dstRGB,
                                              GLenum srcAlpha,
                                              GLenum dstAlpha) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBlendFunci(GLuint buf,
                                                        GLenum sfactor,
                                                        GLenum dfactor) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBlendFunciOES(GLuint buf,
                                                           GLenum sfactor,
                                                           GLenum dfactor) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBlitFramebuffer(GLint srcX0,
                                                             GLint srcY0,
                                                             GLint srcX1,
                                                             GLint srcY1,
                                                             GLint dstX0,
                                                             GLint dstY0,
                                                             GLint dstX1,
                                                             GLint dstY1,
                                                             GLbitfield mask,
                                                             GLenum filter) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glBlitFramebufferANGLE(GLint srcX0,
                                             GLint srcY0,
                                             GLint srcX1,
                                             GLint srcY1,
                                             GLint dstX0,
                                             GLint dstY0,
                                             GLint dstX1,
                                             GLint dstY1,
                                             GLbitfield mask,
                                             GLenum filter) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBlitFramebufferNV(GLint srcX0,
                                                               GLint srcY0,
                                                               GLint srcX1,
                                                               GLint srcY1,
                                                               GLint dstX0,
                                                               GLint dstY0,
                                                               GLint dstX1,
                                                               GLint dstY1,
                                                               GLbitfield mask,
                                                               GLenum filter) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBufferData(GLenum target,
                                                        GLsizeiptr size,
                                                        const void* data,
                                                        GLenum usage) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glBufferSubData(GLenum target,
                                                           GLintptr offset,
                                                           GLsizeiptr size,
                                                           const void* data) { … }

GLenum GL_BINDING_CALL
MockGLInterface::Mock_glCheckFramebufferStatus(GLenum target) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glClear(GLbitfield mask) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glClearBufferfi(GLenum buffer,
                                                           GLint drawbuffer,
                                                           const GLfloat depth,
                                                           GLint stencil) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glClearBufferfv(GLenum buffer,
                                      GLint drawbuffer,
                                      const GLfloat* value) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glClearBufferiv(GLenum buffer,
                                                           GLint drawbuffer,
                                                           const GLint* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glClearBufferuiv(GLenum buffer,
                                       GLint drawbuffer,
                                       const GLuint* value) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glClearColor(GLclampf red,
                                                        GLclampf green,
                                                        GLclampf blue,
                                                        GLclampf alpha) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glClearDepth(GLclampd depth) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glClearDepthf(GLclampf depth) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glClearStencil(GLint s) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glClearTexImageEXT(GLuint texture,
                                         GLint level,
                                         GLenum format,
                                         GLenum type,
                                         const GLvoid* data) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glClearTexSubImage(GLuint texture,
                                         GLint level,
                                         GLint xoffset,
                                         GLint yoffset,
                                         GLint zoffset,
                                         GLint width,
                                         GLint height,
                                         GLint depth,
                                         GLenum format,
                                         GLenum type,
                                         const GLvoid* data) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glClearTexSubImageEXT(GLuint texture,
                                            GLint level,
                                            GLint xoffset,
                                            GLint yoffset,
                                            GLint zoffset,
                                            GLint width,
                                            GLint height,
                                            GLint depth,
                                            GLenum format,
                                            GLenum type,
                                            const GLvoid* data) { … }

GLenum GL_BINDING_CALL
MockGLInterface::Mock_glClientWaitSync(GLsync sync,
                                       GLbitfield flags,
                                       GLuint64 timeout) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glClipControlEXT(GLenum origin,
                                                            GLenum depth) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glColorMask(GLboolean red,
                                                       GLboolean green,
                                                       GLboolean blue,
                                                       GLboolean alpha) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glColorMaski(GLuint buf,
                                                        GLboolean red,
                                                        GLboolean green,
                                                        GLboolean blue,
                                                        GLboolean alpha) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glColorMaskiOES(GLuint buf,
                                                           GLboolean red,
                                                           GLboolean green,
                                                           GLboolean blue,
                                                           GLboolean alpha) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glCompileShader(GLuint shader) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glCompressedTexImage2D(GLenum target,
                                             GLint level,
                                             GLenum internalformat,
                                             GLsizei width,
                                             GLsizei height,
                                             GLint border,
                                             GLsizei imageSize,
                                             const void* data) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glCompressedTexImage2DRobustANGLE(GLenum target,
                                                        GLint level,
                                                        GLenum internalformat,
                                                        GLsizei width,
                                                        GLsizei height,
                                                        GLint border,
                                                        GLsizei imageSize,
                                                        GLsizei dataSize,
                                                        const void* data) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glCompressedTexImage3D(GLenum target,
                                             GLint level,
                                             GLenum internalformat,
                                             GLsizei width,
                                             GLsizei height,
                                             GLsizei depth,
                                             GLint border,
                                             GLsizei imageSize,
                                             const void* data) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glCompressedTexImage3DRobustANGLE(GLenum target,
                                                        GLint level,
                                                        GLenum internalformat,
                                                        GLsizei width,
                                                        GLsizei height,
                                                        GLsizei depth,
                                                        GLint border,
                                                        GLsizei imageSize,
                                                        GLsizei dataSize,
                                                        const void* data) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glCompressedTexSubImage2D(GLenum target,
                                                GLint level,
                                                GLint xoffset,
                                                GLint yoffset,
                                                GLsizei width,
                                                GLsizei height,
                                                GLenum format,
                                                GLsizei imageSize,
                                                const void* data) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glCompressedTexSubImage2DRobustANGLE(GLenum target,
                                                           GLint level,
                                                           GLint xoffset,
                                                           GLint yoffset,
                                                           GLsizei width,
                                                           GLsizei height,
                                                           GLenum format,
                                                           GLsizei imageSize,
                                                           GLsizei dataSize,
                                                           const void* data) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glCompressedTexSubImage3D(GLenum target,
                                                GLint level,
                                                GLint xoffset,
                                                GLint yoffset,
                                                GLint zoffset,
                                                GLsizei width,
                                                GLsizei height,
                                                GLsizei depth,
                                                GLenum format,
                                                GLsizei imageSize,
                                                const void* data) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glCompressedTexSubImage3DRobustANGLE(GLenum target,
                                                           GLint level,
                                                           GLint xoffset,
                                                           GLint yoffset,
                                                           GLint zoffset,
                                                           GLsizei width,
                                                           GLsizei height,
                                                           GLsizei depth,
                                                           GLenum format,
                                                           GLsizei imageSize,
                                                           GLsizei dataSize,
                                                           const void* data) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glCopyBufferSubData(GLenum readTarget,
                                          GLenum writeTarget,
                                          GLintptr readOffset,
                                          GLintptr writeOffset,
                                          GLsizeiptr size) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glCopySubTextureCHROMIUM(
    GLuint sourceId,
    GLint sourceLevel,
    GLenum destTarget,
    GLuint destId,
    GLint destLevel,
    GLint xoffset,
    GLint yoffset,
    GLint x,
    GLint y,
    GLsizei width,
    GLsizei height,
    GLboolean unpackFlipY,
    GLboolean unpackPremultiplyAlpha,
    GLboolean unpackUnmultiplyAlpha) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glCopyTexImage2D(GLenum target,
                                       GLint level,
                                       GLenum internalformat,
                                       GLint x,
                                       GLint y,
                                       GLsizei width,
                                       GLsizei height,
                                       GLint border) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glCopyTexSubImage2D(GLenum target,
                                                               GLint level,
                                                               GLint xoffset,
                                                               GLint yoffset,
                                                               GLint x,
                                                               GLint y,
                                                               GLsizei width,
                                                               GLsizei height) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glCopyTexSubImage3D(GLenum target,
                                                               GLint level,
                                                               GLint xoffset,
                                                               GLint yoffset,
                                                               GLint zoffset,
                                                               GLint x,
                                                               GLint y,
                                                               GLsizei width,
                                                               GLsizei height) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glCopyTextureCHROMIUM(GLuint sourceId,
                                            GLint sourceLevel,
                                            GLenum destTarget,
                                            GLuint destId,
                                            GLint destLevel,
                                            GLint internalFormat,
                                            GLenum destType,
                                            GLboolean unpackFlipY,
                                            GLboolean unpackPremultiplyAlpha,
                                            GLboolean unpackUnmultiplyAlpha) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glCreateMemoryObjectsEXT(GLsizei n,
                                               GLuint* memoryObjects) { … }

GLuint GL_BINDING_CALL MockGLInterface::Mock_glCreateProgram(void) { … }

GLuint GL_BINDING_CALL MockGLInterface::Mock_glCreateShader(GLenum type) { … }

GLuint GL_BINDING_CALL
MockGLInterface::Mock_glCreateShaderProgramv(GLenum type,
                                             GLsizei count,
                                             const char* const* strings) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glCullFace(GLenum mode) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDebugMessageCallback(GLDEBUGPROC callback,
                                             const void* userParam) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDebugMessageCallbackKHR(GLDEBUGPROC callback,
                                                const void* userParam) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDebugMessageControl(GLenum source,
                                            GLenum type,
                                            GLenum severity,
                                            GLsizei count,
                                            const GLuint* ids,
                                            GLboolean enabled) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDebugMessageControlKHR(GLenum source,
                                               GLenum type,
                                               GLenum severity,
                                               GLsizei count,
                                               const GLuint* ids,
                                               GLboolean enabled) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDebugMessageInsert(GLenum source,
                                           GLenum type,
                                           GLuint id,
                                           GLenum severity,
                                           GLsizei length,
                                           const char* buf) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDebugMessageInsertKHR(GLenum source,
                                              GLenum type,
                                              GLuint id,
                                              GLenum severity,
                                              GLsizei length,
                                              const char* buf) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDeleteBuffers(GLsizei n, const GLuint* buffers) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDeleteFencesNV(GLsizei n, const GLuint* fences) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDeleteFramebuffers(GLsizei n,
                                           const GLuint* framebuffers) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDeleteMemoryObjectsEXT(GLsizei n,
                                               const GLuint* memoryObjects) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glDeleteProgram(GLuint program) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDeleteProgramPipelines(GLsizei n,
                                               const GLuint* pipelines) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glDeleteQueries(GLsizei n,
                                                           const GLuint* ids) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDeleteQueriesEXT(GLsizei n, const GLuint* ids) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDeleteRenderbuffers(GLsizei n,
                                            const GLuint* renderbuffers) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDeleteSamplers(GLsizei n, const GLuint* samplers) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDeleteSemaphoresEXT(GLsizei n,
                                            const GLuint* semaphores) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glDeleteShader(GLuint shader) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glDeleteSync(GLsync sync) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDeleteTextures(GLsizei n, const GLuint* textures) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDeleteTransformFeedbacks(GLsizei n, const GLuint* ids) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDeleteVertexArrays(GLsizei n, const GLuint* arrays) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glDepthFunc(GLenum func) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glDepthMask(GLboolean flag) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glDepthRange(GLclampd zNear,
                                                        GLclampd zFar) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glDepthRangef(GLclampf zNear,
                                                         GLclampf zFar) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glDetachShader(GLuint program,
                                                          GLuint shader) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glDisable(GLenum cap) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDisableExtensionANGLE(const char* name) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDisableVertexAttribArray(GLuint index) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glDisablei(GLenum target,
                                                      GLuint index) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glDisableiOES(GLenum target,
                                                         GLuint index) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDiscardFramebufferEXT(GLenum target,
                                              GLsizei numAttachments,
                                              const GLenum* attachments) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDispatchCompute(GLuint numGroupsX,
                                        GLuint numGroupsY,
                                        GLuint numGroupsZ) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDispatchComputeIndirect(GLintptr indirect) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glDrawArrays(GLenum mode,
                                                        GLint first,
                                                        GLsizei count) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDrawArraysIndirect(GLenum mode, const void* indirect) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDrawArraysInstanced(GLenum mode,
                                            GLint first,
                                            GLsizei count,
                                            GLsizei primcount) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDrawArraysInstancedANGLE(GLenum mode,
                                                 GLint first,
                                                 GLsizei count,
                                                 GLsizei primcount) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDrawArraysInstancedBaseInstanceANGLE(
    GLenum mode,
    GLint first,
    GLsizei count,
    GLsizei primcount,
    GLuint baseinstance) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glDrawArraysInstancedBaseInstanceEXT(
    GLenum mode,
    GLint first,
    GLsizei count,
    GLsizei primcount,
    GLuint baseinstance) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glDrawBuffer(GLenum mode) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glDrawBuffers(GLsizei n,
                                                         const GLenum* bufs) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDrawBuffersEXT(GLsizei n, const GLenum* bufs) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glDrawElements(GLenum mode,
                                                          GLsizei count,
                                                          GLenum type,
                                                          const void* indices) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDrawElementsIndirect(GLenum mode,
                                             GLenum type,
                                             const void* indirect) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDrawElementsInstanced(GLenum mode,
                                              GLsizei count,
                                              GLenum type,
                                              const void* indices,
                                              GLsizei primcount) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDrawElementsInstancedANGLE(GLenum mode,
                                                   GLsizei count,
                                                   GLenum type,
                                                   const void* indices,
                                                   GLsizei primcount) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDrawElementsInstancedBaseVertexBaseInstanceANGLE(
    GLenum mode,
    GLsizei count,
    GLenum type,
    const void* indices,
    GLsizei primcount,
    GLint baseVertex,
    GLuint baseInstance) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDrawElementsInstancedBaseVertexBaseInstanceEXT(
    GLenum mode,
    GLsizei count,
    GLenum type,
    const void* indices,
    GLsizei primcount,
    GLint baseVertex,
    GLuint baseInstance) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glDrawRangeElements(GLenum mode,
                                          GLuint start,
                                          GLuint end,
                                          GLsizei count,
                                          GLenum type,
                                          const void* indices) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glEGLImageTargetRenderbufferStorageOES(
    GLenum target,
    GLeglImageOES image) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glEGLImageTargetTexture2DOES(GLenum target,
                                                   GLeglImageOES image) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glEnable(GLenum cap) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glEnableVertexAttribArray(GLuint index) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glEnablei(GLenum target,
                                                     GLuint index) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glEnableiOES(GLenum target,
                                                        GLuint index) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glEndPixelLocalStorageANGLE(GLsizei n,
                                                  const GLenum* storeops) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glEndQuery(GLenum target) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glEndQueryEXT(GLenum target) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glEndTilingQCOM(GLbitfield preserveMask) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glEndTransformFeedback(void) { … }

GLsync GL_BINDING_CALL MockGLInterface::Mock_glFenceSync(GLenum condition,
                                                         GLbitfield flags) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glFinish(void) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glFinishFenceNV(GLuint fence) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glFlush(void) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glFlushMappedBufferRange(GLenum target,
                                               GLintptr offset,
                                               GLsizeiptr length) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glFlushMappedBufferRangeEXT(GLenum target,
                                                  GLintptr offset,
                                                  GLsizeiptr length) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glFramebufferMemorylessPixelLocalStorageANGLE(
    GLint plane,
    GLenum internalformat) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glFramebufferParameteri(GLenum target,
                                              GLenum pname,
                                              GLint param) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glFramebufferParameteriMESA(GLenum target,
                                                  GLenum pname,
                                                  GLint param) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glFramebufferPixelLocalClearValuefvANGLE(
    GLint plane,
    const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glFramebufferPixelLocalClearValueivANGLE(
    GLint plane,
    const GLint* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glFramebufferPixelLocalClearValueuivANGLE(
    GLint plane,
    const GLuint* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glFramebufferPixelLocalStorageInterruptANGLE() { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glFramebufferPixelLocalStorageRestoreANGLE() { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glFramebufferRenderbuffer(GLenum target,
                                                GLenum attachment,
                                                GLenum renderbuffertarget,
                                                GLuint renderbuffer) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glFramebufferTexture2D(GLenum target,
                                             GLenum attachment,
                                             GLenum textarget,
                                             GLuint texture,
                                             GLint level) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glFramebufferTexture2DMultisampleEXT(GLenum target,
                                                           GLenum attachment,
                                                           GLenum textarget,
                                                           GLuint texture,
                                                           GLint level,
                                                           GLsizei samples) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glFramebufferTexture2DMultisampleIMG(GLenum target,
                                                           GLenum attachment,
                                                           GLenum textarget,
                                                           GLuint texture,
                                                           GLint level,
                                                           GLsizei samples) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glFramebufferTextureLayer(GLenum target,
                                                GLenum attachment,
                                                GLuint texture,
                                                GLint level,
                                                GLint layer) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glFramebufferTextureMultiviewOVR(GLenum target,
                                                       GLenum attachment,
                                                       GLuint texture,
                                                       GLint level,
                                                       GLint baseViewIndex,
                                                       GLsizei numViews) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glFramebufferTexturePixelLocalStorageANGLE(
    GLint plane,
    GLuint backingtexture,
    GLint level,
    GLint layer) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glFrontFace(GLenum mode) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGenBuffers(GLsizei n,
                                                        GLuint* buffers) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGenFencesNV(GLsizei n,
                                                         GLuint* fences) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGenFramebuffers(GLsizei n, GLuint* framebuffers) { … }

GLuint GL_BINDING_CALL
MockGLInterface::Mock_glGenProgramPipelines(GLsizei n, GLuint* pipelines) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGenQueries(GLsizei n,
                                                        GLuint* ids) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGenQueriesEXT(GLsizei n,
                                                           GLuint* ids) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGenSamplers(GLsizei n,
                                                         GLuint* samplers) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGenSemaphoresEXT(GLsizei n, GLuint* semaphores) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGenTextures(GLsizei n,
                                                         GLuint* textures) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGenTransformFeedbacks(GLsizei n, GLuint* ids) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGenVertexArrays(GLsizei n,
                                                             GLuint* arrays) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGenVertexArraysOES(GLsizei n, GLuint* arrays) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGenerateMipmap(GLenum target) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetActiveAttrib(GLuint program,
                                                             GLuint index,
                                                             GLsizei bufsize,
                                                             GLsizei* length,
                                                             GLint* size,
                                                             GLenum* type,
                                                             char* name) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetActiveUniform(GLuint program,
                                                              GLuint index,
                                                              GLsizei bufsize,
                                                              GLsizei* length,
                                                              GLint* size,
                                                              GLenum* type,
                                                              char* name) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetActiveUniformBlockName(GLuint program,
                                                  GLuint uniformBlockIndex,
                                                  GLsizei bufSize,
                                                  GLsizei* length,
                                                  char* uniformBlockName) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetActiveUniformBlockiv(GLuint program,
                                                GLuint uniformBlockIndex,
                                                GLenum pname,
                                                GLint* params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetActiveUniformBlockivRobustANGLE(
    GLuint program,
    GLuint uniformBlockIndex,
    GLenum pname,
    GLsizei bufSize,
    GLsizei* length,
    GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetActiveUniformsiv(GLuint program,
                                            GLsizei uniformCount,
                                            const GLuint* uniformIndices,
                                            GLenum pname,
                                            GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetAttachedShaders(GLuint program,
                                           GLsizei maxcount,
                                           GLsizei* count,
                                           GLuint* shaders) { … }

GLint GL_BINDING_CALL
MockGLInterface::Mock_glGetAttribLocation(GLuint program, const char* name) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetBooleani_v(GLenum target,
                                                           GLuint index,
                                                           GLboolean* data) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetBooleani_vRobustANGLE(GLenum target,
                                                 GLuint index,
                                                 GLsizei bufSize,
                                                 GLsizei* length,
                                                 GLboolean* data) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetBooleanv(GLenum pname,
                                                         GLboolean* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetBooleanvRobustANGLE(GLenum pname,
                                               GLsizei bufSize,
                                               GLsizei* length,
                                               GLboolean* data) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetBufferParameteri64vRobustANGLE(GLenum target,
                                                          GLenum pname,
                                                          GLsizei bufSize,
                                                          GLsizei* length,
                                                          GLint64* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetBufferParameteriv(GLenum target,
                                             GLenum pname,
                                             GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetBufferParameterivRobustANGLE(GLenum target,
                                                        GLenum pname,
                                                        GLsizei bufSize,
                                                        GLsizei* length,
                                                        GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetBufferPointervRobustANGLE(GLenum target,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei* length,
                                                     void** params) { … }

GLuint GL_BINDING_CALL
MockGLInterface::Mock_glGetDebugMessageLog(GLuint count,
                                           GLsizei bufSize,
                                           GLenum* sources,
                                           GLenum* types,
                                           GLuint* ids,
                                           GLenum* severities,
                                           GLsizei* lengths,
                                           char* messageLog) { … }

GLuint GL_BINDING_CALL
MockGLInterface::Mock_glGetDebugMessageLogKHR(GLuint count,
                                              GLsizei bufSize,
                                              GLenum* sources,
                                              GLenum* types,
                                              GLuint* ids,
                                              GLenum* severities,
                                              GLsizei* lengths,
                                              char* messageLog) { … }

GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetError(void) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetFenceivNV(GLuint fence,
                                                          GLenum pname,
                                                          GLint* params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetFloatv(GLenum pname,
                                                       GLfloat* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetFloatvRobustANGLE(GLenum pname,
                                             GLsizei bufSize,
                                             GLsizei* length,
                                             GLfloat* data) { … }

GLint GL_BINDING_CALL
MockGLInterface::Mock_glGetFragDataIndexEXT(GLuint program, const char* name) { … }

GLint GL_BINDING_CALL
MockGLInterface::Mock_glGetFragDataLocation(GLuint program, const char* name) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetFramebufferAttachmentParameteriv(GLenum target,
                                                            GLenum attachment,
                                                            GLenum pname,
                                                            GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetFramebufferAttachmentParameterivRobustANGLE(
    GLenum target,
    GLenum attachment,
    GLenum pname,
    GLsizei bufSize,
    GLsizei* length,
    GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetFramebufferParameteriv(GLenum target,
                                                  GLenum pname,
                                                  GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetFramebufferParameterivRobustANGLE(GLenum target,
                                                             GLenum pname,
                                                             GLsizei bufSize,
                                                             GLsizei* length,
                                                             GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetFramebufferPixelLocalStorageParameterfvANGLE(
    GLint plane,
    GLenum pname,
    GLfloat* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetFramebufferPixelLocalStorageParameterfvRobustANGLE(
    GLint plane,
    GLenum pname,
    GLsizei bufSize,
    GLsizei* length,
    GLfloat* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetFramebufferPixelLocalStorageParameterivANGLE(
    GLint plane,
    GLenum pname,
    GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetFramebufferPixelLocalStorageParameterivRobustANGLE(
    GLint plane,
    GLenum pname,
    GLsizei bufSize,
    GLsizei* length,
    GLint* params) { … }

GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatus(void) { … }

GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatusEXT(void) { … }

GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatusKHR(void) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetInteger64i_v(GLenum target,
                                                             GLuint index,
                                                             GLint64* data) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetInteger64i_vRobustANGLE(GLenum target,
                                                   GLuint index,
                                                   GLsizei bufSize,
                                                   GLsizei* length,
                                                   GLint64* data) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetInteger64v(GLenum pname,
                                                           GLint64* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetInteger64vRobustANGLE(GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei* length,
                                                 GLint64* data) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetIntegeri_v(GLenum target,
                                                           GLuint index,
                                                           GLint* data) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetIntegeri_vRobustANGLE(GLenum target,
                                                 GLuint index,
                                                 GLsizei bufSize,
                                                 GLsizei* length,
                                                 GLint* data) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetIntegerv(GLenum pname,
                                                         GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetIntegervRobustANGLE(GLenum pname,
                                               GLsizei bufSize,
                                               GLsizei* length,
                                               GLint* data) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetInternalformatSampleivNV(GLenum target,
                                                    GLenum internalformat,
                                                    GLsizei samples,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetInternalformativ(GLenum target,
                                            GLenum internalformat,
                                            GLenum pname,
                                            GLsizei bufSize,
                                            GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetInternalformativRobustANGLE(GLenum target,
                                                       GLenum internalformat,
                                                       GLenum pname,
                                                       GLsizei bufSize,
                                                       GLsizei* length,
                                                       GLint* params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetMultisamplefv(GLenum pname,
                                                              GLuint index,
                                                              GLfloat* val) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetMultisamplefvRobustANGLE(GLenum pname,
                                                    GLuint index,
                                                    GLsizei bufSize,
                                                    GLsizei* length,
                                                    GLfloat* val) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetObjectLabel(GLenum identifier,
                                                            GLuint name,
                                                            GLsizei bufSize,
                                                            GLsizei* length,
                                                            char* label) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetObjectLabelKHR(GLenum identifier,
                                          GLuint name,
                                          GLsizei bufSize,
                                          GLsizei* length,
                                          char* label) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetObjectPtrLabel(void* ptr,
                                                               GLsizei bufSize,
                                                               GLsizei* length,
                                                               char* label) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetObjectPtrLabelKHR(void* ptr,
                                             GLsizei bufSize,
                                             GLsizei* length,
                                             char* label) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetPointerv(GLenum pname,
                                                         void** params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetPointervKHR(GLenum pname,
                                                            void** params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetPointervRobustANGLERobustANGLE(GLenum pname,
                                                          GLsizei bufSize,
                                                          GLsizei* length,
                                                          void** params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetProgramBinary(GLuint program,
                                         GLsizei bufSize,
                                         GLsizei* length,
                                         GLenum* binaryFormat,
                                         GLvoid* binary) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetProgramBinaryOES(GLuint program,
                                            GLsizei bufSize,
                                            GLsizei* length,
                                            GLenum* binaryFormat,
                                            GLvoid* binary) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetProgramInfoLog(GLuint program,
                                                               GLsizei bufsize,
                                                               GLsizei* length,
                                                               char* infolog) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetProgramInterfaceiv(GLuint program,
                                              GLenum programInterface,
                                              GLenum pname,
                                              GLint* params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetProgramInterfaceivRobustANGLE(
    GLuint program,
    GLenum programInterface,
    GLenum pname,
    GLsizei bufSize,
    GLsizei* length,
    GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetProgramPipelineInfoLog(GLuint pipeline,
                                                  GLsizei bufSize,
                                                  GLsizei* length,
                                                  GLchar* infoLog) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetProgramPipelineiv(GLuint pipeline,
                                             GLenum pname,
                                             GLint* params) { … }

GLuint GL_BINDING_CALL
MockGLInterface::Mock_glGetProgramResourceIndex(GLuint program,
                                                GLenum programInterface,
                                                const GLchar* name) { … }

GLint GL_BINDING_CALL
MockGLInterface::Mock_glGetProgramResourceLocation(GLuint program,
                                                   GLenum programInterface,
                                                   const char* name) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetProgramResourceName(GLuint program,
                                               GLenum programInterface,
                                               GLuint index,
                                               GLsizei bufSize,
                                               GLsizei* length,
                                               GLchar* name) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetProgramResourceiv(GLuint program,
                                             GLenum programInterface,
                                             GLuint index,
                                             GLsizei propCount,
                                             const GLenum* props,
                                             GLsizei bufSize,
                                             GLsizei* length,
                                             GLint* params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetProgramiv(GLuint program,
                                                          GLenum pname,
                                                          GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetProgramivRobustANGLE(GLuint program,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei* length,
                                                GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetQueryObjecti64vEXT(GLuint id,
                                              GLenum pname,
                                              GLint64* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetQueryObjecti64vRobustANGLE(GLuint id,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei* length,
                                                      GLint64* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetQueryObjectivEXT(GLuint id,
                                            GLenum pname,
                                            GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetQueryObjectivRobustANGLE(GLuint id,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLsizei* length,
                                                    GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetQueryObjectui64vEXT(GLuint id,
                                               GLenum pname,
                                               GLuint64* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetQueryObjectui64vRobustANGLE(GLuint id,
                                                       GLenum pname,
                                                       GLsizei bufSize,
                                                       GLsizei* length,
                                                       GLuint64* params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryObjectuiv(GLuint id,
                                                               GLenum pname,
                                                               GLuint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetQueryObjectuivEXT(GLuint id,
                                             GLenum pname,
                                             GLuint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetQueryObjectuivRobustANGLE(GLuint id,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei* length,
                                                     GLuint* params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryiv(GLenum target,
                                                        GLenum pname,
                                                        GLint* params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryivEXT(GLenum target,
                                                           GLenum pname,
                                                           GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetQueryivRobustANGLE(GLenum target,
                                              GLenum pname,
                                              GLsizei bufSize,
                                              GLsizei* length,
                                              GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetRenderbufferParameteriv(GLenum target,
                                                   GLenum pname,
                                                   GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetRenderbufferParameterivRobustANGLE(GLenum target,
                                                              GLenum pname,
                                                              GLsizei bufSize,
                                                              GLsizei* length,
                                                              GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetSamplerParameterIivRobustANGLE(GLuint sampler,
                                                          GLenum pname,
                                                          GLsizei bufSize,
                                                          GLsizei* length,
                                                          GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetSamplerParameterIuivRobustANGLE(GLuint sampler,
                                                           GLenum pname,
                                                           GLsizei bufSize,
                                                           GLsizei* length,
                                                           GLuint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetSamplerParameterfv(GLuint sampler,
                                              GLenum pname,
                                              GLfloat* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetSamplerParameterfvRobustANGLE(GLuint sampler,
                                                         GLenum pname,
                                                         GLsizei bufSize,
                                                         GLsizei* length,
                                                         GLfloat* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetSamplerParameteriv(GLuint sampler,
                                              GLenum pname,
                                              GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetSamplerParameterivRobustANGLE(GLuint sampler,
                                                         GLenum pname,
                                                         GLsizei bufSize,
                                                         GLsizei* length,
                                                         GLint* params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetShaderInfoLog(GLuint shader,
                                                              GLsizei bufsize,
                                                              GLsizei* length,
                                                              char* infolog) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetShaderPrecisionFormat(GLenum shadertype,
                                                 GLenum precisiontype,
                                                 GLint* range,
                                                 GLint* precision) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetShaderSource(GLuint shader,
                                                             GLsizei bufsize,
                                                             GLsizei* length,
                                                             char* source) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetShaderiv(GLuint shader,
                                                         GLenum pname,
                                                         GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetShaderivRobustANGLE(GLuint shader,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               GLsizei* length,
                                               GLint* params) { … }

const GLubyte* GL_BINDING_CALL MockGLInterface::Mock_glGetString(GLenum name) { … }

const GLubyte* GL_BINDING_CALL
MockGLInterface::Mock_glGetStringi(GLenum name, GLuint index) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetSynciv(GLsync sync,
                                                       GLenum pname,
                                                       GLsizei bufSize,
                                                       GLsizei* length,
                                                       GLint* values) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetTexLevelParameterfv(GLenum target,
                                               GLint level,
                                               GLenum pname,
                                               GLfloat* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetTexLevelParameterfvANGLE(GLenum target,
                                                    GLint level,
                                                    GLenum pname,
                                                    GLfloat* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetTexLevelParameterfvRobustANGLE(GLenum target,
                                                          GLint level,
                                                          GLenum pname,
                                                          GLsizei bufSize,
                                                          GLsizei* length,
                                                          GLfloat* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetTexLevelParameteriv(GLenum target,
                                               GLint level,
                                               GLenum pname,
                                               GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetTexLevelParameterivANGLE(GLenum target,
                                                    GLint level,
                                                    GLenum pname,
                                                    GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetTexLevelParameterivRobustANGLE(GLenum target,
                                                          GLint level,
                                                          GLenum pname,
                                                          GLsizei bufSize,
                                                          GLsizei* length,
                                                          GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetTexParameterIivRobustANGLE(GLenum target,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei* length,
                                                      GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetTexParameterIuivRobustANGLE(GLenum target,
                                                       GLenum pname,
                                                       GLsizei bufSize,
                                                       GLsizei* length,
                                                       GLuint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetTexParameterfv(GLenum target,
                                          GLenum pname,
                                          GLfloat* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetTexParameterfvRobustANGLE(GLenum target,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei* length,
                                                     GLfloat* params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetTexParameteriv(GLenum target,
                                                               GLenum pname,
                                                               GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetTexParameterivRobustANGLE(GLenum target,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei* length,
                                                     GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetTransformFeedbackVarying(GLuint program,
                                                    GLuint index,
                                                    GLsizei bufSize,
                                                    GLsizei* length,
                                                    GLsizei* size,
                                                    GLenum* type,
                                                    char* name) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetTranslatedShaderSourceANGLE(GLuint shader,
                                                       GLsizei bufsize,
                                                       GLsizei* length,
                                                       char* source) { … }

GLuint GL_BINDING_CALL
MockGLInterface::Mock_glGetUniformBlockIndex(GLuint program,
                                             const char* uniformBlockName) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetUniformIndices(GLuint program,
                                          GLsizei uniformCount,
                                          const char* const* uniformNames,
                                          GLuint* uniformIndices) { … }

GLint GL_BINDING_CALL
MockGLInterface::Mock_glGetUniformLocation(GLuint program, const char* name) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetUniformfv(GLuint program,
                                                          GLint location,
                                                          GLfloat* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetUniformfvRobustANGLE(GLuint program,
                                                GLint location,
                                                GLsizei bufSize,
                                                GLsizei* length,
                                                GLfloat* params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetUniformiv(GLuint program,
                                                          GLint location,
                                                          GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetUniformivRobustANGLE(GLuint program,
                                                GLint location,
                                                GLsizei bufSize,
                                                GLsizei* length,
                                                GLint* params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetUniformuiv(GLuint program,
                                                           GLint location,
                                                           GLuint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetUniformuivRobustANGLE(GLuint program,
                                                 GLint location,
                                                 GLsizei bufSize,
                                                 GLsizei* length,
                                                 GLuint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetVertexAttribIivRobustANGLE(GLuint index,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei* length,
                                                      GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetVertexAttribIuivRobustANGLE(GLuint index,
                                                       GLenum pname,
                                                       GLsizei bufSize,
                                                       GLsizei* length,
                                                       GLuint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetVertexAttribPointerv(GLuint index,
                                                GLenum pname,
                                                void** pointer) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetVertexAttribPointervRobustANGLE(GLuint index,
                                                           GLenum pname,
                                                           GLsizei bufSize,
                                                           GLsizei* length,
                                                           void** pointer) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetVertexAttribfv(GLuint index,
                                          GLenum pname,
                                          GLfloat* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetVertexAttribfvRobustANGLE(GLuint index,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei* length,
                                                     GLfloat* params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glGetVertexAttribiv(GLuint index,
                                                               GLenum pname,
                                                               GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetVertexAttribivRobustANGLE(GLuint index,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei* length,
                                                     GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetnUniformfvRobustANGLE(GLuint program,
                                                 GLint location,
                                                 GLsizei bufSize,
                                                 GLsizei* length,
                                                 GLfloat* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetnUniformivRobustANGLE(GLuint program,
                                                 GLint location,
                                                 GLsizei bufSize,
                                                 GLsizei* length,
                                                 GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glGetnUniformuivRobustANGLE(GLuint program,
                                                  GLint location,
                                                  GLsizei bufSize,
                                                  GLsizei* length,
                                                  GLuint* params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glHint(GLenum target, GLenum mode) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glImportMemoryFdEXT(GLuint memory,
                                          GLuint64 size,
                                          GLenum handleType,
                                          GLint fd) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glImportMemoryWin32HandleEXT(GLuint memory,
                                                   GLuint64 size,
                                                   GLenum handleType,
                                                   void* handle) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glImportMemoryZirconHandleANGLE(GLuint memory,
                                                      GLuint64 size,
                                                      GLenum handleType,
                                                      GLuint handle) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glImportSemaphoreFdEXT(GLuint semaphore,
                                             GLenum handleType,
                                             GLint fd) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glImportSemaphoreWin32HandleEXT(GLuint semaphore,
                                                      GLenum handleType,
                                                      void* handle) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glImportSemaphoreZirconHandleANGLE(GLuint semaphore,
                                                         GLenum handleType,
                                                         GLuint handle) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glInsertEventMarkerEXT(GLsizei length,
                                             const char* marker) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glInvalidateFramebuffer(GLenum target,
                                              GLsizei numAttachments,
                                              const GLenum* attachments) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glInvalidateSubFramebuffer(GLenum target,
                                                 GLsizei numAttachments,
                                                 const GLenum* attachments,
                                                 GLint x,
                                                 GLint y,
                                                 GLint width,
                                                 GLint height) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glInvalidateTextureANGLE(GLenum target) { … }

GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsBuffer(GLuint buffer) { … }

GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsEnabled(GLenum cap) { … }

GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsEnabledi(GLenum target,
                                                             GLuint index) { … }

GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsEnablediOES(GLenum target,
                                                                GLuint index) { … }

GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsFenceNV(GLuint fence) { … }

GLboolean GL_BINDING_CALL
MockGLInterface::Mock_glIsFramebuffer(GLuint framebuffer) { … }

GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsProgram(GLuint program) { … }

GLboolean GL_BINDING_CALL
MockGLInterface::Mock_glIsProgramPipeline(GLuint pipeline) { … }

GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsQuery(GLuint query) { … }

GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsQueryEXT(GLuint query) { … }

GLboolean GL_BINDING_CALL
MockGLInterface::Mock_glIsRenderbuffer(GLuint renderbuffer) { … }

GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsSampler(GLuint sampler) { … }

GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsShader(GLuint shader) { … }

GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsSync(GLsync sync) { … }

GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsTexture(GLuint texture) { … }

GLboolean GL_BINDING_CALL
MockGLInterface::Mock_glIsTransformFeedback(GLuint id) { … }

GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsVertexArray(GLuint array) { … }

GLboolean GL_BINDING_CALL
MockGLInterface::Mock_glIsVertexArrayOES(GLuint array) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glLineWidth(GLfloat width) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glLinkProgram(GLuint program) { … }

void* GL_BINDING_CALL MockGLInterface::Mock_glMapBufferOES(GLenum target,
                                                           GLenum access) { … }

void* GL_BINDING_CALL
MockGLInterface::Mock_glMapBufferRange(GLenum target,
                                       GLintptr offset,
                                       GLsizeiptr length,
                                       GLbitfield access) { … }

void* GL_BINDING_CALL
MockGLInterface::Mock_glMapBufferRangeEXT(GLenum target,
                                          GLintptr offset,
                                          GLsizeiptr length,
                                          GLbitfield access) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glMaxShaderCompilerThreadsKHR(GLuint count) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glMemoryBarrier(GLbitfield barriers) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glMemoryBarrierByRegion(GLbitfield barriers) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glMemoryBarrierEXT(GLbitfield barriers) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glMemoryObjectParameterivEXT(GLuint memoryObject,
                                                   GLenum pname,
                                                   const GLint* param) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glMinSampleShading(GLfloat value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glMultiDrawArraysANGLE(GLenum mode,
                                             const GLint* firsts,
                                             const GLsizei* counts,
                                             GLsizei drawcount) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glMultiDrawArraysInstancedANGLE(
    GLenum mode,
    const GLint* firsts,
    const GLsizei* counts,
    const GLsizei* instanceCounts,
    GLsizei drawcount) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glMultiDrawArraysInstancedBaseInstanceANGLE(
    GLenum mode,
    const GLint* firsts,
    const GLsizei* counts,
    const GLsizei* instanceCounts,
    const GLuint* baseInstances,
    GLsizei drawcount) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glMultiDrawElementsANGLE(GLenum mode,
                                               const GLsizei* counts,
                                               GLenum type,
                                               const GLvoid* const* indices,
                                               GLsizei drawcount) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glMultiDrawElementsInstancedANGLE(
    GLenum mode,
    const GLsizei* counts,
    GLenum type,
    const GLvoid* const* indices,
    const GLsizei* instanceCounts,
    GLsizei drawcount) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(
    GLenum mode,
    const GLsizei* counts,
    GLenum type,
    const GLvoid* const* indices,
    const GLsizei* instanceCounts,
    const GLint* baseVertices,
    const GLuint* baseInstances,
    GLsizei drawcount) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glObjectLabel(GLenum identifier,
                                                         GLuint name,
                                                         GLsizei length,
                                                         const char* label) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glObjectLabelKHR(GLenum identifier,
                                                            GLuint name,
                                                            GLsizei length,
                                                            const char* label) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glObjectPtrLabel(void* ptr,
                                                            GLsizei length,
                                                            const char* label) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glObjectPtrLabelKHR(void* ptr,
                                          GLsizei length,
                                          const char* label) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glPatchParameteri(GLenum pname,
                                                             GLint value) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glPatchParameteriOES(GLenum pname,
                                                                GLint value) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glPauseTransformFeedback(void) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glPixelLocalStorageBarrierANGLE() { … }

void GL_BINDING_CALL MockGLInterface::Mock_glPixelStorei(GLenum pname,
                                                         GLint param) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glPointParameteri(GLenum pname,
                                                             GLint param) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glPolygonMode(GLenum face,
                                                         GLenum mode) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glPolygonModeANGLE(GLenum face,
                                                              GLenum mode) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glPolygonOffset(GLfloat factor,
                                                           GLfloat units) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glPolygonOffsetClampEXT(GLfloat factor,
                                              GLfloat units,
                                              GLfloat clamp) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glPopDebugGroup() { … }

void GL_BINDING_CALL MockGLInterface::Mock_glPopDebugGroupKHR() { … }

void GL_BINDING_CALL MockGLInterface::Mock_glPopGroupMarkerEXT(void) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glPrimitiveRestartIndex(GLuint index) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glProgramBinary(GLuint program,
                                                           GLenum binaryFormat,
                                                           const GLvoid* binary,
                                                           GLsizei length) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramBinaryOES(GLuint program,
                                         GLenum binaryFormat,
                                         const GLvoid* binary,
                                         GLsizei length) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glProgramParameteri(GLuint program,
                                                               GLenum pname,
                                                               GLint value) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glProgramUniform1f(GLuint program,
                                                              GLint location,
                                                              GLfloat v0) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniform1fv(GLuint program,
                                          GLint location,
                                          GLsizei count,
                                          const GLfloat* value) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glProgramUniform1i(GLuint program,
                                                              GLint location,
                                                              GLint v0) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniform1iv(GLuint program,
                                          GLint location,
                                          GLsizei count,
                                          const GLint* value) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glProgramUniform1ui(GLuint program,
                                                               GLint location,
                                                               GLuint v0) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniform1uiv(GLuint program,
                                           GLint location,
                                           GLsizei count,
                                           const GLuint* value) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glProgramUniform2f(GLuint program,
                                                              GLint location,
                                                              GLfloat v0,
                                                              GLfloat v1) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniform2fv(GLuint program,
                                          GLint location,
                                          GLsizei count,
                                          const GLfloat* value) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glProgramUniform2i(GLuint program,
                                                              GLint location,
                                                              GLint v0,
                                                              GLint v1) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniform2iv(GLuint program,
                                          GLint location,
                                          GLsizei count,
                                          const GLint* value) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glProgramUniform2ui(GLuint program,
                                                               GLint location,
                                                               GLuint v0,
                                                               GLuint v1) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniform2uiv(GLuint program,
                                           GLint location,
                                           GLsizei count,
                                           const GLuint* value) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glProgramUniform3f(GLuint program,
                                                              GLint location,
                                                              GLfloat v0,
                                                              GLfloat v1,
                                                              GLfloat v2) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniform3fv(GLuint program,
                                          GLint location,
                                          GLsizei count,
                                          const GLfloat* value) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glProgramUniform3i(GLuint program,
                                                              GLint location,
                                                              GLint v0,
                                                              GLint v1,
                                                              GLint v2) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniform3iv(GLuint program,
                                          GLint location,
                                          GLsizei count,
                                          const GLint* value) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glProgramUniform3ui(GLuint program,
                                                               GLint location,
                                                               GLuint v0,
                                                               GLuint v1,
                                                               GLuint v2) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniform3uiv(GLuint program,
                                           GLint location,
                                           GLsizei count,
                                           const GLuint* value) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glProgramUniform4f(GLuint program,
                                                              GLint location,
                                                              GLfloat v0,
                                                              GLfloat v1,
                                                              GLfloat v2,
                                                              GLfloat v3) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniform4fv(GLuint program,
                                          GLint location,
                                          GLsizei count,
                                          const GLfloat* value) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glProgramUniform4i(GLuint program,
                                                              GLint location,
                                                              GLint v0,
                                                              GLint v1,
                                                              GLint v2,
                                                              GLint v3) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniform4iv(GLuint program,
                                          GLint location,
                                          GLsizei count,
                                          const GLint* value) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glProgramUniform4ui(GLuint program,
                                                               GLint location,
                                                               GLuint v0,
                                                               GLuint v1,
                                                               GLuint v2,
                                                               GLuint v3) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniform4uiv(GLuint program,
                                           GLint location,
                                           GLsizei count,
                                           const GLuint* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniformMatrix2fv(GLuint program,
                                                GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniformMatrix2x3fv(GLuint program,
                                                  GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniformMatrix2x4fv(GLuint program,
                                                  GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniformMatrix3fv(GLuint program,
                                                GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniformMatrix3x2fv(GLuint program,
                                                  GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniformMatrix3x4fv(GLuint program,
                                                  GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniformMatrix4fv(GLuint program,
                                                GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniformMatrix4x2fv(GLuint program,
                                                  GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProgramUniformMatrix4x3fv(GLuint program,
                                                  GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glProvokingVertexANGLE(GLenum provokeMode) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glPushDebugGroup(GLenum source,
                                       GLuint id,
                                       GLsizei length,
                                       const char* message) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glPushDebugGroupKHR(GLenum source,
                                          GLuint id,
                                          GLsizei length,
                                          const char* message) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glPushGroupMarkerEXT(GLsizei length, const char* marker) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glQueryCounterEXT(GLuint id,
                                                             GLenum target) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glReadBuffer(GLenum src) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glReadPixels(GLint x,
                                                        GLint y,
                                                        GLsizei width,
                                                        GLsizei height,
                                                        GLenum format,
                                                        GLenum type,
                                                        void* pixels) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glReadPixelsRobustANGLE(GLint x,
                                              GLint y,
                                              GLsizei width,
                                              GLsizei height,
                                              GLenum format,
                                              GLenum type,
                                              GLsizei bufSize,
                                              GLsizei* length,
                                              GLsizei* columns,
                                              GLsizei* rows,
                                              void* pixels) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glReadnPixelsRobustANGLE(GLint x,
                                               GLint y,
                                               GLsizei width,
                                               GLsizei height,
                                               GLenum format,
                                               GLenum type,
                                               GLsizei bufSize,
                                               GLsizei* length,
                                               GLsizei* columns,
                                               GLsizei* rows,
                                               void* data) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glReleaseShaderCompiler(void) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glReleaseTexturesANGLE(GLuint numTextures,
                                             const GLuint* textures,
                                             GLenum* layouts) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glRenderbufferStorage(GLenum target,
                                            GLenum internalformat,
                                            GLsizei width,
                                            GLsizei height) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glRenderbufferStorageMultisample(GLenum target,
                                                       GLsizei samples,
                                                       GLenum internalformat,
                                                       GLsizei width,
                                                       GLsizei height) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glRenderbufferStorageMultisampleANGLE(
    GLenum target,
    GLsizei samples,
    GLenum internalformat,
    GLsizei width,
    GLsizei height) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glRenderbufferStorageMultisampleAdvancedAMD(
    GLenum target,
    GLsizei samples,
    GLsizei storageSamples,
    GLenum internalformat,
    GLsizei width,
    GLsizei height) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glRenderbufferStorageMultisampleEXT(GLenum target,
                                                          GLsizei samples,
                                                          GLenum internalformat,
                                                          GLsizei width,
                                                          GLsizei height) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glRenderbufferStorageMultisampleIMG(GLenum target,
                                                          GLsizei samples,
                                                          GLenum internalformat,
                                                          GLsizei width,
                                                          GLsizei height) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glRequestExtensionANGLE(const char* name) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glResumeTransformFeedback(void) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glSampleCoverage(GLclampf value,
                                                            GLboolean invert) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glSampleMaski(GLuint maskNumber,
                                                         GLbitfield mask) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glSamplerParameterIivRobustANGLE(GLuint sampler,
                                                       GLenum pname,
                                                       GLsizei bufSize,
                                                       const GLint* param) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glSamplerParameterIuivRobustANGLE(GLuint sampler,
                                                        GLenum pname,
                                                        GLsizei bufSize,
                                                        const GLuint* param) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glSamplerParameterf(GLuint sampler,
                                                               GLenum pname,
                                                               GLfloat param) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glSamplerParameterfv(GLuint sampler,
                                           GLenum pname,
                                           const GLfloat* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glSamplerParameterfvRobustANGLE(GLuint sampler,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      const GLfloat* param) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glSamplerParameteri(GLuint sampler,
                                                               GLenum pname,
                                                               GLint param) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glSamplerParameteriv(GLuint sampler,
                                           GLenum pname,
                                           const GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glSamplerParameterivRobustANGLE(GLuint sampler,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      const GLint* param) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glScissor(GLint x,
                                                     GLint y,
                                                     GLsizei width,
                                                     GLsizei height) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glSetFenceNV(GLuint fence,
                                                        GLenum condition) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glShaderBinary(GLsizei n,
                                                          const GLuint* shaders,
                                                          GLenum binaryformat,
                                                          const void* binary,
                                                          GLsizei length) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glShaderSource(GLuint shader,
                                     GLsizei count,
                                     const char* const* str,
                                     const GLint* length) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glSignalSemaphoreEXT(GLuint semaphore,
                                           GLuint numBufferBarriers,
                                           const GLuint* buffers,
                                           GLuint numTextureBarriers,
                                           const GLuint* textures,
                                           const GLenum* dstLayouts) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glStartTilingQCOM(GLuint x,
                                        GLuint y,
                                        GLuint width,
                                        GLuint height,
                                        GLbitfield preserveMask) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glStencilFunc(GLenum func,
                                                         GLint ref,
                                                         GLuint mask) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glStencilFuncSeparate(GLenum face,
                                                                 GLenum func,
                                                                 GLint ref,
                                                                 GLuint mask) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glStencilMask(GLuint mask) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glStencilMaskSeparate(GLenum face,
                                                                 GLuint mask) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glStencilOp(GLenum fail,
                                                       GLenum zfail,
                                                       GLenum zpass) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glStencilOpSeparate(GLenum face,
                                                               GLenum fail,
                                                               GLenum zfail,
                                                               GLenum zpass) { … }

GLboolean GL_BINDING_CALL MockGLInterface::Mock_glTestFenceNV(GLuint fence) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glTexBuffer(GLenum target,
                                                       GLenum internalformat,
                                                       GLuint buffer) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glTexBufferEXT(GLenum target,
                                                          GLenum internalformat,
                                                          GLuint buffer) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glTexBufferOES(GLenum target,
                                                          GLenum internalformat,
                                                          GLuint buffer) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glTexBufferRange(GLenum target,
                                       GLenum internalformat,
                                       GLuint buffer,
                                       GLintptr offset,
                                       GLsizeiptr size) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glTexBufferRangeEXT(GLenum target,
                                          GLenum internalformat,
                                          GLuint buffer,
                                          GLintptr offset,
                                          GLsizeiptr size) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glTexBufferRangeOES(GLenum target,
                                          GLenum internalformat,
                                          GLuint buffer,
                                          GLintptr offset,
                                          GLsizeiptr size) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glTexImage2D(GLenum target,
                                                        GLint level,
                                                        GLint internalformat,
                                                        GLsizei width,
                                                        GLsizei height,
                                                        GLint border,
                                                        GLenum format,
                                                        GLenum type,
                                                        const void* pixels) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glTexImage2DExternalANGLE(GLenum target,
                                                GLint level,
                                                GLint internalformat,
                                                GLsizei width,
                                                GLsizei height,
                                                GLint border,
                                                GLenum format,
                                                GLenum type) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glTexImage2DRobustANGLE(GLenum target,
                                              GLint level,
                                              GLint internalformat,
                                              GLsizei width,
                                              GLsizei height,
                                              GLint border,
                                              GLenum format,
                                              GLenum type,
                                              GLsizei bufSize,
                                              const void* pixels) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glTexImage3D(GLenum target,
                                                        GLint level,
                                                        GLint internalformat,
                                                        GLsizei width,
                                                        GLsizei height,
                                                        GLsizei depth,
                                                        GLint border,
                                                        GLenum format,
                                                        GLenum type,
                                                        const void* pixels) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glTexImage3DRobustANGLE(GLenum target,
                                              GLint level,
                                              GLint internalformat,
                                              GLsizei width,
                                              GLsizei height,
                                              GLsizei depth,
                                              GLint border,
                                              GLenum format,
                                              GLenum type,
                                              GLsizei bufSize,
                                              const void* pixels) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glTexParameterIivRobustANGLE(GLenum target,
                                                   GLenum pname,
                                                   GLsizei bufSize,
                                                   const GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glTexParameterIuivRobustANGLE(GLenum target,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    const GLuint* params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glTexParameterf(GLenum target,
                                                           GLenum pname,
                                                           GLfloat param) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glTexParameterfv(GLenum target,
                                       GLenum pname,
                                       const GLfloat* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glTexParameterfvRobustANGLE(GLenum target,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  const GLfloat* params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glTexParameteri(GLenum target,
                                                           GLenum pname,
                                                           GLint param) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glTexParameteriv(GLenum target,
                                       GLenum pname,
                                       const GLint* params) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glTexParameterivRobustANGLE(GLenum target,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  const GLint* params) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glTexStorage2D(GLenum target,
                                                          GLsizei levels,
                                                          GLenum internalformat,
                                                          GLsizei width,
                                                          GLsizei height) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glTexStorage2DEXT(GLenum target,
                                        GLsizei levels,
                                        GLenum internalformat,
                                        GLsizei width,
                                        GLsizei height) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glTexStorage2DMultisample(
    GLenum target,
    GLsizei samples,
    GLenum internalformat,
    GLsizei width,
    GLsizei height,
    GLboolean fixedsamplelocations) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glTexStorage3D(GLenum target,
                                                          GLsizei levels,
                                                          GLenum internalformat,
                                                          GLsizei width,
                                                          GLsizei height,
                                                          GLsizei depth) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glTexStorageMem2DEXT(GLenum target,
                                           GLsizei levels,
                                           GLenum internalFormat,
                                           GLsizei width,
                                           GLsizei height,
                                           GLuint memory,
                                           GLuint64 offset) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glTexStorageMemFlags2DANGLE(
    GLenum target,
    GLsizei levels,
    GLenum internalFormat,
    GLsizei width,
    GLsizei height,
    GLuint memory,
    GLuint64 offset,
    GLbitfield createFlags,
    GLbitfield usageFlags,
    const void* imageCreateInfoPNext) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glTexSubImage2D(GLenum target,
                                                           GLint level,
                                                           GLint xoffset,
                                                           GLint yoffset,
                                                           GLsizei width,
                                                           GLsizei height,
                                                           GLenum format,
                                                           GLenum type,
                                                           const void* pixels) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glTexSubImage2DRobustANGLE(GLenum target,
                                                 GLint level,
                                                 GLint xoffset,
                                                 GLint yoffset,
                                                 GLsizei width,
                                                 GLsizei height,
                                                 GLenum format,
                                                 GLenum type,
                                                 GLsizei bufSize,
                                                 const void* pixels) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glTexSubImage3D(GLenum target,
                                                           GLint level,
                                                           GLint xoffset,
                                                           GLint yoffset,
                                                           GLint zoffset,
                                                           GLsizei width,
                                                           GLsizei height,
                                                           GLsizei depth,
                                                           GLenum format,
                                                           GLenum type,
                                                           const void* pixels) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glTexSubImage3DRobustANGLE(GLenum target,
                                                 GLint level,
                                                 GLint xoffset,
                                                 GLint yoffset,
                                                 GLint zoffset,
                                                 GLsizei width,
                                                 GLsizei height,
                                                 GLsizei depth,
                                                 GLenum format,
                                                 GLenum type,
                                                 GLsizei bufSize,
                                                 const void* pixels) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glTransformFeedbackVaryings(GLuint program,
                                                  GLsizei count,
                                                  const char* const* varyings,
                                                  GLenum bufferMode) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform1f(GLint location,
                                                       GLfloat x) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform1fv(GLint location,
                                                        GLsizei count,
                                                        const GLfloat* v) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform1i(GLint location,
                                                       GLint x) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform1iv(GLint location,
                                                        GLsizei count,
                                                        const GLint* v) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform1ui(GLint location,
                                                        GLuint v0) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform1uiv(GLint location,
                                                         GLsizei count,
                                                         const GLuint* v) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform2f(GLint location,
                                                       GLfloat x,
                                                       GLfloat y) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform2fv(GLint location,
                                                        GLsizei count,
                                                        const GLfloat* v) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform2i(GLint location,
                                                       GLint x,
                                                       GLint y) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform2iv(GLint location,
                                                        GLsizei count,
                                                        const GLint* v) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform2ui(GLint location,
                                                        GLuint v0,
                                                        GLuint v1) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform2uiv(GLint location,
                                                         GLsizei count,
                                                         const GLuint* v) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform3f(GLint location,
                                                       GLfloat x,
                                                       GLfloat y,
                                                       GLfloat z) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform3fv(GLint location,
                                                        GLsizei count,
                                                        const GLfloat* v) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform3i(GLint location,
                                                       GLint x,
                                                       GLint y,
                                                       GLint z) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform3iv(GLint location,
                                                        GLsizei count,
                                                        const GLint* v) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform3ui(GLint location,
                                                        GLuint v0,
                                                        GLuint v1,
                                                        GLuint v2) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform3uiv(GLint location,
                                                         GLsizei count,
                                                         const GLuint* v) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform4f(GLint location,
                                                       GLfloat x,
                                                       GLfloat y,
                                                       GLfloat z,
                                                       GLfloat w) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform4fv(GLint location,
                                                        GLsizei count,
                                                        const GLfloat* v) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform4i(GLint location,
                                                       GLint x,
                                                       GLint y,
                                                       GLint z,
                                                       GLint w) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform4iv(GLint location,
                                                        GLsizei count,
                                                        const GLint* v) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform4ui(GLint location,
                                                        GLuint v0,
                                                        GLuint v1,
                                                        GLuint v2,
                                                        GLuint v3) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUniform4uiv(GLint location,
                                                         GLsizei count,
                                                         const GLuint* v) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glUniformBlockBinding(GLuint program,
                                            GLuint uniformBlockIndex,
                                            GLuint uniformBlockBinding) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glUniformMatrix2fv(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glUniformMatrix2x3fv(GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glUniformMatrix2x4fv(GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glUniformMatrix3fv(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glUniformMatrix3x2fv(GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glUniformMatrix3x4fv(GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glUniformMatrix4fv(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glUniformMatrix4x2fv(GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat* value) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glUniformMatrix4x3fv(GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat* value) { … }

GLboolean GL_BINDING_CALL MockGLInterface::Mock_glUnmapBuffer(GLenum target) { … }

GLboolean GL_BINDING_CALL
MockGLInterface::Mock_glUnmapBufferOES(GLenum target) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUseProgram(GLuint program) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glUseProgramStages(GLuint pipeline,
                                                              GLbitfield stages,
                                                              GLuint program) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glValidateProgram(GLuint program) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glValidateProgramPipeline(GLuint pipeline) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttrib1f(GLuint indx,
                                                            GLfloat x) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glVertexAttrib1fv(GLuint indx, const GLfloat* values) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttrib2f(GLuint indx,
                                                            GLfloat x,
                                                            GLfloat y) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glVertexAttrib2fv(GLuint indx, const GLfloat* values) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttrib3f(GLuint indx,
                                                            GLfloat x,
                                                            GLfloat y,
                                                            GLfloat z) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glVertexAttrib3fv(GLuint indx, const GLfloat* values) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttrib4f(GLuint indx,
                                                            GLfloat x,
                                                            GLfloat y,
                                                            GLfloat z,
                                                            GLfloat w) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glVertexAttrib4fv(GLuint indx, const GLfloat* values) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glVertexAttribBinding(GLuint attribindex,
                                            GLuint bindingindex) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glVertexAttribDivisor(GLuint index, GLuint divisor) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glVertexAttribDivisorANGLE(GLuint index, GLuint divisor) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glVertexAttribDivisorEXT(GLuint index, GLuint divisor) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glVertexAttribFormat(GLuint attribindex,
                                           GLint size,
                                           GLenum type,
                                           GLboolean normalized,
                                           GLuint relativeoffset) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttribI4i(GLuint indx,
                                                             GLint x,
                                                             GLint y,
                                                             GLint z,
                                                             GLint w) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glVertexAttribI4iv(GLuint indx, const GLint* values) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttribI4ui(GLuint indx,
                                                              GLuint x,
                                                              GLuint y,
                                                              GLuint z,
                                                              GLuint w) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glVertexAttribI4uiv(GLuint indx, const GLuint* values) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glVertexAttribIFormat(GLuint attribindex,
                                            GLint size,
                                            GLenum type,
                                            GLuint relativeoffset) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glVertexAttribIPointer(GLuint indx,
                                             GLint size,
                                             GLenum type,
                                             GLsizei stride,
                                             const void* ptr) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glVertexAttribPointer(GLuint indx,
                                            GLint size,
                                            GLenum type,
                                            GLboolean normalized,
                                            GLsizei stride,
                                            const void* ptr) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glVertexBindingDivisor(GLuint bindingindex,
                                             GLuint divisor) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glViewport(GLint x,
                                                      GLint y,
                                                      GLsizei width,
                                                      GLsizei height) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glWaitSemaphoreEXT(GLuint semaphore,
                                         GLuint numBufferBarriers,
                                         const GLuint* buffers,
                                         GLuint numTextureBarriers,
                                         const GLuint* textures,
                                         const GLenum* srcLayouts) { … }

void GL_BINDING_CALL MockGLInterface::Mock_glWaitSync(GLsync sync,
                                                      GLbitfield flags,
                                                      GLuint64 timeout) { … }

void GL_BINDING_CALL
MockGLInterface::Mock_glWindowRectanglesEXT(GLenum mode,
                                            GLsizei n,
                                            const GLint* box) { … }

static void MockGlInvalidFunction() { … }

GLFunctionPointerType GL_BINDING_CALL
MockGLInterface::GetGLProcAddress(const char* name) { … }

}  // namespace gl