← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/glx/tests/indirect_api.cpp

  • Committer: mmach
  • Date: 2022-09-22 19:56:13 UTC
  • Revision ID: netbit73@gmail.com-20220922195613-wtik9mmy20tmor0i
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/glx/tests/indirect_api.cpp
1
 
/*
2
 
 * Copyright © 2012 Intel Corporation
3
 
 *
4
 
 * Permission is hereby granted, free of charge, to any person obtaining a
5
 
 * copy of this software and associated documentation files (the "Software"),
6
 
 * to deal in the Software without restriction, including without limitation
7
 
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8
 
 * and/or sell copies of the Software, and to permit persons to whom the
9
 
 * Software is furnished to do so, subject to the following conditions:
10
 
 *
11
 
 * The above copyright notice and this permission notice (including the next
12
 
 * paragraph) shall be included in all copies or substantial portions of the
13
 
 * Software.
14
 
 *
15
 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
 
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18
 
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
 
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20
 
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21
 
 * DEALINGS IN THE SOFTWARE.
22
 
 */
23
 
 
24
 
/**
25
 
 * \file indirect_api.cpp
26
 
 * Validate the generated code in indirect_init.c
27
 
 *
28
 
 * Tests various apsects of the dispatch table generated by
29
 
 * \c __glXNewIndirectAPI.
30
 
 *
31
 
 *    * No entry in the table should be \c NULL.
32
 
 *
33
 
 *    * Entries in the table that correspond to "known" functions with GLX
34
 
 *      protocol should point to the correct function.
35
 
 *
36
 
 *    * Entries beyond the end of the "known" part of the table (i.e., entries
37
 
 *      that can be allocated by drivers for extensions) should point to a
38
 
 *      no-op function.
39
 
 *
40
 
 *    * Entries in the table that correspond to "known" functions that lack
41
 
 *      GLX protocol should point to a no-op function.
42
 
 *
43
 
 * Very few entries in the last catogory are tests.  See \c OpenGL_20_is_nop.
44
 
 */
45
 
 
46
 
#include <gtest/gtest.h>
47
 
#include "main/glheader.h"
48
 
#include "../indirect_init.h"
49
 
#include "glapi/glapi.h"
50
 
#include "../../mesa/main/dispatch.h"
51
 
 
52
 
#ifndef GLX_USE_APPLEGL
53
 
static const void *nil = 0;
54
 
#endif
55
 
 
56
 
#define EXTRA_DISPATCH 111
57
 
 
58
 
static bool dispatch_table_size_was_queried = false;
59
 
 
60
 
extern "C" GLuint
61
 
_glapi_get_dispatch_table_size(void)
62
 
{
63
 
   dispatch_table_size_was_queried = true;
64
 
   return _gloffset_COUNT + EXTRA_DISPATCH;
65
 
}
66
 
 
67
 
/**
68
 
 * \name Indirect-rendering function stubs
69
 
 *
70
 
 * These are necessary so that indirect_init.c doesn't try to link with
71
 
 * indirect.c.  Linking with indirect.c would require linking with various X
72
 
 * libraries and a bunch of other stuff.  While this is ugly, it does simplify
73
 
 * the build quite a bit.
74
 
 */
75
 
/*@{*/
76
 
extern "C" {
77
 
void __indirect_glAccum(GLenum op, GLfloat value) { }
78
 
void __indirect_glAlphaFunc(GLenum func, GLclampf ref) { }
79
 
void __indirect_glBegin(GLenum mode) { }
80
 
void __indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap) { }
81
 
void __indirect_glBlendFunc(GLenum sfactor, GLenum dfactor) { }
82
 
void __indirect_glCallList(GLuint list) { }
83
 
void __indirect_glCallLists(GLsizei n, GLenum type, const GLvoid *lists) { }
84
 
void __indirect_glClear(GLbitfield mask) { }
85
 
void __indirect_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { }
86
 
void __indirect_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { }
87
 
void __indirect_glClearDepth(GLclampd depth) { }
88
 
void __indirect_glClearIndex(GLfloat c) { }
89
 
void __indirect_glClearStencil(GLint s) { }
90
 
void __indirect_glClipPlane(GLenum plane, const GLdouble *equation) { }
91
 
void __indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue) { }
92
 
void __indirect_glColor3bv(const GLbyte *v) { }
93
 
void __indirect_glColor3d(GLdouble red, GLdouble green, GLdouble blue) { }
94
 
void __indirect_glColor3dv(const GLdouble *v) { }
95
 
void __indirect_glColor3f(GLfloat red, GLfloat green, GLfloat blue) { }
96
 
void __indirect_glColor3fv(const GLfloat *v) { }
97
 
void __indirect_glColor3i(GLint red, GLint green, GLint blue) { }
98
 
void __indirect_glColor3iv(const GLint *v) { }
99
 
void __indirect_glColor3s(GLshort red, GLshort green, GLshort blue) { }
100
 
void __indirect_glColor3sv(const GLshort *v) { }
101
 
void __indirect_glColor3ub(GLubyte red, GLubyte green, GLubyte blue) { }
102
 
void __indirect_glColor3ubv(const GLubyte *v) { }
103
 
void __indirect_glColor3ui(GLuint red, GLuint green, GLuint blue) { }
104
 
void __indirect_glColor3uiv(const GLuint *v) { }
105
 
void __indirect_glColor3us(GLushort red, GLushort green, GLushort blue) { }
106
 
void __indirect_glColor3usv(const GLushort *v) { }
107
 
void __indirect_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) { }
108
 
void __indirect_glColor4bv(const GLbyte *v) { }
109
 
void __indirect_glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) { }
110
 
void __indirect_glColor4dv(const GLdouble *v) { }
111
 
void __indirect_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { }
112
 
void __indirect_glColor4fv(const GLfloat *v) { }
113
 
void __indirect_glColor4i(GLint red, GLint green, GLint blue, GLint alpha) { }
114
 
void __indirect_glColor4iv(const GLint *v) { }
115
 
void __indirect_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha) { }
116
 
void __indirect_glColor4sv(const GLshort *v) { }
117
 
void __indirect_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) { }
118
 
void __indirect_glColor4ubv(const GLubyte *v) { }
119
 
void __indirect_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha) { }
120
 
void __indirect_glColor4uiv(const GLuint *v) { }
121
 
void __indirect_glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha) { }
122
 
void __indirect_glColor4usv(const GLushort *v) { }
123
 
void __indirect_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { }
124
 
void __indirect_glColorMaterial(GLenum face, GLenum mode) { }
125
 
void __indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) { }
126
 
void __indirect_glCullFace(GLenum mode) { }
127
 
void __indirect_glDeleteLists(GLuint list, GLsizei range) { }
128
 
void __indirect_glDepthFunc(GLenum func) { }
129
 
void __indirect_glDepthMask(GLboolean flag) { }
130
 
void __indirect_glDepthRange(GLclampd near_val, GLclampd far_val) { }
131
 
void __indirect_glDisable(GLenum cap) { }
132
 
void __indirect_glDrawBuffer(GLenum mode) { }
133
 
void __indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) { }
134
 
void __indirect_glEdgeFlag(GLboolean flag) { }
135
 
void __indirect_glEdgeFlagv(const GLboolean *flag) { }
136
 
void __indirect_glEnable(GLenum cap) { }
137
 
void __indirect_glEnd(void) { }
138
 
void __indirect_glEndList(void) { }
139
 
void __indirect_glEvalCoord1d(GLdouble u) { }
140
 
void __indirect_glEvalCoord1dv(const GLdouble *u) { }
141
 
void __indirect_glEvalCoord1f(GLfloat u) { }
142
 
void __indirect_glEvalCoord1fv(const GLfloat *u) { }
143
 
void __indirect_glEvalCoord2d(GLdouble u, GLdouble v) { }
144
 
void __indirect_glEvalCoord2dv(const GLdouble *u) { }
145
 
void __indirect_glEvalCoord2f(GLfloat u, GLfloat v) { }
146
 
void __indirect_glEvalCoord2fv(const GLfloat *u) { }
147
 
void __indirect_glEvalMesh1(GLenum mode, GLint i1, GLint i2) { }
148
 
void __indirect_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) { }
149
 
void __indirect_glEvalPoint1(GLint i) { }
150
 
void __indirect_glEvalPoint2(GLint i, GLint j) { }
151
 
void __indirect_glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer) { }
152
 
void __indirect_glFinish(void) { }
153
 
void __indirect_glFlush(void) { }
154
 
void __indirect_glFogf(GLenum pname, GLfloat param) { }
155
 
void __indirect_glFogfv(GLenum pname, const GLfloat *params) { }
156
 
void __indirect_glFogi(GLenum pname, GLint param) { }
157
 
void __indirect_glFogiv(GLenum pname, const GLint *params) { }
158
 
void __indirect_glFrontFace(GLenum mode) { }
159
 
void __indirect_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val) { }
160
 
void __indirect_glGenLists(GLsizei range) { }
161
 
void __indirect_glGetBooleanv(GLenum pname, GLboolean *params) { }
162
 
void __indirect_glGetClipPlane(GLenum plane, GLdouble *equation) { }
163
 
void __indirect_glGetDoublev(GLenum pname, GLdouble *params) { }
164
 
void __indirect_glGetError(void) { }
165
 
void __indirect_glGetFloatv(GLenum pname, GLfloat *params) { }
166
 
void __indirect_glGetIntegerv(GLenum pname, GLint *params) { }
167
 
void __indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat *params) { }
168
 
void __indirect_glGetLightiv(GLenum light, GLenum pname, GLint *params) { }
169
 
void __indirect_glGetMapdv(GLenum target, GLenum query, GLdouble *v) { }
170
 
void __indirect_glGetMapfv(GLenum target, GLenum query, GLfloat *v) { }
171
 
void __indirect_glGetMapiv(GLenum target, GLenum query, GLint *v) { }
172
 
void __indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) { }
173
 
void __indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint *params) { }
174
 
void __indirect_glGetPixelMapfv(GLenum map, GLfloat *values) { }
175
 
void __indirect_glGetPixelMapuiv(GLenum map, GLuint *values) { }
176
 
void __indirect_glGetPixelMapusv(GLenum map, GLushort *values) { }
177
 
void __indirect_glGetPolygonStipple(GLubyte *mask) { }
178
 
void __indirect_glGetString(GLenum name) { }
179
 
void __indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params) { }
180
 
void __indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint *params) { }
181
 
void __indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params) { }
182
 
void __indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params) { }
183
 
void __indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint *params) { }
184
 
void __indirect_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) { }
185
 
void __indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) { }
186
 
void __indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) { }
187
 
void __indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) { }
188
 
void __indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint *params) { }
189
 
void __indirect_glHint(GLenum target, GLenum mode) { }
190
 
void __indirect_glIndexMask(GLuint mask) { }
191
 
void __indirect_glIndexd(GLdouble c) { }
192
 
void __indirect_glIndexdv(const GLdouble *c) { }
193
 
void __indirect_glIndexf(GLfloat c) { }
194
 
void __indirect_glIndexfv(const GLfloat *c) { }
195
 
void __indirect_glIndexi(GLint c) { }
196
 
void __indirect_glIndexiv(const GLint *c) { }
197
 
void __indirect_glIndexs(GLshort c) { }
198
 
void __indirect_glIndexsv(const GLshort *c) { }
199
 
void __indirect_glInitNames(void) { }
200
 
void __indirect_glIsEnabled(GLenum cap) { }
201
 
void __indirect_glIsList(GLuint list) { }
202
 
void __indirect_glLightModelf(GLenum pname, GLfloat param) { }
203
 
void __indirect_glLightModelfv(GLenum pname, const GLfloat *params) { }
204
 
void __indirect_glLightModeli(GLenum pname, GLint param) { }
205
 
void __indirect_glLightModeliv(GLenum pname, const GLint *params) { }
206
 
void __indirect_glLightf(GLenum light, GLenum pname, GLfloat param) { }
207
 
void __indirect_glLightfv(GLenum light, GLenum pname, const GLfloat *params) { }
208
 
void __indirect_glLighti(GLenum light, GLenum pname, GLint param) { }
209
 
void __indirect_glLightiv(GLenum light, GLenum pname, const GLint *params) { }
210
 
void __indirect_glLineStipple(GLint factor, GLushort pattern) { }
211
 
void __indirect_glLineWidth(GLfloat width) { }
212
 
void __indirect_glListBase(GLuint base) { }
213
 
void __indirect_glLoadIdentity(void) { }
214
 
void __indirect_glLoadMatrixd(const GLdouble *m) { }
215
 
void __indirect_glLoadMatrixf(const GLfloat *m) { }
216
 
void __indirect_glLoadName(GLuint name) { }
217
 
void __indirect_glLogicOp(GLenum opcode) { }
218
 
void __indirect_glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points) { }
219
 
void __indirect_glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points) { }
220
 
void __indirect_glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points) { }
221
 
void __indirect_glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points) { }
222
 
void __indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2) { }
223
 
void __indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2) { }
224
 
void __indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) { }
225
 
void __indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) { }
226
 
void __indirect_glMaterialf(GLenum face, GLenum pname, GLfloat param) { }
227
 
void __indirect_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) { }
228
 
void __indirect_glMateriali(GLenum face, GLenum pname, GLint param) { }
229
 
void __indirect_glMaterialiv(GLenum face, GLenum pname, const GLint *params) { }
230
 
void __indirect_glMatrixMode(GLenum mode) { }
231
 
void __indirect_glMultMatrixd(const GLdouble *m) { }
232
 
void __indirect_glMultMatrixf(const GLfloat *m) { }
233
 
void __indirect_glNewList(GLuint list, GLenum mode) { }
234
 
void __indirect_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz) { }
235
 
void __indirect_glNormal3bv(const GLbyte *v) { }
236
 
void __indirect_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz) { }
237
 
void __indirect_glNormal3dv(const GLdouble *v) { }
238
 
void __indirect_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) { }
239
 
void __indirect_glNormal3fv(const GLfloat *v) { }
240
 
void __indirect_glNormal3i(GLint nx, GLint ny, GLint nz) { }
241
 
void __indirect_glNormal3iv(const GLint *v) { }
242
 
void __indirect_glNormal3s(GLshort nx, GLshort ny, GLshort nz) { }
243
 
void __indirect_glNormal3sv(const GLshort *v) { }
244
 
void __indirect_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val) { }
245
 
void __indirect_glPassThrough(GLfloat token) { }
246
 
void __indirect_glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values) { }
247
 
void __indirect_glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values) { }
248
 
void __indirect_glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values) { }
249
 
void __indirect_glPixelStoref(GLenum pname, GLfloat param) { }
250
 
void __indirect_glPixelStorei(GLenum pname, GLint param) { }
251
 
void __indirect_glPixelTransferf(GLenum pname, GLfloat param) { }
252
 
void __indirect_glPixelTransferi(GLenum pname, GLint param) { }
253
 
void __indirect_glPixelZoom(GLfloat xfactor, GLfloat yfactor) { }
254
 
void __indirect_glPointSize(GLfloat size) { }
255
 
void __indirect_glPolygonMode(GLenum face, GLenum mode) { }
256
 
void __indirect_glPolygonStipple(const GLubyte *mask) { }
257
 
void __indirect_glPopAttrib(void) { }
258
 
void __indirect_glPopMatrix(void) { }
259
 
void __indirect_glPopName(void) { }
260
 
void __indirect_glPushAttrib(GLbitfield mask) { }
261
 
void __indirect_glPushMatrix(void) { }
262
 
void __indirect_glPushName(GLuint name) { }
263
 
void __indirect_glRasterPos2d(GLdouble x, GLdouble y) { }
264
 
void __indirect_glRasterPos2dv(const GLdouble *v) { }
265
 
void __indirect_glRasterPos2f(GLfloat x, GLfloat y) { }
266
 
void __indirect_glRasterPos2fv(const GLfloat *v) { }
267
 
void __indirect_glRasterPos2i(GLint x, GLint y) { }
268
 
void __indirect_glRasterPos2iv(const GLint *v) { }
269
 
void __indirect_glRasterPos2s(GLshort x, GLshort y) { }
270
 
void __indirect_glRasterPos2sv(const GLshort *v) { }
271
 
void __indirect_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z) { }
272
 
void __indirect_glRasterPos3dv(const GLdouble *v) { }
273
 
void __indirect_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z) { }
274
 
void __indirect_glRasterPos3fv(const GLfloat *v) { }
275
 
void __indirect_glRasterPos3i(GLint x, GLint y, GLint z) { }
276
 
void __indirect_glRasterPos3iv(const GLint *v) { }
277
 
void __indirect_glRasterPos3s(GLshort x, GLshort y, GLshort z) { }
278
 
void __indirect_glRasterPos3sv(const GLshort *v) { }
279
 
void __indirect_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) { }
280
 
void __indirect_glRasterPos4dv(const GLdouble *v) { }
281
 
void __indirect_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) { }
282
 
void __indirect_glRasterPos4fv(const GLfloat *v) { }
283
 
void __indirect_glRasterPos4i(GLint x, GLint y, GLint z, GLint w) { }
284
 
void __indirect_glRasterPos4iv(const GLint *v) { }
285
 
void __indirect_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w) { }
286
 
void __indirect_glRasterPos4sv(const GLshort *v) { }
287
 
void __indirect_glReadBuffer(GLenum mode) { }
288
 
void __indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) { }
289
 
void __indirect_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) { }
290
 
void __indirect_glRectdv(const GLdouble *v1, const GLdouble *v2) { }
291
 
void __indirect_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) { }
292
 
void __indirect_glRectfv(const GLfloat *v1, const GLfloat *v2) { }
293
 
void __indirect_glRecti(GLint x1, GLint y1, GLint x2, GLint y2) { }
294
 
void __indirect_glRectiv(const GLint *v1, const GLint *v2) { }
295
 
void __indirect_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2) { }
296
 
void __indirect_glRectsv(const GLshort *v1, const GLshort *v2) { }
297
 
void __indirect_glRenderMode(GLenum mode) { }
298
 
void __indirect_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) { }
299
 
void __indirect_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { }
300
 
void __indirect_glScaled(GLdouble x, GLdouble y, GLdouble z) { }
301
 
void __indirect_glScalef(GLfloat x, GLfloat y, GLfloat z) { }
302
 
void __indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height) { }
303
 
void __indirect_glSelectBuffer(GLsizei size, GLuint *buffer) { }
304
 
void __indirect_glShadeModel(GLenum mode) { }
305
 
void __indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask) { }
306
 
void __indirect_glStencilMask(GLuint mask) { }
307
 
void __indirect_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) { }
308
 
void __indirect_glTexCoord1d(GLdouble s) { }
309
 
void __indirect_glTexCoord1dv(const GLdouble *v) { }
310
 
void __indirect_glTexCoord1f(GLfloat s) { }
311
 
void __indirect_glTexCoord1fv(const GLfloat *v) { }
312
 
void __indirect_glTexCoord1i(GLint s) { }
313
 
void __indirect_glTexCoord1iv(const GLint *v) { }
314
 
void __indirect_glTexCoord1s(GLshort s) { }
315
 
void __indirect_glTexCoord1sv(const GLshort *v) { }
316
 
void __indirect_glTexCoord2d(GLdouble s, GLdouble t) { }
317
 
void __indirect_glTexCoord2dv(const GLdouble *v) { }
318
 
void __indirect_glTexCoord2f(GLfloat s, GLfloat t) { }
319
 
void __indirect_glTexCoord2fv(const GLfloat *v) { }
320
 
void __indirect_glTexCoord2i(GLint s, GLint t) { }
321
 
void __indirect_glTexCoord2iv(const GLint *v) { }
322
 
void __indirect_glTexCoord2s(GLshort s, GLshort t) { }
323
 
void __indirect_glTexCoord2sv(const GLshort *v) { }
324
 
void __indirect_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r) { }
325
 
void __indirect_glTexCoord3dv(const GLdouble *v) { }
326
 
void __indirect_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r) { }
327
 
void __indirect_glTexCoord3fv(const GLfloat *v) { }
328
 
void __indirect_glTexCoord3i(GLint s, GLint t, GLint r) { }
329
 
void __indirect_glTexCoord3iv(const GLint *v) { }
330
 
void __indirect_glTexCoord3s(GLshort s, GLshort t, GLshort r) { }
331
 
void __indirect_glTexCoord3sv(const GLshort *v) { }
332
 
void __indirect_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q) { }
333
 
void __indirect_glTexCoord4dv(const GLdouble *v) { }
334
 
void __indirect_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) { }
335
 
void __indirect_glTexCoord4fv(const GLfloat *v) { }
336
 
void __indirect_glTexCoord4i(GLint s, GLint t, GLint r, GLint q) { }
337
 
void __indirect_glTexCoord4iv(const GLint *v) { }
338
 
void __indirect_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q) { }
339
 
void __indirect_glTexCoord4sv(const GLshort *v) { }
340
 
void __indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param) { }
341
 
void __indirect_glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) { }
342
 
void __indirect_glTexEnvi(GLenum target, GLenum pname, GLint param) { }
343
 
void __indirect_glTexEnviv(GLenum target, GLenum pname, const GLint *params) { }
344
 
void __indirect_glTexGend(GLenum coord, GLenum pname, GLdouble param) { }
345
 
void __indirect_glTexGendv(GLenum coord, GLenum pname, const GLdouble *params) { }
346
 
void __indirect_glTexGenf(GLenum coord, GLenum pname, GLfloat param) { }
347
 
void __indirect_glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params) { }
348
 
void __indirect_glTexGeni(GLenum coord, GLenum pname, GLint param) { }
349
 
void __indirect_glTexGeniv(GLenum coord, GLenum pname, const GLint *params) { }
350
 
void __indirect_glTexImage1D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { }
351
 
void __indirect_glTexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { }
352
 
void __indirect_glTexParameterf(GLenum target, GLenum pname, GLfloat param) { }
353
 
void __indirect_glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) { }
354
 
void __indirect_glTexParameteri(GLenum target, GLenum pname, GLint param) { }
355
 
void __indirect_glTexParameteriv(GLenum target, GLenum pname, const GLint *params) { }
356
 
void __indirect_glTranslated(GLdouble x, GLdouble y, GLdouble z) { }
357
 
void __indirect_glTranslatef(GLfloat x, GLfloat y, GLfloat z) { }
358
 
void __indirect_glVertex2d(GLdouble x, GLdouble y) { }
359
 
void __indirect_glVertex2dv(const GLdouble *v) { }
360
 
void __indirect_glVertex2f(GLfloat x, GLfloat y) { }
361
 
void __indirect_glVertex2fv(const GLfloat *v) { }
362
 
void __indirect_glVertex2i(GLint x, GLint y) { }
363
 
void __indirect_glVertex2iv(const GLint *v) { }
364
 
void __indirect_glVertex2s(GLshort x, GLshort y) { }
365
 
void __indirect_glVertex2sv(const GLshort *v) { }
366
 
void __indirect_glVertex3d(GLdouble x, GLdouble y, GLdouble z) { }
367
 
void __indirect_glVertex3dv(const GLdouble *v) { }
368
 
void __indirect_glVertex3f(GLfloat x, GLfloat y, GLfloat z) { }
369
 
void __indirect_glVertex3fv(const GLfloat *v) { }
370
 
void __indirect_glVertex3i(GLint x, GLint y, GLint z) { }
371
 
void __indirect_glVertex3iv(const GLint *v) { }
372
 
void __indirect_glVertex3s(GLshort x, GLshort y, GLshort z) { }
373
 
void __indirect_glVertex3sv(const GLshort *v) { }
374
 
void __indirect_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) { }
375
 
void __indirect_glVertex4dv(const GLdouble *v) { }
376
 
void __indirect_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) { }
377
 
void __indirect_glVertex4fv(const GLfloat *v) { }
378
 
void __indirect_glVertex4i(GLint x, GLint y, GLint z, GLint w) { }
379
 
void __indirect_glVertex4iv(const GLint *v) { }
380
 
void __indirect_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w) { }
381
 
void __indirect_glVertex4sv(const GLshort *v) { }
382
 
void __indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height) { }
383
 
void __indirect_glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences) { }
384
 
void __indirect_glArrayElement(GLint i) { }
385
 
void __indirect_glBindTexture(GLenum target, GLuint texture) { }
386
 
void __indirect_glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) { }
387
 
void __indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) { }
388
 
void __indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { }
389
 
void __indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) { }
390
 
void __indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { }
391
 
void __indirect_glDeleteTextures(GLsizei n, const GLuint *textures) { }
392
 
void __indirect_glDisableClientState(GLenum cap) { }
393
 
void __indirect_glDrawArrays(GLenum mode, GLint first, GLsizei count) { }
394
 
void __indirect_glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) { }
395
 
void __indirect_glEdgeFlagPointer(GLsizei stride, const GLvoid *ptr) { }
396
 
void __indirect_glEnableClientState(GLenum cap) { }
397
 
void __indirect_glGenTextures(GLsizei n, GLuint *textures) { }
398
 
void __indirect_glGetPointerv(GLenum pname, GLvoid **params) { }
399
 
void __indirect_glIndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr) { }
400
 
void __indirect_glIndexub(GLubyte c) { }
401
 
void __indirect_glIndexubv(const GLubyte *c) { }
402
 
void __indirect_glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer) { }
403
 
void __indirect_glIsTexture(GLuint texture) { }
404
 
void __indirect_glNormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr) { }
405
 
void __indirect_glPolygonOffset(GLfloat factor, GLfloat units) { }
406
 
void __indirect_glPopClientAttrib(void) { }
407
 
void __indirect_glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities) { }
408
 
void __indirect_glPushClientAttrib(GLbitfield mask) { }
409
 
void __indirect_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) { }
410
 
void __indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels) { }
411
 
void __indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) { }
412
 
void __indirect_glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) { }
413
 
void __indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { }
414
 
void __indirect_glBlendEquation(GLenum mode) { }
415
 
void __indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data) { }
416
 
void __indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table) { }
417
 
void __indirect_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params) { }
418
 
void __indirect_glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params) { }
419
 
void __indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image) { }
420
 
void __indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image) { }
421
 
void __indirect_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params) { }
422
 
void __indirect_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params) { }
423
 
void __indirect_glConvolutionParameteri(GLenum target, GLenum pname, GLint params) { }
424
 
void __indirect_glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params) { }
425
 
void __indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) { }
426
 
void __indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) { }
427
 
void __indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) { }
428
 
void __indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) { }
429
 
void __indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { }
430
 
void __indirect_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) { }
431
 
void __indirect_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table) { }
432
 
void __indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params) { }
433
 
void __indirect_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params) { }
434
 
void __indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image) { }
435
 
void __indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params) { }
436
 
void __indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params) { }
437
 
void __indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) { }
438
 
void __indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params) { }
439
 
void __indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params) { }
440
 
void __indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values) { }
441
 
void __indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params) { }
442
 
void __indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params) { }
443
 
void __indirect_glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span) { }
444
 
void __indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink) { }
445
 
void __indirect_glMinmax(GLenum target, GLenum internalformat, GLboolean sink) { }
446
 
void __indirect_glResetHistogram(GLenum target) { }
447
 
void __indirect_glResetMinmax(GLenum target) { }
448
 
void __indirect_glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column) { }
449
 
void __indirect_glTexImage3D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { }
450
 
void __indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) { }
451
 
void __indirect_glActiveTexture(GLenum texture) { }
452
 
void __indirect_glClientActiveTexture(GLenum texture) { }
453
 
void __indirect_glMultiTexCoord1d(GLenum target, GLdouble s) { }
454
 
void __indirect_glMultiTexCoord1dv(GLenum target, const GLdouble *v) { }
455
 
void __indirect_glMultiTexCoord1fARB(GLenum target, GLfloat s) { }
456
 
void __indirect_glMultiTexCoord1fvARB(GLenum target, const GLfloat *v) { }
457
 
void __indirect_glMultiTexCoord1i(GLenum target, GLint s) { }
458
 
void __indirect_glMultiTexCoord1iv(GLenum target, const GLint *v) { }
459
 
void __indirect_glMultiTexCoord1s(GLenum target, GLshort s) { }
460
 
void __indirect_glMultiTexCoord1sv(GLenum target, const GLshort *v) { }
461
 
void __indirect_glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t) { }
462
 
void __indirect_glMultiTexCoord2dv(GLenum target, const GLdouble *v) { }
463
 
void __indirect_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t) { }
464
 
void __indirect_glMultiTexCoord2fvARB(GLenum target, const GLfloat *v) { }
465
 
void __indirect_glMultiTexCoord2i(GLenum target, GLint s, GLint t) { }
466
 
void __indirect_glMultiTexCoord2iv(GLenum target, const GLint *v) { }
467
 
void __indirect_glMultiTexCoord2s(GLenum target, GLshort s, GLshort t) { }
468
 
void __indirect_glMultiTexCoord2sv(GLenum target, const GLshort *v) { }
469
 
void __indirect_glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r) { }
470
 
void __indirect_glMultiTexCoord3dv(GLenum target, const GLdouble *v) { }
471
 
void __indirect_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r) { }
472
 
void __indirect_glMultiTexCoord3fvARB(GLenum target, const GLfloat *v) { }
473
 
void __indirect_glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r) { }
474
 
void __indirect_glMultiTexCoord3iv(GLenum target, const GLint *v) { }
475
 
void __indirect_glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r) { }
476
 
void __indirect_glMultiTexCoord3sv(GLenum target, const GLshort *v) { }
477
 
void __indirect_glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) { }
478
 
void __indirect_glMultiTexCoord4dv(GLenum target, const GLdouble *v) { }
479
 
void __indirect_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) { }
480
 
void __indirect_glMultiTexCoord4fvARB(GLenum target, const GLfloat *v) { }
481
 
void __indirect_glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q) { }
482
 
void __indirect_glMultiTexCoord4iv(GLenum target, const GLint *v) { }
483
 
void __indirect_glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) { }
484
 
void __indirect_glMultiTexCoord4sv(GLenum target, const GLshort *v) { }
485
 
void __indirect_glLoadTransposeMatrixd(const GLdouble m[16]) { }
486
 
void __indirect_glLoadTransposeMatrixf(const GLfloat m[16]) { }
487
 
void __indirect_glMultTransposeMatrixd(const GLdouble m[16]) { }
488
 
void __indirect_glMultTransposeMatrixf(const GLfloat m[16]) { }
489
 
void __indirect_glSampleCoverage(GLclampf value, GLboolean invert) { }
490
 
void __indirect_glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data) { }
491
 
void __indirect_glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) { }
492
 
void __indirect_glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data) { }
493
 
void __indirect_glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data) { }
494
 
void __indirect_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) { }
495
 
void __indirect_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data) { }
496
 
void __indirect_glGetCompressedTexImage(GLenum target, GLint lod, GLvoid *img) { }
497
 
void __indirect_glDisableVertexAttribArray(GLuint index) { }
498
 
void __indirect_glEnableVertexAttribArray(GLuint index) { }
499
 
void __indirect_glGetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble *params) { }
500
 
void __indirect_glGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat *params) { }
501
 
void __indirect_glGetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble *params) { }
502
 
void __indirect_glGetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat *params) { }
503
 
void __indirect_glGetProgramStringARB(GLenum target, GLenum pname, void *string) { }
504
 
void __indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint *params) { }
505
 
void __indirect_glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params) { }
506
 
void __indirect_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params) { }
507
 
void __indirect_glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params) { }
508
 
void __indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { }
509
 
void __indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble *params) { }
510
 
void __indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { }
511
 
void __indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat *params) { }
512
 
void __indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { }
513
 
void __indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble *params) { }
514
 
void __indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { }
515
 
void __indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat *params) { }
516
 
void __indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len, const void *string) { }
517
 
void __indirect_glVertexAttrib1d(GLuint index, GLdouble x) { }
518
 
void __indirect_glVertexAttrib1dv(GLuint index, const GLdouble *v) { }
519
 
void __indirect_glVertexAttrib1fARB(GLuint index, GLfloat x) { }
520
 
void __indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat *v) { }
521
 
void __indirect_glVertexAttrib1s(GLuint index, GLshort x) { }
522
 
void __indirect_glVertexAttrib1sv(GLuint index, const GLshort *v) { }
523
 
void __indirect_glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y) { }
524
 
void __indirect_glVertexAttrib2dv(GLuint index, const GLdouble *v) { }
525
 
void __indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y) { }
526
 
void __indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat *v) { }
527
 
void __indirect_glVertexAttrib2s(GLuint index, GLshort x, GLshort y) { }
528
 
void __indirect_glVertexAttrib2sv(GLuint index, const GLshort *v) { }
529
 
void __indirect_glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z) { }
530
 
void __indirect_glVertexAttrib3dv(GLuint index, const GLdouble *v) { }
531
 
void __indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z) { }
532
 
void __indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat *v) { }
533
 
void __indirect_glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z) { }
534
 
void __indirect_glVertexAttrib3sv(GLuint index, const GLshort *v) { }
535
 
void __indirect_glVertexAttrib4Nbv(GLuint index, const GLbyte *v) { }
536
 
void __indirect_glVertexAttrib4Niv(GLuint index, const GLint *v) { }
537
 
void __indirect_glVertexAttrib4Nsv(GLuint index, const GLshort *v) { }
538
 
void __indirect_glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) { }
539
 
void __indirect_glVertexAttrib4Nubv(GLuint index, const GLubyte *v) { }
540
 
void __indirect_glVertexAttrib4Nuiv(GLuint index, const GLuint *v) { }
541
 
void __indirect_glVertexAttrib4Nusv(GLuint index, const GLushort *v) { }
542
 
void __indirect_glVertexAttrib4bv(GLuint index, const GLbyte *v) { }
543
 
void __indirect_glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { }
544
 
void __indirect_glVertexAttrib4dv(GLuint index, const GLdouble *v) { }
545
 
void __indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { }
546
 
void __indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat *v) { }
547
 
void __indirect_glVertexAttrib4iv(GLuint index, const GLint *v) { }
548
 
void __indirect_glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) { }
549
 
void __indirect_glVertexAttrib4sv(GLuint index, const GLshort *v) { }
550
 
void __indirect_glVertexAttrib4ubv(GLuint index, const GLubyte *v) { }
551
 
void __indirect_glVertexAttrib4uiv(GLuint index, const GLuint *v) { }
552
 
void __indirect_glVertexAttrib4usv(GLuint index, const GLushort *v) { }
553
 
void __indirect_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) { }
554
 
void __indirect_glBeginQuery(GLenum target, GLuint id) { }
555
 
void __indirect_glDeleteQueries(GLsizei n, const GLuint *ids) { }
556
 
void __indirect_glEndQuery(GLenum target) { }
557
 
void __indirect_glGenQueries(GLsizei n, GLuint *ids) { }
558
 
void __indirect_glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params) { }
559
 
void __indirect_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params) { }
560
 
void __indirect_glGetQueryiv(GLenum target, GLenum pname, GLint *params) { }
561
 
void __indirect_glIsQuery(GLuint id) { }
562
 
void __indirect_glDrawBuffers(GLsizei n, const GLenum *bufs) { }
563
 
void __indirect_glClampColor(GLenum target, GLenum clamp) { }
564
 
void __indirect_glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) { }
565
 
void __indirect_glSampleMaskSGIS(GLclampf value, GLboolean invert) { }
566
 
void __indirect_glSamplePatternSGIS(GLenum pattern) { }
567
 
void __indirect_glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer) { }
568
 
void __indirect_glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *pointer) { }
569
 
void __indirect_glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const void *pointer) { }
570
 
void __indirect_glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const void *pointer) { }
571
 
void __indirect_glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer) { }
572
 
void __indirect_glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer) { }
573
 
void __indirect_glPointParameterf(GLenum pname, GLfloat param) { }
574
 
void __indirect_glPointParameterfv(GLenum pname, const GLfloat *params) { }
575
 
void __indirect_glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue) { }
576
 
void __indirect_glSecondaryColor3bv(const GLbyte *v) { }
577
 
void __indirect_glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue) { }
578
 
void __indirect_glSecondaryColor3dv(const GLdouble *v) { }
579
 
void __indirect_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue) { }
580
 
void __indirect_glSecondaryColor3fvEXT(const GLfloat *v) { }
581
 
void __indirect_glSecondaryColor3i(GLint red, GLint green, GLint blue) { }
582
 
void __indirect_glSecondaryColor3iv(const GLint *v) { }
583
 
void __indirect_glSecondaryColor3s(GLshort red, GLshort green, GLshort blue) { }
584
 
void __indirect_glSecondaryColor3sv(const GLshort *v) { }
585
 
void __indirect_glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue) { }
586
 
void __indirect_glSecondaryColor3ubv(const GLubyte *v) { }
587
 
void __indirect_glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue) { }
588
 
void __indirect_glSecondaryColor3uiv(const GLuint *v) { }
589
 
void __indirect_glSecondaryColor3us(GLushort red, GLushort green, GLushort blue) { }
590
 
void __indirect_glSecondaryColor3usv(const GLushort *v) { }
591
 
void __indirect_glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) { }
592
 
void __indirect_glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount) { }
593
 
void __indirect_glMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei primcount) { }
594
 
void __indirect_glFogCoordPointer(GLenum type, GLsizei stride, const void *pointer) { }
595
 
void __indirect_glFogCoordd(GLdouble coord) { }
596
 
void __indirect_glFogCoorddv(const GLdouble *coord) { }
597
 
void __indirect_glFogCoordfEXT(GLfloat coord) { }
598
 
void __indirect_glFogCoordfvEXT(const GLfloat *coord) { }
599
 
void __indirect_glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) { }
600
 
void __indirect_glWindowPos2d(GLdouble x, GLdouble y) { }
601
 
void __indirect_glWindowPos2dv(const GLdouble *v) { }
602
 
void __indirect_glWindowPos2f(GLfloat x, GLfloat y) { }
603
 
void __indirect_glWindowPos2fv(const GLfloat *v) { }
604
 
void __indirect_glWindowPos2i(GLint x, GLint y) { }
605
 
void __indirect_glWindowPos2iv(const GLint *v) { }
606
 
void __indirect_glWindowPos2s(GLshort x, GLshort y) { }
607
 
void __indirect_glWindowPos2sv(const GLshort *v) { }
608
 
void __indirect_glWindowPos3d(GLdouble x, GLdouble y, GLdouble z) { }
609
 
void __indirect_glWindowPos3dv(const GLdouble *v) { }
610
 
void __indirect_glWindowPos3f(GLfloat x, GLfloat y, GLfloat z) { }
611
 
void __indirect_glWindowPos3fv(const GLfloat *v) { }
612
 
void __indirect_glWindowPos3i(GLint x, GLint y, GLint z) { }
613
 
void __indirect_glWindowPos3iv(const GLint *v) { }
614
 
void __indirect_glWindowPos3s(GLshort x, GLshort y, GLshort z) { }
615
 
void __indirect_glWindowPos3sv(const GLshort *v) { }
616
 
void __indirect_glAreProgramsResidentNV(GLsizei n, const GLuint *programs, GLboolean *residences) { }
617
 
void __indirect_glBindProgramARB(GLenum target, GLuint program) { }
618
 
void __indirect_glDeleteProgramsARB(GLsizei n, const GLuint *programs) { }
619
 
void __indirect_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params) { }
620
 
void __indirect_glGenProgramsARB(GLsizei n, GLuint *programs) { }
621
 
void __indirect_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble *params) { }
622
 
void __indirect_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat *params) { }
623
 
void __indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte *program) { }
624
 
void __indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint *params) { }
625
 
void __indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint *params) { }
626
 
void __indirect_glGetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer) { }
627
 
void __indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble *params) { }
628
 
void __indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat *params) { }
629
 
void __indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint *params) { }
630
 
void __indirect_glIsProgramARB(GLuint program) { }
631
 
void __indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte *program) { }
632
 
void __indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLsizei count, const GLdouble *v) { }
633
 
void __indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLsizei count, const GLfloat *v) { }
634
 
void __indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint *programs) { }
635
 
void __indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform) { }
636
 
void __indirect_glVertexAttrib1dNV(GLuint index, GLdouble x) { }
637
 
void __indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble *v) { }
638
 
void __indirect_glVertexAttrib1fNV(GLuint index, GLfloat x) { }
639
 
void __indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat *v) { }
640
 
void __indirect_glVertexAttrib1sNV(GLuint index, GLshort x) { }
641
 
void __indirect_glVertexAttrib1svNV(GLuint index, const GLshort *v) { }
642
 
void __indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y) { }
643
 
void __indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble *v) { }
644
 
void __indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y) { }
645
 
void __indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat *v) { }
646
 
void __indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y) { }
647
 
void __indirect_glVertexAttrib2svNV(GLuint index, const GLshort *v) { }
648
 
void __indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z) { }
649
 
void __indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble *v) { }
650
 
void __indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z) { }
651
 
void __indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat *v) { }
652
 
void __indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z) { }
653
 
void __indirect_glVertexAttrib3svNV(GLuint index, const GLshort *v) { }
654
 
void __indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { }
655
 
void __indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble *v) { }
656
 
void __indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { }
657
 
void __indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat *v) { }
658
 
void __indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) { }
659
 
void __indirect_glVertexAttrib4svNV(GLuint index, const GLshort *v) { }
660
 
void __indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) { }
661
 
void __indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte *v) { }
662
 
void __indirect_glVertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, const void *pointer) { }
663
 
void __indirect_glVertexAttribs1dvNV(GLuint index, GLsizei count, const GLdouble *v) { }
664
 
void __indirect_glVertexAttribs1fvNV(GLuint index, GLsizei count, const GLfloat *v) { }
665
 
void __indirect_glVertexAttribs1svNV(GLuint index, GLsizei count, const GLshort *v) { }
666
 
void __indirect_glVertexAttribs2dvNV(GLuint index, GLsizei count, const GLdouble *v) { }
667
 
void __indirect_glVertexAttribs2fvNV(GLuint index, GLsizei count, const GLfloat *v) { }
668
 
void __indirect_glVertexAttribs2svNV(GLuint index, GLsizei count, const GLshort *v) { }
669
 
void __indirect_glVertexAttribs3dvNV(GLuint index, GLsizei count, const GLdouble *v) { }
670
 
void __indirect_glVertexAttribs3fvNV(GLuint index, GLsizei count, const GLfloat *v) { }
671
 
void __indirect_glVertexAttribs3svNV(GLuint index, GLsizei count, const GLshort *v) { }
672
 
void __indirect_glVertexAttribs4dvNV(GLuint index, GLsizei count, const GLdouble *v) { }
673
 
void __indirect_glVertexAttribs4fvNV(GLuint index, GLsizei count, const GLfloat *v) { }
674
 
void __indirect_glVertexAttribs4svNV(GLuint index, GLsizei count, const GLshort *v) { }
675
 
void __indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei count, const GLubyte *v) { }
676
 
void __indirect_glPointParameteri(GLenum pname, GLint param) { }
677
 
void __indirect_glPointParameteriv(GLenum pname, const GLint *params) { }
678
 
void __indirect_glActiveStencilFaceEXT(GLenum face) { }
679
 
void __indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble *params) { }
680
 
void __indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat *params) { }
681
 
void __indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { }
682
 
void __indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v) { }
683
 
void __indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { }
684
 
void __indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v) { }
685
 
void __indirect_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) { }
686
 
void __indirect_glBindFramebufferEXT(GLenum target, GLuint framebuffer) { }
687
 
void __indirect_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer) { }
688
 
void __indirect_glBindFramebuffer(GLenum target, GLuint framebuffer) { }
689
 
void __indirect_glBindRenderbuffer(GLenum target, GLuint renderbuffer) { }
690
 
void __indirect_glCheckFramebufferStatus(GLenum target) { }
691
 
void __indirect_glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers) { }
692
 
void __indirect_glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers) { }
693
 
void __indirect_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { }
694
 
void __indirect_glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { }
695
 
void __indirect_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { }
696
 
void __indirect_glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) { }
697
 
void __indirect_glGenFramebuffers(GLsizei n, GLuint *framebuffers) { }
698
 
void __indirect_glGenRenderbuffers(GLsizei n, GLuint *renderbuffers) { }
699
 
void __indirect_glGenerateMipmap(GLenum target) { }
700
 
void __indirect_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) { }
701
 
void __indirect_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params) { }
702
 
void __indirect_glIsFramebuffer(GLuint framebuffer) { }
703
 
void __indirect_glIsRenderbuffer(GLuint renderbuffer) { }
704
 
void __indirect_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { }
705
 
void __indirect_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) { }
706
 
void __indirect_glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) { }
707
 
}
708
 
/*@}*/
709
 
 
710
 
#ifndef GLX_USE_APPLEGL
711
 
 
712
 
class IndirectAPI : public ::testing::Test {
713
 
public:
714
 
   virtual void SetUp();
715
 
   virtual void TearDown();
716
 
 
717
 
   _glapi_proc *table;
718
 
};
719
 
 
720
 
void
721
 
IndirectAPI::SetUp()
722
 
{
723
 
   this->table = (_glapi_proc *) __glXNewIndirectAPI();
724
 
}
725
 
 
726
 
void
727
 
IndirectAPI::TearDown()
728
 
{
729
 
   free(this->table);
730
 
   this->table = NULL;
731
 
}
732
 
 
733
 
TEST_F(IndirectAPI, DispatchTableSizeWasQueried)
734
 
{
735
 
   dispatch_table_size_was_queried = false;
736
 
 
737
 
   /* __glXNewIndirectAPI determines the size of the dispatch table by calling
738
 
    * _glapi_get_dispatch_table_size.  Our stub version of this function sets
739
 
    * a flag so that we can detect that __glXNewIndirectAPI called it.
740
 
    */
741
 
   EXPECT_FALSE(dispatch_table_size_was_queried);
742
 
   _glapi_table *table = __glXNewIndirectAPI();
743
 
   EXPECT_TRUE(dispatch_table_size_was_queried);
744
 
 
745
 
   /* Since a second dispatch table was created, it must be freed by hand.
746
 
    */
747
 
   free(table);
748
 
}
749
 
 
750
 
TEST_F(IndirectAPI, NoNullEntries)
751
 
{
752
 
   const unsigned entries = _glapi_get_dispatch_table_size();
753
 
 
754
 
   /* There should not be any NULL entries in the dispatch table.  All entires
755
 
    * should either point to a real implementation or to a no-op function.
756
 
    */
757
 
   for (unsigned i = 0; i < entries; i++) {
758
 
      EXPECT_NE(nil, table[i]);
759
 
   }
760
 
}
761
 
 
762
 
TEST_F(IndirectAPI, OpenGL_10)
763
 
{
764
 
   EXPECT_EQ((_glapi_proc) __indirect_glAccum, table[_gloffset_Accum]);
765
 
   EXPECT_EQ((_glapi_proc) __indirect_glAlphaFunc, table[_gloffset_AlphaFunc]);
766
 
   EXPECT_EQ((_glapi_proc) __indirect_glBegin, table[_gloffset_Begin]);
767
 
   EXPECT_EQ((_glapi_proc) __indirect_glBitmap, table[_gloffset_Bitmap]);
768
 
   EXPECT_EQ((_glapi_proc) __indirect_glBlendFunc, table[_gloffset_BlendFunc]);
769
 
   EXPECT_EQ((_glapi_proc) __indirect_glCallList, table[_gloffset_CallList]);
770
 
   EXPECT_EQ((_glapi_proc) __indirect_glCallLists, table[_gloffset_CallLists]);
771
 
   EXPECT_EQ((_glapi_proc) __indirect_glClear, table[_gloffset_Clear]);
772
 
   EXPECT_EQ((_glapi_proc) __indirect_glClearAccum, table[_gloffset_ClearAccum]);
773
 
   EXPECT_EQ((_glapi_proc) __indirect_glClearColor, table[_gloffset_ClearColor]);
774
 
   EXPECT_EQ((_glapi_proc) __indirect_glClearDepth, table[_gloffset_ClearDepth]);
775
 
   EXPECT_EQ((_glapi_proc) __indirect_glClearIndex, table[_gloffset_ClearIndex]);
776
 
   EXPECT_EQ((_glapi_proc) __indirect_glClearStencil, table[_gloffset_ClearStencil]);
777
 
   EXPECT_EQ((_glapi_proc) __indirect_glClipPlane, table[_gloffset_ClipPlane]);
778
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor3b, table[_gloffset_Color3b]);
779
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor3bv, table[_gloffset_Color3bv]);
780
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor3d, table[_gloffset_Color3d]);
781
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor3dv, table[_gloffset_Color3dv]);
782
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor3f, table[_gloffset_Color3f]);
783
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor3fv, table[_gloffset_Color3fv]);
784
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor3i, table[_gloffset_Color3i]);
785
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor3iv, table[_gloffset_Color3iv]);
786
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor3s, table[_gloffset_Color3s]);
787
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor3sv, table[_gloffset_Color3sv]);
788
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor3ub, table[_gloffset_Color3ub]);
789
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor3ubv, table[_gloffset_Color3ubv]);
790
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor3ui, table[_gloffset_Color3ui]);
791
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor3uiv, table[_gloffset_Color3uiv]);
792
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor3us, table[_gloffset_Color3us]);
793
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor3usv, table[_gloffset_Color3usv]);
794
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor4b, table[_gloffset_Color4b]);
795
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor4bv, table[_gloffset_Color4bv]);
796
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor4d, table[_gloffset_Color4d]);
797
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor4dv, table[_gloffset_Color4dv]);
798
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor4f, table[_gloffset_Color4f]);
799
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor4fv, table[_gloffset_Color4fv]);
800
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor4i, table[_gloffset_Color4i]);
801
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor4iv, table[_gloffset_Color4iv]);
802
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor4s, table[_gloffset_Color4s]);
803
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor4sv, table[_gloffset_Color4sv]);
804
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor4ub, table[_gloffset_Color4ub]);
805
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor4ubv, table[_gloffset_Color4ubv]);
806
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor4ui, table[_gloffset_Color4ui]);
807
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor4uiv, table[_gloffset_Color4uiv]);
808
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor4us, table[_gloffset_Color4us]);
809
 
   EXPECT_EQ((_glapi_proc) __indirect_glColor4usv, table[_gloffset_Color4usv]);
810
 
   EXPECT_EQ((_glapi_proc) __indirect_glColorMask, table[_gloffset_ColorMask]);
811
 
   EXPECT_EQ((_glapi_proc) __indirect_glColorMaterial, table[_gloffset_ColorMaterial]);
812
 
   EXPECT_EQ((_glapi_proc) __indirect_glCopyPixels, table[_gloffset_CopyPixels]);
813
 
   EXPECT_EQ((_glapi_proc) __indirect_glCullFace, table[_gloffset_CullFace]);
814
 
   EXPECT_EQ((_glapi_proc) __indirect_glDeleteLists, table[_gloffset_DeleteLists]);
815
 
   EXPECT_EQ((_glapi_proc) __indirect_glDepthFunc, table[_gloffset_DepthFunc]);
816
 
   EXPECT_EQ((_glapi_proc) __indirect_glDepthMask, table[_gloffset_DepthMask]);
817
 
   EXPECT_EQ((_glapi_proc) __indirect_glDepthRange, table[_gloffset_DepthRange]);
818
 
   EXPECT_EQ((_glapi_proc) __indirect_glDisable, table[_gloffset_Disable]);
819
 
   EXPECT_EQ((_glapi_proc) __indirect_glDrawBuffer, table[_gloffset_DrawBuffer]);
820
 
   EXPECT_EQ((_glapi_proc) __indirect_glDrawPixels, table[_gloffset_DrawPixels]);
821
 
   EXPECT_EQ((_glapi_proc) __indirect_glEdgeFlag, table[_gloffset_EdgeFlag]);
822
 
   EXPECT_EQ((_glapi_proc) __indirect_glEdgeFlagv, table[_gloffset_EdgeFlagv]);
823
 
   EXPECT_EQ((_glapi_proc) __indirect_glEnable, table[_gloffset_Enable]);
824
 
   EXPECT_EQ((_glapi_proc) __indirect_glEnd, table[_gloffset_End]);
825
 
   EXPECT_EQ((_glapi_proc) __indirect_glEndList, table[_gloffset_EndList]);
826
 
   EXPECT_EQ((_glapi_proc) __indirect_glEvalCoord1d, table[_gloffset_EvalCoord1d]);
827
 
   EXPECT_EQ((_glapi_proc) __indirect_glEvalCoord1dv, table[_gloffset_EvalCoord1dv]);
828
 
   EXPECT_EQ((_glapi_proc) __indirect_glEvalCoord1f, table[_gloffset_EvalCoord1f]);
829
 
   EXPECT_EQ((_glapi_proc) __indirect_glEvalCoord1fv, table[_gloffset_EvalCoord1fv]);
830
 
   EXPECT_EQ((_glapi_proc) __indirect_glEvalCoord2d, table[_gloffset_EvalCoord2d]);
831
 
   EXPECT_EQ((_glapi_proc) __indirect_glEvalCoord2dv, table[_gloffset_EvalCoord2dv]);
832
 
   EXPECT_EQ((_glapi_proc) __indirect_glEvalCoord2f, table[_gloffset_EvalCoord2f]);
833
 
   EXPECT_EQ((_glapi_proc) __indirect_glEvalCoord2fv, table[_gloffset_EvalCoord2fv]);
834
 
   EXPECT_EQ((_glapi_proc) __indirect_glEvalMesh1, table[_gloffset_EvalMesh1]);
835
 
   EXPECT_EQ((_glapi_proc) __indirect_glEvalMesh2, table[_gloffset_EvalMesh2]);
836
 
   EXPECT_EQ((_glapi_proc) __indirect_glEvalPoint1, table[_gloffset_EvalPoint1]);
837
 
   EXPECT_EQ((_glapi_proc) __indirect_glEvalPoint2, table[_gloffset_EvalPoint2]);
838
 
   EXPECT_EQ((_glapi_proc) __indirect_glFeedbackBuffer, table[_gloffset_FeedbackBuffer]);
839
 
   EXPECT_EQ((_glapi_proc) __indirect_glFinish, table[_gloffset_Finish]);
840
 
   EXPECT_EQ((_glapi_proc) __indirect_glFlush, table[_gloffset_Flush]);
841
 
   EXPECT_EQ((_glapi_proc) __indirect_glFogf, table[_gloffset_Fogf]);
842
 
   EXPECT_EQ((_glapi_proc) __indirect_glFogfv, table[_gloffset_Fogfv]);
843
 
   EXPECT_EQ((_glapi_proc) __indirect_glFogi, table[_gloffset_Fogi]);
844
 
   EXPECT_EQ((_glapi_proc) __indirect_glFogiv, table[_gloffset_Fogiv]);
845
 
   EXPECT_EQ((_glapi_proc) __indirect_glFrontFace, table[_gloffset_FrontFace]);
846
 
   EXPECT_EQ((_glapi_proc) __indirect_glFrustum, table[_gloffset_Frustum]);
847
 
   EXPECT_EQ((_glapi_proc) __indirect_glGenLists, table[_gloffset_GenLists]);
848
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetBooleanv, table[_gloffset_GetBooleanv]);
849
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetClipPlane, table[_gloffset_GetClipPlane]);
850
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetDoublev, table[_gloffset_GetDoublev]);
851
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetError, table[_gloffset_GetError]);
852
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetFloatv, table[_gloffset_GetFloatv]);
853
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetIntegerv, table[_gloffset_GetIntegerv]);
854
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetLightfv, table[_gloffset_GetLightfv]);
855
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetLightiv, table[_gloffset_GetLightiv]);
856
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetMapdv, table[_gloffset_GetMapdv]);
857
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetMapfv, table[_gloffset_GetMapfv]);
858
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetMapiv, table[_gloffset_GetMapiv]);
859
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetMaterialfv, table[_gloffset_GetMaterialfv]);
860
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetMaterialiv, table[_gloffset_GetMaterialiv]);
861
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetPixelMapfv, table[_gloffset_GetPixelMapfv]);
862
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetPixelMapuiv, table[_gloffset_GetPixelMapuiv]);
863
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetPixelMapusv, table[_gloffset_GetPixelMapusv]);
864
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetPolygonStipple, table[_gloffset_GetPolygonStipple]);
865
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetString, table[_gloffset_GetString]);
866
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetTexEnvfv, table[_gloffset_GetTexEnvfv]);
867
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetTexEnviv, table[_gloffset_GetTexEnviv]);
868
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetTexGendv, table[_gloffset_GetTexGendv]);
869
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetTexGenfv, table[_gloffset_GetTexGenfv]);
870
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetTexGeniv, table[_gloffset_GetTexGeniv]);
871
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetTexImage, table[_gloffset_GetTexImage]);
872
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetTexLevelParameterfv, table[_gloffset_GetTexLevelParameterfv]);
873
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetTexLevelParameteriv, table[_gloffset_GetTexLevelParameteriv]);
874
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetTexParameterfv, table[_gloffset_GetTexParameterfv]);
875
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetTexParameteriv, table[_gloffset_GetTexParameteriv]);
876
 
   EXPECT_EQ((_glapi_proc) __indirect_glHint, table[_gloffset_Hint]);
877
 
   EXPECT_EQ((_glapi_proc) __indirect_glIndexMask, table[_gloffset_IndexMask]);
878
 
   EXPECT_EQ((_glapi_proc) __indirect_glIndexd, table[_gloffset_Indexd]);
879
 
   EXPECT_EQ((_glapi_proc) __indirect_glIndexdv, table[_gloffset_Indexdv]);
880
 
   EXPECT_EQ((_glapi_proc) __indirect_glIndexf, table[_gloffset_Indexf]);
881
 
   EXPECT_EQ((_glapi_proc) __indirect_glIndexfv, table[_gloffset_Indexfv]);
882
 
   EXPECT_EQ((_glapi_proc) __indirect_glIndexi, table[_gloffset_Indexi]);
883
 
   EXPECT_EQ((_glapi_proc) __indirect_glIndexiv, table[_gloffset_Indexiv]);
884
 
   EXPECT_EQ((_glapi_proc) __indirect_glIndexs, table[_gloffset_Indexs]);
885
 
   EXPECT_EQ((_glapi_proc) __indirect_glIndexsv, table[_gloffset_Indexsv]);
886
 
   EXPECT_EQ((_glapi_proc) __indirect_glInitNames, table[_gloffset_InitNames]);
887
 
   EXPECT_EQ((_glapi_proc) __indirect_glIsEnabled, table[_gloffset_IsEnabled]);
888
 
   EXPECT_EQ((_glapi_proc) __indirect_glIsList, table[_gloffset_IsList]);
889
 
   EXPECT_EQ((_glapi_proc) __indirect_glLightModelf, table[_gloffset_LightModelf]);
890
 
   EXPECT_EQ((_glapi_proc) __indirect_glLightModelfv, table[_gloffset_LightModelfv]);
891
 
   EXPECT_EQ((_glapi_proc) __indirect_glLightModeli, table[_gloffset_LightModeli]);
892
 
   EXPECT_EQ((_glapi_proc) __indirect_glLightModeliv, table[_gloffset_LightModeliv]);
893
 
   EXPECT_EQ((_glapi_proc) __indirect_glLightf, table[_gloffset_Lightf]);
894
 
   EXPECT_EQ((_glapi_proc) __indirect_glLightfv, table[_gloffset_Lightfv]);
895
 
   EXPECT_EQ((_glapi_proc) __indirect_glLighti, table[_gloffset_Lighti]);
896
 
   EXPECT_EQ((_glapi_proc) __indirect_glLightiv, table[_gloffset_Lightiv]);
897
 
   EXPECT_EQ((_glapi_proc) __indirect_glLineStipple, table[_gloffset_LineStipple]);
898
 
   EXPECT_EQ((_glapi_proc) __indirect_glLineWidth, table[_gloffset_LineWidth]);
899
 
   EXPECT_EQ((_glapi_proc) __indirect_glListBase, table[_gloffset_ListBase]);
900
 
   EXPECT_EQ((_glapi_proc) __indirect_glLoadIdentity, table[_gloffset_LoadIdentity]);
901
 
   EXPECT_EQ((_glapi_proc) __indirect_glLoadMatrixd, table[_gloffset_LoadMatrixd]);
902
 
   EXPECT_EQ((_glapi_proc) __indirect_glLoadMatrixf, table[_gloffset_LoadMatrixf]);
903
 
   EXPECT_EQ((_glapi_proc) __indirect_glLoadName, table[_gloffset_LoadName]);
904
 
   EXPECT_EQ((_glapi_proc) __indirect_glLogicOp, table[_gloffset_LogicOp]);
905
 
   EXPECT_EQ((_glapi_proc) __indirect_glMap1d, table[_gloffset_Map1d]);
906
 
   EXPECT_EQ((_glapi_proc) __indirect_glMap1f, table[_gloffset_Map1f]);
907
 
   EXPECT_EQ((_glapi_proc) __indirect_glMap2d, table[_gloffset_Map2d]);
908
 
   EXPECT_EQ((_glapi_proc) __indirect_glMap2f, table[_gloffset_Map2f]);
909
 
   EXPECT_EQ((_glapi_proc) __indirect_glMapGrid1d, table[_gloffset_MapGrid1d]);
910
 
   EXPECT_EQ((_glapi_proc) __indirect_glMapGrid1f, table[_gloffset_MapGrid1f]);
911
 
   EXPECT_EQ((_glapi_proc) __indirect_glMapGrid2d, table[_gloffset_MapGrid2d]);
912
 
   EXPECT_EQ((_glapi_proc) __indirect_glMapGrid2f, table[_gloffset_MapGrid2f]);
913
 
   EXPECT_EQ((_glapi_proc) __indirect_glMaterialf, table[_gloffset_Materialf]);
914
 
   EXPECT_EQ((_glapi_proc) __indirect_glMaterialfv, table[_gloffset_Materialfv]);
915
 
   EXPECT_EQ((_glapi_proc) __indirect_glMateriali, table[_gloffset_Materiali]);
916
 
   EXPECT_EQ((_glapi_proc) __indirect_glMaterialiv, table[_gloffset_Materialiv]);
917
 
   EXPECT_EQ((_glapi_proc) __indirect_glMatrixMode, table[_gloffset_MatrixMode]);
918
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultMatrixd, table[_gloffset_MultMatrixd]);
919
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultMatrixf, table[_gloffset_MultMatrixf]);
920
 
   EXPECT_EQ((_glapi_proc) __indirect_glNewList, table[_gloffset_NewList]);
921
 
   EXPECT_EQ((_glapi_proc) __indirect_glNormal3b, table[_gloffset_Normal3b]);
922
 
   EXPECT_EQ((_glapi_proc) __indirect_glNormal3bv, table[_gloffset_Normal3bv]);
923
 
   EXPECT_EQ((_glapi_proc) __indirect_glNormal3d, table[_gloffset_Normal3d]);
924
 
   EXPECT_EQ((_glapi_proc) __indirect_glNormal3dv, table[_gloffset_Normal3dv]);
925
 
   EXPECT_EQ((_glapi_proc) __indirect_glNormal3f, table[_gloffset_Normal3f]);
926
 
   EXPECT_EQ((_glapi_proc) __indirect_glNormal3fv, table[_gloffset_Normal3fv]);
927
 
   EXPECT_EQ((_glapi_proc) __indirect_glNormal3i, table[_gloffset_Normal3i]);
928
 
   EXPECT_EQ((_glapi_proc) __indirect_glNormal3iv, table[_gloffset_Normal3iv]);
929
 
   EXPECT_EQ((_glapi_proc) __indirect_glNormal3s, table[_gloffset_Normal3s]);
930
 
   EXPECT_EQ((_glapi_proc) __indirect_glNormal3sv, table[_gloffset_Normal3sv]);
931
 
   EXPECT_EQ((_glapi_proc) __indirect_glOrtho, table[_gloffset_Ortho]);
932
 
   EXPECT_EQ((_glapi_proc) __indirect_glPassThrough, table[_gloffset_PassThrough]);
933
 
   EXPECT_EQ((_glapi_proc) __indirect_glPixelMapfv, table[_gloffset_PixelMapfv]);
934
 
   EXPECT_EQ((_glapi_proc) __indirect_glPixelMapuiv, table[_gloffset_PixelMapuiv]);
935
 
   EXPECT_EQ((_glapi_proc) __indirect_glPixelMapusv, table[_gloffset_PixelMapusv]);
936
 
   EXPECT_EQ((_glapi_proc) __indirect_glPixelStoref, table[_gloffset_PixelStoref]);
937
 
   EXPECT_EQ((_glapi_proc) __indirect_glPixelStorei, table[_gloffset_PixelStorei]);
938
 
   EXPECT_EQ((_glapi_proc) __indirect_glPixelTransferf, table[_gloffset_PixelTransferf]);
939
 
   EXPECT_EQ((_glapi_proc) __indirect_glPixelTransferi, table[_gloffset_PixelTransferi]);
940
 
   EXPECT_EQ((_glapi_proc) __indirect_glPixelZoom, table[_gloffset_PixelZoom]);
941
 
   EXPECT_EQ((_glapi_proc) __indirect_glPointSize, table[_gloffset_PointSize]);
942
 
   EXPECT_EQ((_glapi_proc) __indirect_glPolygonMode, table[_gloffset_PolygonMode]);
943
 
   EXPECT_EQ((_glapi_proc) __indirect_glPolygonStipple, table[_gloffset_PolygonStipple]);
944
 
   EXPECT_EQ((_glapi_proc) __indirect_glPopAttrib, table[_gloffset_PopAttrib]);
945
 
   EXPECT_EQ((_glapi_proc) __indirect_glPopMatrix, table[_gloffset_PopMatrix]);
946
 
   EXPECT_EQ((_glapi_proc) __indirect_glPopName, table[_gloffset_PopName]);
947
 
   EXPECT_EQ((_glapi_proc) __indirect_glPushAttrib, table[_gloffset_PushAttrib]);
948
 
   EXPECT_EQ((_glapi_proc) __indirect_glPushMatrix, table[_gloffset_PushMatrix]);
949
 
   EXPECT_EQ((_glapi_proc) __indirect_glPushName, table[_gloffset_PushName]);
950
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos2d, table[_gloffset_RasterPos2d]);
951
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos2dv, table[_gloffset_RasterPos2dv]);
952
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos2f, table[_gloffset_RasterPos2f]);
953
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos2fv, table[_gloffset_RasterPos2fv]);
954
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos2i, table[_gloffset_RasterPos2i]);
955
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos2iv, table[_gloffset_RasterPos2iv]);
956
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos2s, table[_gloffset_RasterPos2s]);
957
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos2sv, table[_gloffset_RasterPos2sv]);
958
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos3d, table[_gloffset_RasterPos3d]);
959
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos3dv, table[_gloffset_RasterPos3dv]);
960
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos3f, table[_gloffset_RasterPos3f]);
961
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos3fv, table[_gloffset_RasterPos3fv]);
962
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos3i, table[_gloffset_RasterPos3i]);
963
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos3iv, table[_gloffset_RasterPos3iv]);
964
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos3s, table[_gloffset_RasterPos3s]);
965
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos3sv, table[_gloffset_RasterPos3sv]);
966
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos4d, table[_gloffset_RasterPos4d]);
967
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos4dv, table[_gloffset_RasterPos4dv]);
968
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos4f, table[_gloffset_RasterPos4f]);
969
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos4fv, table[_gloffset_RasterPos4fv]);
970
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos4i, table[_gloffset_RasterPos4i]);
971
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos4iv, table[_gloffset_RasterPos4iv]);
972
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos4s, table[_gloffset_RasterPos4s]);
973
 
   EXPECT_EQ((_glapi_proc) __indirect_glRasterPos4sv, table[_gloffset_RasterPos4sv]);
974
 
   EXPECT_EQ((_glapi_proc) __indirect_glReadBuffer, table[_gloffset_ReadBuffer]);
975
 
   EXPECT_EQ((_glapi_proc) __indirect_glReadPixels, table[_gloffset_ReadPixels]);
976
 
   EXPECT_EQ((_glapi_proc) __indirect_glRectd, table[_gloffset_Rectd]);
977
 
   EXPECT_EQ((_glapi_proc) __indirect_glRectdv, table[_gloffset_Rectdv]);
978
 
   EXPECT_EQ((_glapi_proc) __indirect_glRectf, table[_gloffset_Rectf]);
979
 
   EXPECT_EQ((_glapi_proc) __indirect_glRectfv, table[_gloffset_Rectfv]);
980
 
   EXPECT_EQ((_glapi_proc) __indirect_glRecti, table[_gloffset_Recti]);
981
 
   EXPECT_EQ((_glapi_proc) __indirect_glRectiv, table[_gloffset_Rectiv]);
982
 
   EXPECT_EQ((_glapi_proc) __indirect_glRects, table[_gloffset_Rects]);
983
 
   EXPECT_EQ((_glapi_proc) __indirect_glRectsv, table[_gloffset_Rectsv]);
984
 
   EXPECT_EQ((_glapi_proc) __indirect_glRenderMode, table[_gloffset_RenderMode]);
985
 
   EXPECT_EQ((_glapi_proc) __indirect_glRotated, table[_gloffset_Rotated]);
986
 
   EXPECT_EQ((_glapi_proc) __indirect_glRotatef, table[_gloffset_Rotatef]);
987
 
   EXPECT_EQ((_glapi_proc) __indirect_glScaled, table[_gloffset_Scaled]);
988
 
   EXPECT_EQ((_glapi_proc) __indirect_glScalef, table[_gloffset_Scalef]);
989
 
   EXPECT_EQ((_glapi_proc) __indirect_glScissor, table[_gloffset_Scissor]);
990
 
   EXPECT_EQ((_glapi_proc) __indirect_glSelectBuffer, table[_gloffset_SelectBuffer]);
991
 
   EXPECT_EQ((_glapi_proc) __indirect_glShadeModel, table[_gloffset_ShadeModel]);
992
 
   EXPECT_EQ((_glapi_proc) __indirect_glStencilFunc, table[_gloffset_StencilFunc]);
993
 
   EXPECT_EQ((_glapi_proc) __indirect_glStencilMask, table[_gloffset_StencilMask]);
994
 
   EXPECT_EQ((_glapi_proc) __indirect_glStencilOp, table[_gloffset_StencilOp]);
995
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord1d, table[_gloffset_TexCoord1d]);
996
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord1dv, table[_gloffset_TexCoord1dv]);
997
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord1f, table[_gloffset_TexCoord1f]);
998
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord1fv, table[_gloffset_TexCoord1fv]);
999
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord1i, table[_gloffset_TexCoord1i]);
1000
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord1iv, table[_gloffset_TexCoord1iv]);
1001
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord1s, table[_gloffset_TexCoord1s]);
1002
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord1sv, table[_gloffset_TexCoord1sv]);
1003
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord2d, table[_gloffset_TexCoord2d]);
1004
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord2dv, table[_gloffset_TexCoord2dv]);
1005
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord2f, table[_gloffset_TexCoord2f]);
1006
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord2fv, table[_gloffset_TexCoord2fv]);
1007
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord2i, table[_gloffset_TexCoord2i]);
1008
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord2iv, table[_gloffset_TexCoord2iv]);
1009
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord2s, table[_gloffset_TexCoord2s]);
1010
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord2sv, table[_gloffset_TexCoord2sv]);
1011
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord3d, table[_gloffset_TexCoord3d]);
1012
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord3dv, table[_gloffset_TexCoord3dv]);
1013
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord3f, table[_gloffset_TexCoord3f]);
1014
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord3fv, table[_gloffset_TexCoord3fv]);
1015
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord3i, table[_gloffset_TexCoord3i]);
1016
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord3iv, table[_gloffset_TexCoord3iv]);
1017
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord3s, table[_gloffset_TexCoord3s]);
1018
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord3sv, table[_gloffset_TexCoord3sv]);
1019
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord4d, table[_gloffset_TexCoord4d]);
1020
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord4dv, table[_gloffset_TexCoord4dv]);
1021
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord4f, table[_gloffset_TexCoord4f]);
1022
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord4fv, table[_gloffset_TexCoord4fv]);
1023
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord4i, table[_gloffset_TexCoord4i]);
1024
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord4iv, table[_gloffset_TexCoord4iv]);
1025
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord4s, table[_gloffset_TexCoord4s]);
1026
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoord4sv, table[_gloffset_TexCoord4sv]);
1027
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexEnvf, table[_gloffset_TexEnvf]);
1028
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexEnvfv, table[_gloffset_TexEnvfv]);
1029
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexEnvi, table[_gloffset_TexEnvi]);
1030
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexEnviv, table[_gloffset_TexEnviv]);
1031
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexGend, table[_gloffset_TexGend]);
1032
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexGendv, table[_gloffset_TexGendv]);
1033
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexGenf, table[_gloffset_TexGenf]);
1034
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexGenfv, table[_gloffset_TexGenfv]);
1035
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexGeni, table[_gloffset_TexGeni]);
1036
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexGeniv, table[_gloffset_TexGeniv]);
1037
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexImage1D, table[_gloffset_TexImage1D]);
1038
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexImage2D, table[_gloffset_TexImage2D]);
1039
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexParameterf, table[_gloffset_TexParameterf]);
1040
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexParameterfv, table[_gloffset_TexParameterfv]);
1041
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexParameteri, table[_gloffset_TexParameteri]);
1042
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexParameteriv, table[_gloffset_TexParameteriv]);
1043
 
   EXPECT_EQ((_glapi_proc) __indirect_glTranslated, table[_gloffset_Translated]);
1044
 
   EXPECT_EQ((_glapi_proc) __indirect_glTranslatef, table[_gloffset_Translatef]);
1045
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex2d, table[_gloffset_Vertex2d]);
1046
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex2dv, table[_gloffset_Vertex2dv]);
1047
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex2f, table[_gloffset_Vertex2f]);
1048
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex2fv, table[_gloffset_Vertex2fv]);
1049
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex2i, table[_gloffset_Vertex2i]);
1050
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex2iv, table[_gloffset_Vertex2iv]);
1051
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex2s, table[_gloffset_Vertex2s]);
1052
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex2sv, table[_gloffset_Vertex2sv]);
1053
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex3d, table[_gloffset_Vertex3d]);
1054
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex3dv, table[_gloffset_Vertex3dv]);
1055
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex3f, table[_gloffset_Vertex3f]);
1056
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex3fv, table[_gloffset_Vertex3fv]);
1057
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex3i, table[_gloffset_Vertex3i]);
1058
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex3iv, table[_gloffset_Vertex3iv]);
1059
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex3s, table[_gloffset_Vertex3s]);
1060
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex3sv, table[_gloffset_Vertex3sv]);
1061
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex4d, table[_gloffset_Vertex4d]);
1062
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex4dv, table[_gloffset_Vertex4dv]);
1063
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex4f, table[_gloffset_Vertex4f]);
1064
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex4fv, table[_gloffset_Vertex4fv]);
1065
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex4i, table[_gloffset_Vertex4i]);
1066
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex4iv, table[_gloffset_Vertex4iv]);
1067
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex4s, table[_gloffset_Vertex4s]);
1068
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertex4sv, table[_gloffset_Vertex4sv]);
1069
 
   EXPECT_EQ((_glapi_proc) __indirect_glViewport, table[_gloffset_Viewport]);
1070
 
}
1071
 
 
1072
 
TEST_F(IndirectAPI, OpenGL_11)
1073
 
{
1074
 
   EXPECT_EQ((_glapi_proc) __indirect_glAreTexturesResident, table[_gloffset_AreTexturesResident]);
1075
 
   EXPECT_EQ((_glapi_proc) __indirect_glArrayElement, table[_gloffset_ArrayElement]);
1076
 
   EXPECT_EQ((_glapi_proc) __indirect_glBindTexture, table[_gloffset_BindTexture]);
1077
 
   EXPECT_EQ((_glapi_proc) __indirect_glColorPointer, table[_gloffset_ColorPointer]);
1078
 
   EXPECT_EQ((_glapi_proc) __indirect_glCopyTexImage1D, table[_gloffset_CopyTexImage1D]);
1079
 
   EXPECT_EQ((_glapi_proc) __indirect_glCopyTexImage2D, table[_gloffset_CopyTexImage2D]);
1080
 
   EXPECT_EQ((_glapi_proc) __indirect_glCopyTexSubImage1D, table[_gloffset_CopyTexSubImage1D]);
1081
 
   EXPECT_EQ((_glapi_proc) __indirect_glCopyTexSubImage2D, table[_gloffset_CopyTexSubImage2D]);
1082
 
   EXPECT_EQ((_glapi_proc) __indirect_glDeleteTextures, table[_gloffset_DeleteTextures]);
1083
 
   EXPECT_EQ((_glapi_proc) __indirect_glDisableClientState, table[_gloffset_DisableClientState]);
1084
 
   EXPECT_EQ((_glapi_proc) __indirect_glDrawArrays, table[_gloffset_DrawArrays]);
1085
 
   EXPECT_EQ((_glapi_proc) __indirect_glDrawElements, table[_gloffset_DrawElements]);
1086
 
   EXPECT_EQ((_glapi_proc) __indirect_glEdgeFlagPointer, table[_gloffset_EdgeFlagPointer]);
1087
 
   EXPECT_EQ((_glapi_proc) __indirect_glEnableClientState, table[_gloffset_EnableClientState]);
1088
 
   EXPECT_EQ((_glapi_proc) __indirect_glGenTextures, table[_gloffset_GenTextures]);
1089
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetPointerv, table[_gloffset_GetPointerv]);
1090
 
   EXPECT_EQ((_glapi_proc) __indirect_glIndexPointer, table[_gloffset_IndexPointer]);
1091
 
   EXPECT_EQ((_glapi_proc) __indirect_glIndexub, table[_gloffset_Indexub]);
1092
 
   EXPECT_EQ((_glapi_proc) __indirect_glIndexubv, table[_gloffset_Indexubv]);
1093
 
   EXPECT_EQ((_glapi_proc) __indirect_glInterleavedArrays, table[_gloffset_InterleavedArrays]);
1094
 
   EXPECT_EQ((_glapi_proc) __indirect_glIsTexture, table[_gloffset_IsTexture]);
1095
 
   EXPECT_EQ((_glapi_proc) __indirect_glNormalPointer, table[_gloffset_NormalPointer]);
1096
 
   EXPECT_EQ((_glapi_proc) __indirect_glPolygonOffset, table[_gloffset_PolygonOffset]);
1097
 
   EXPECT_EQ((_glapi_proc) __indirect_glPopClientAttrib, table[_gloffset_PopClientAttrib]);
1098
 
   EXPECT_EQ((_glapi_proc) __indirect_glPrioritizeTextures, table[_gloffset_PrioritizeTextures]);
1099
 
   EXPECT_EQ((_glapi_proc) __indirect_glPushClientAttrib, table[_gloffset_PushClientAttrib]);
1100
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoordPointer, table[_gloffset_TexCoordPointer]);
1101
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexSubImage1D, table[_gloffset_TexSubImage1D]);
1102
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexSubImage2D, table[_gloffset_TexSubImage2D]);
1103
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexPointer, table[_gloffset_VertexPointer]);
1104
 
}
1105
 
 
1106
 
TEST_F(IndirectAPI, OpenGL_12)
1107
 
{
1108
 
   EXPECT_EQ((_glapi_proc) __indirect_glBlendColor, table[_gloffset_BlendColor]);
1109
 
   EXPECT_EQ((_glapi_proc) __indirect_glBlendEquation, table[_gloffset_BlendEquation]);
1110
 
   EXPECT_EQ((_glapi_proc) __indirect_glColorSubTable, table[_gloffset_ColorSubTable]);
1111
 
   EXPECT_EQ((_glapi_proc) __indirect_glColorTable, table[_gloffset_ColorTable]);
1112
 
   EXPECT_EQ((_glapi_proc) __indirect_glColorTableParameterfv, table[_gloffset_ColorTableParameterfv]);
1113
 
   EXPECT_EQ((_glapi_proc) __indirect_glColorTableParameteriv, table[_gloffset_ColorTableParameteriv]);
1114
 
   EXPECT_EQ((_glapi_proc) __indirect_glConvolutionFilter1D, table[_gloffset_ConvolutionFilter1D]);
1115
 
   EXPECT_EQ((_glapi_proc) __indirect_glConvolutionFilter2D, table[_gloffset_ConvolutionFilter2D]);
1116
 
   EXPECT_EQ((_glapi_proc) __indirect_glConvolutionParameterf, table[_gloffset_ConvolutionParameterf]);
1117
 
   EXPECT_EQ((_glapi_proc) __indirect_glConvolutionParameterfv, table[_gloffset_ConvolutionParameterfv]);
1118
 
   EXPECT_EQ((_glapi_proc) __indirect_glConvolutionParameteri, table[_gloffset_ConvolutionParameteri]);
1119
 
   EXPECT_EQ((_glapi_proc) __indirect_glConvolutionParameteriv, table[_gloffset_ConvolutionParameteriv]);
1120
 
   EXPECT_EQ((_glapi_proc) __indirect_glCopyColorSubTable, table[_gloffset_CopyColorSubTable]);
1121
 
   EXPECT_EQ((_glapi_proc) __indirect_glCopyColorTable, table[_gloffset_CopyColorTable]);
1122
 
   EXPECT_EQ((_glapi_proc) __indirect_glCopyConvolutionFilter1D, table[_gloffset_CopyConvolutionFilter1D]);
1123
 
   EXPECT_EQ((_glapi_proc) __indirect_glCopyConvolutionFilter2D, table[_gloffset_CopyConvolutionFilter2D]);
1124
 
   EXPECT_EQ((_glapi_proc) __indirect_glCopyTexSubImage3D, table[_gloffset_CopyTexSubImage3D]);
1125
 
   EXPECT_EQ((_glapi_proc) __indirect_glDrawRangeElements, table[_gloffset_DrawRangeElements]);
1126
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetColorTable, table[_gloffset_GetColorTable]);
1127
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetColorTableParameterfv, table[_gloffset_GetColorTableParameterfv]);
1128
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetColorTableParameteriv, table[_gloffset_GetColorTableParameteriv]);
1129
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetConvolutionFilter, table[_gloffset_GetConvolutionFilter]);
1130
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetConvolutionParameterfv, table[_gloffset_GetConvolutionParameterfv]);
1131
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetConvolutionParameteriv, table[_gloffset_GetConvolutionParameteriv]);
1132
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetHistogram, table[_gloffset_GetHistogram]);
1133
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetHistogramParameterfv, table[_gloffset_GetHistogramParameterfv]);
1134
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetHistogramParameteriv, table[_gloffset_GetHistogramParameteriv]);
1135
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetMinmax, table[_gloffset_GetMinmax]);
1136
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetMinmaxParameterfv, table[_gloffset_GetMinmaxParameterfv]);
1137
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetMinmaxParameteriv, table[_gloffset_GetMinmaxParameteriv]);
1138
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetSeparableFilter, table[_gloffset_GetSeparableFilter]);
1139
 
   EXPECT_EQ((_glapi_proc) __indirect_glHistogram, table[_gloffset_Histogram]);
1140
 
   EXPECT_EQ((_glapi_proc) __indirect_glMinmax, table[_gloffset_Minmax]);
1141
 
   EXPECT_EQ((_glapi_proc) __indirect_glResetHistogram, table[_gloffset_ResetHistogram]);
1142
 
   EXPECT_EQ((_glapi_proc) __indirect_glResetMinmax, table[_gloffset_ResetMinmax]);
1143
 
   EXPECT_EQ((_glapi_proc) __indirect_glSeparableFilter2D, table[_gloffset_SeparableFilter2D]);
1144
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexImage3D, table[_gloffset_TexImage3D]);
1145
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexSubImage3D, table[_gloffset_TexSubImage3D]);
1146
 
}
1147
 
 
1148
 
TEST_F(IndirectAPI, OpenGL_20_is_nop)
1149
 
{
1150
 
   _glapi_proc const nop = table[_gloffset_COUNT];
1151
 
 
1152
 
   EXPECT_EQ(nop, table[_glapi_get_proc_offset("glAttachShader")]);
1153
 
   EXPECT_EQ(nop, table[_glapi_get_proc_offset("glCreateProgram")]);
1154
 
   EXPECT_EQ(nop, table[_glapi_get_proc_offset("glCreateShader")]);
1155
 
   EXPECT_EQ(nop, table[_glapi_get_proc_offset("glDeleteProgram")]);
1156
 
   EXPECT_EQ(nop, table[_glapi_get_proc_offset("glDeleteShader")]);
1157
 
   EXPECT_EQ(nop, table[_glapi_get_proc_offset("glDetachShader")]);
1158
 
   EXPECT_EQ(nop, table[_glapi_get_proc_offset("glGetAttachedShaders")]);
1159
 
   EXPECT_EQ(nop, table[_glapi_get_proc_offset("glGetProgramInfoLog")]);
1160
 
   EXPECT_EQ(nop, table[_glapi_get_proc_offset("glGetProgramiv")]);
1161
 
   EXPECT_EQ(nop, table[_glapi_get_proc_offset("glGetShaderInfoLog")]);
1162
 
   EXPECT_EQ(nop, table[_glapi_get_proc_offset("glGetShaderiv")]);
1163
 
   EXPECT_EQ(nop, table[_glapi_get_proc_offset("glIsProgram")]);
1164
 
   EXPECT_EQ(nop, table[_glapi_get_proc_offset("glIsShader")]);
1165
 
   EXPECT_EQ(nop, table[_glapi_get_proc_offset("glStencilFuncSeparate")]);
1166
 
   EXPECT_EQ(nop, table[_glapi_get_proc_offset("glStencilMaskSeparate")]);
1167
 
   EXPECT_EQ(nop, table[_glapi_get_proc_offset("glStencilOpSeparate")]);
1168
 
}
1169
 
 
1170
 
TEST_F(IndirectAPI, ARB_multitexture)
1171
 
{
1172
 
   EXPECT_EQ((_glapi_proc) __indirect_glActiveTexture, table[_gloffset_ActiveTexture]);
1173
 
   EXPECT_EQ((_glapi_proc) __indirect_glClientActiveTexture, table[_gloffset_ClientActiveTexture]);
1174
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord1d, table[_gloffset_MultiTexCoord1d]);
1175
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord1dv, table[_gloffset_MultiTexCoord1dv]);
1176
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord1fARB, table[_gloffset_MultiTexCoord1fARB]);
1177
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord1fvARB, table[_gloffset_MultiTexCoord1fvARB]);
1178
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord1i, table[_gloffset_MultiTexCoord1i]);
1179
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord1iv, table[_gloffset_MultiTexCoord1iv]);
1180
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord1s, table[_gloffset_MultiTexCoord1s]);
1181
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord1sv, table[_gloffset_MultiTexCoord1sv]);
1182
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord2d, table[_gloffset_MultiTexCoord2d]);
1183
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord2dv, table[_gloffset_MultiTexCoord2dv]);
1184
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord2fARB, table[_gloffset_MultiTexCoord2fARB]);
1185
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord2fvARB, table[_gloffset_MultiTexCoord2fvARB]);
1186
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord2i, table[_gloffset_MultiTexCoord2i]);
1187
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord2iv, table[_gloffset_MultiTexCoord2iv]);
1188
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord2s, table[_gloffset_MultiTexCoord2s]);
1189
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord2sv, table[_gloffset_MultiTexCoord2sv]);
1190
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord3d, table[_gloffset_MultiTexCoord3d]);
1191
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord3dv, table[_gloffset_MultiTexCoord3dv]);
1192
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord3fARB, table[_gloffset_MultiTexCoord3fARB]);
1193
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord3fvARB, table[_gloffset_MultiTexCoord3fvARB]);
1194
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord3i, table[_gloffset_MultiTexCoord3i]);
1195
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord3iv, table[_gloffset_MultiTexCoord3iv]);
1196
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord3s, table[_gloffset_MultiTexCoord3s]);
1197
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord3sv, table[_gloffset_MultiTexCoord3sv]);
1198
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord4d, table[_gloffset_MultiTexCoord4d]);
1199
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord4dv, table[_gloffset_MultiTexCoord4dv]);
1200
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord4fARB, table[_gloffset_MultiTexCoord4fARB]);
1201
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord4fvARB, table[_gloffset_MultiTexCoord4fvARB]);
1202
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord4i, table[_gloffset_MultiTexCoord4i]);
1203
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord4iv, table[_gloffset_MultiTexCoord4iv]);
1204
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord4s, table[_gloffset_MultiTexCoord4s]);
1205
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiTexCoord4sv, table[_gloffset_MultiTexCoord4sv]);
1206
 
}
1207
 
 
1208
 
TEST_F(IndirectAPI, ARB_transpose_matrix)
1209
 
{
1210
 
   EXPECT_EQ((_glapi_proc) __indirect_glLoadTransposeMatrixd, table[_glapi_get_proc_offset("glLoadTransposeMatrixdARB")]);
1211
 
   EXPECT_EQ((_glapi_proc) __indirect_glLoadTransposeMatrixf, table[_glapi_get_proc_offset("glLoadTransposeMatrixfARB")]);
1212
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultTransposeMatrixd, table[_glapi_get_proc_offset("glMultTransposeMatrixdARB")]);
1213
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultTransposeMatrixf, table[_glapi_get_proc_offset("glMultTransposeMatrixfARB")]);
1214
 
}
1215
 
 
1216
 
TEST_F(IndirectAPI, ARB_multisample)
1217
 
{
1218
 
   EXPECT_EQ((_glapi_proc) __indirect_glSampleCoverage, table[_glapi_get_proc_offset("glSampleCoverageARB")]);
1219
 
}
1220
 
 
1221
 
TEST_F(IndirectAPI, ARB_texture_compression)
1222
 
{
1223
 
   EXPECT_EQ((_glapi_proc) __indirect_glCompressedTexImage1D, table[_glapi_get_proc_offset("glCompressedTexImage1DARB")]);
1224
 
   EXPECT_EQ((_glapi_proc) __indirect_glCompressedTexImage2D, table[_glapi_get_proc_offset("glCompressedTexImage2DARB")]);
1225
 
   EXPECT_EQ((_glapi_proc) __indirect_glCompressedTexImage3D, table[_glapi_get_proc_offset("glCompressedTexImage3DARB")]);
1226
 
   EXPECT_EQ((_glapi_proc) __indirect_glCompressedTexSubImage1D, table[_glapi_get_proc_offset("glCompressedTexSubImage1DARB")]);
1227
 
   EXPECT_EQ((_glapi_proc) __indirect_glCompressedTexSubImage2D, table[_glapi_get_proc_offset("glCompressedTexSubImage2DARB")]);
1228
 
   EXPECT_EQ((_glapi_proc) __indirect_glCompressedTexSubImage3D, table[_glapi_get_proc_offset("glCompressedTexSubImage3DARB")]);
1229
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetCompressedTexImage, table[_glapi_get_proc_offset("glGetCompressedTexImageARB")]);
1230
 
}
1231
 
 
1232
 
TEST_F(IndirectAPI, ARB_vertex_program)
1233
 
{
1234
 
   EXPECT_EQ((_glapi_proc) __indirect_glDisableVertexAttribArray, table[_glapi_get_proc_offset("glDisableVertexAttribArrayARB")]);
1235
 
   EXPECT_EQ((_glapi_proc) __indirect_glEnableVertexAttribArray, table[_glapi_get_proc_offset("glEnableVertexAttribArrayARB")]);
1236
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetProgramEnvParameterdvARB, table[_glapi_get_proc_offset("glGetProgramEnvParameterdvARB")]);
1237
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetProgramEnvParameterfvARB, table[_glapi_get_proc_offset("glGetProgramEnvParameterfvARB")]);
1238
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetProgramLocalParameterdvARB, table[_glapi_get_proc_offset("glGetProgramLocalParameterdvARB")]);
1239
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetProgramLocalParameterfvARB, table[_glapi_get_proc_offset("glGetProgramLocalParameterfvARB")]);
1240
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetProgramStringARB, table[_glapi_get_proc_offset("glGetProgramStringARB")]);
1241
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetProgramivARB, table[_glapi_get_proc_offset("glGetProgramivARB")]);
1242
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetVertexAttribdv, table[_glapi_get_proc_offset("glGetVertexAttribdvARB")]);
1243
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetVertexAttribfv, table[_glapi_get_proc_offset("glGetVertexAttribfvARB")]);
1244
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetVertexAttribiv, table[_glapi_get_proc_offset("glGetVertexAttribivARB")]);
1245
 
   EXPECT_EQ((_glapi_proc) __indirect_glProgramEnvParameter4dARB, table[_glapi_get_proc_offset("glProgramEnvParameter4dARB")]);
1246
 
   EXPECT_EQ((_glapi_proc) __indirect_glProgramEnvParameter4dvARB, table[_glapi_get_proc_offset("glProgramEnvParameter4dvARB")]);
1247
 
   EXPECT_EQ((_glapi_proc) __indirect_glProgramEnvParameter4fARB, table[_glapi_get_proc_offset("glProgramEnvParameter4fARB")]);
1248
 
   EXPECT_EQ((_glapi_proc) __indirect_glProgramEnvParameter4fvARB, table[_glapi_get_proc_offset("glProgramEnvParameter4fvARB")]);
1249
 
   EXPECT_EQ((_glapi_proc) __indirect_glProgramLocalParameter4dARB, table[_glapi_get_proc_offset("glProgramLocalParameter4dARB")]);
1250
 
   EXPECT_EQ((_glapi_proc) __indirect_glProgramLocalParameter4dvARB, table[_glapi_get_proc_offset("glProgramLocalParameter4dvARB")]);
1251
 
   EXPECT_EQ((_glapi_proc) __indirect_glProgramLocalParameter4fARB, table[_glapi_get_proc_offset("glProgramLocalParameter4fARB")]);
1252
 
   EXPECT_EQ((_glapi_proc) __indirect_glProgramLocalParameter4fvARB, table[_glapi_get_proc_offset("glProgramLocalParameter4fvARB")]);
1253
 
   EXPECT_EQ((_glapi_proc) __indirect_glProgramStringARB, table[_glapi_get_proc_offset("glProgramStringARB")]);
1254
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib1d, table[_glapi_get_proc_offset("glVertexAttrib1dARB")]);
1255
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib1dv, table[_glapi_get_proc_offset("glVertexAttrib1dvARB")]);
1256
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib1fARB, table[_glapi_get_proc_offset("glVertexAttrib1fARB")]);
1257
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib1fvARB, table[_glapi_get_proc_offset("glVertexAttrib1fvARB")]);
1258
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib1s, table[_glapi_get_proc_offset("glVertexAttrib1sARB")]);
1259
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib1sv, table[_glapi_get_proc_offset("glVertexAttrib1svARB")]);
1260
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib2d, table[_glapi_get_proc_offset("glVertexAttrib2dARB")]);
1261
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib2dv, table[_glapi_get_proc_offset("glVertexAttrib2dvARB")]);
1262
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib2fARB, table[_glapi_get_proc_offset("glVertexAttrib2fARB")]);
1263
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib2fvARB, table[_glapi_get_proc_offset("glVertexAttrib2fvARB")]);
1264
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib2s, table[_glapi_get_proc_offset("glVertexAttrib2sARB")]);
1265
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib2sv, table[_glapi_get_proc_offset("glVertexAttrib2svARB")]);
1266
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib3d, table[_glapi_get_proc_offset("glVertexAttrib3dARB")]);
1267
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib3dv, table[_glapi_get_proc_offset("glVertexAttrib3dvARB")]);
1268
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib3fARB, table[_glapi_get_proc_offset("glVertexAttrib3fARB")]);
1269
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib3fvARB, table[_glapi_get_proc_offset("glVertexAttrib3fvARB")]);
1270
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib3s, table[_glapi_get_proc_offset("glVertexAttrib3sARB")]);
1271
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib3sv, table[_glapi_get_proc_offset("glVertexAttrib3svARB")]);
1272
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4Nbv, table[_glapi_get_proc_offset("glVertexAttrib4NbvARB")]);
1273
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4Niv, table[_glapi_get_proc_offset("glVertexAttrib4NivARB")]);
1274
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4Nsv, table[_glapi_get_proc_offset("glVertexAttrib4NsvARB")]);
1275
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4Nub, table[_glapi_get_proc_offset("glVertexAttrib4NubARB")]);
1276
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4Nubv, table[_glapi_get_proc_offset("glVertexAttrib4NubvARB")]);
1277
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4Nuiv, table[_glapi_get_proc_offset("glVertexAttrib4NuivARB")]);
1278
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4Nusv, table[_glapi_get_proc_offset("glVertexAttrib4NusvARB")]);
1279
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4bv, table[_glapi_get_proc_offset("glVertexAttrib4bvARB")]);
1280
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4d, table[_glapi_get_proc_offset("glVertexAttrib4dARB")]);
1281
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4dv, table[_glapi_get_proc_offset("glVertexAttrib4dvARB")]);
1282
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4fARB, table[_glapi_get_proc_offset("glVertexAttrib4fARB")]);
1283
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4fvARB, table[_glapi_get_proc_offset("glVertexAttrib4fvARB")]);
1284
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4iv, table[_glapi_get_proc_offset("glVertexAttrib4ivARB")]);
1285
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4s, table[_glapi_get_proc_offset("glVertexAttrib4sARB")]);
1286
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4sv, table[_glapi_get_proc_offset("glVertexAttrib4svARB")]);
1287
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4ubv, table[_glapi_get_proc_offset("glVertexAttrib4ubvARB")]);
1288
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4uiv, table[_glapi_get_proc_offset("glVertexAttrib4uivARB")]);
1289
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4usv, table[_glapi_get_proc_offset("glVertexAttrib4usvARB")]);
1290
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttribPointer, table[_glapi_get_proc_offset("glVertexAttribPointerARB")]);
1291
 
}
1292
 
 
1293
 
TEST_F(IndirectAPI, ARB_occlusion_query)
1294
 
{
1295
 
   EXPECT_EQ((_glapi_proc) __indirect_glBeginQuery, table[_glapi_get_proc_offset("glBeginQueryARB")]);
1296
 
   EXPECT_EQ((_glapi_proc) __indirect_glDeleteQueries, table[_glapi_get_proc_offset("glDeleteQueriesARB")]);
1297
 
   EXPECT_EQ((_glapi_proc) __indirect_glEndQuery, table[_glapi_get_proc_offset("glEndQueryARB")]);
1298
 
   EXPECT_EQ((_glapi_proc) __indirect_glGenQueries, table[_glapi_get_proc_offset("glGenQueriesARB")]);
1299
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetQueryObjectiv, table[_glapi_get_proc_offset("glGetQueryObjectivARB")]);
1300
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetQueryObjectuiv, table[_glapi_get_proc_offset("glGetQueryObjectuivARB")]);
1301
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetQueryiv, table[_glapi_get_proc_offset("glGetQueryivARB")]);
1302
 
   EXPECT_EQ((_glapi_proc) __indirect_glIsQuery, table[_glapi_get_proc_offset("glIsQueryARB")]);
1303
 
}
1304
 
 
1305
 
TEST_F(IndirectAPI, ARB_draw_buffers)
1306
 
{
1307
 
   EXPECT_EQ((_glapi_proc) __indirect_glDrawBuffers, table[_glapi_get_proc_offset("glDrawBuffersARB")]);
1308
 
}
1309
 
 
1310
 
TEST_F(IndirectAPI, ARB_color_buffer_float)
1311
 
{
1312
 
   EXPECT_EQ((_glapi_proc) __indirect_glClampColor, table[_glapi_get_proc_offset("glClampColorARB")]);
1313
 
}
1314
 
 
1315
 
TEST_F(IndirectAPI, ARB_framebuffer_object)
1316
 
{
1317
 
   EXPECT_EQ((_glapi_proc) __indirect_glRenderbufferStorageMultisample, table[_glapi_get_proc_offset("glRenderbufferStorageMultisample")]);
1318
 
}
1319
 
 
1320
 
TEST_F(IndirectAPI, SGIS_multisample)
1321
 
{
1322
 
   EXPECT_EQ((_glapi_proc) __indirect_glSampleMaskSGIS, table[_glapi_get_proc_offset("glSampleMaskSGIS")]);
1323
 
   EXPECT_EQ((_glapi_proc) __indirect_glSamplePatternSGIS, table[_glapi_get_proc_offset("glSamplePatternSGIS")]);
1324
 
}
1325
 
 
1326
 
TEST_F(IndirectAPI, EXT_vertex_array)
1327
 
{
1328
 
   EXPECT_EQ((_glapi_proc) __indirect_glColorPointerEXT, table[_glapi_get_proc_offset("glColorPointerEXT")]);
1329
 
   EXPECT_EQ((_glapi_proc) __indirect_glEdgeFlagPointerEXT, table[_glapi_get_proc_offset("glEdgeFlagPointerEXT")]);
1330
 
   EXPECT_EQ((_glapi_proc) __indirect_glIndexPointerEXT, table[_glapi_get_proc_offset("glIndexPointerEXT")]);
1331
 
   EXPECT_EQ((_glapi_proc) __indirect_glNormalPointerEXT, table[_glapi_get_proc_offset("glNormalPointerEXT")]);
1332
 
   EXPECT_EQ((_glapi_proc) __indirect_glTexCoordPointerEXT, table[_glapi_get_proc_offset("glTexCoordPointerEXT")]);
1333
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexPointerEXT, table[_glapi_get_proc_offset("glVertexPointerEXT")]);
1334
 
}
1335
 
 
1336
 
TEST_F(IndirectAPI, EXT_point_parameters)
1337
 
{
1338
 
   EXPECT_EQ((_glapi_proc) __indirect_glPointParameterf, table[_glapi_get_proc_offset("glPointParameterfEXT")]);
1339
 
   EXPECT_EQ((_glapi_proc) __indirect_glPointParameterfv, table[_glapi_get_proc_offset("glPointParameterfvEXT")]);
1340
 
}
1341
 
 
1342
 
TEST_F(IndirectAPI, EXT_secondary_color)
1343
 
{
1344
 
   EXPECT_EQ((_glapi_proc) __indirect_glSecondaryColor3b, table[_glapi_get_proc_offset("glSecondaryColor3bEXT")]);
1345
 
   EXPECT_EQ((_glapi_proc) __indirect_glSecondaryColor3bv, table[_glapi_get_proc_offset("glSecondaryColor3bvEXT")]);
1346
 
   EXPECT_EQ((_glapi_proc) __indirect_glSecondaryColor3d, table[_glapi_get_proc_offset("glSecondaryColor3dEXT")]);
1347
 
   EXPECT_EQ((_glapi_proc) __indirect_glSecondaryColor3dv, table[_glapi_get_proc_offset("glSecondaryColor3dvEXT")]);
1348
 
   EXPECT_EQ((_glapi_proc) __indirect_glSecondaryColor3fEXT, table[_glapi_get_proc_offset("glSecondaryColor3fEXT")]);
1349
 
   EXPECT_EQ((_glapi_proc) __indirect_glSecondaryColor3fvEXT, table[_glapi_get_proc_offset("glSecondaryColor3fvEXT")]);
1350
 
   EXPECT_EQ((_glapi_proc) __indirect_glSecondaryColor3i, table[_glapi_get_proc_offset("glSecondaryColor3iEXT")]);
1351
 
   EXPECT_EQ((_glapi_proc) __indirect_glSecondaryColor3iv, table[_glapi_get_proc_offset("glSecondaryColor3ivEXT")]);
1352
 
   EXPECT_EQ((_glapi_proc) __indirect_glSecondaryColor3s, table[_glapi_get_proc_offset("glSecondaryColor3sEXT")]);
1353
 
   EXPECT_EQ((_glapi_proc) __indirect_glSecondaryColor3sv, table[_glapi_get_proc_offset("glSecondaryColor3svEXT")]);
1354
 
   EXPECT_EQ((_glapi_proc) __indirect_glSecondaryColor3ub, table[_glapi_get_proc_offset("glSecondaryColor3ubEXT")]);
1355
 
   EXPECT_EQ((_glapi_proc) __indirect_glSecondaryColor3ubv, table[_glapi_get_proc_offset("glSecondaryColor3ubvEXT")]);
1356
 
   EXPECT_EQ((_glapi_proc) __indirect_glSecondaryColor3ui, table[_glapi_get_proc_offset("glSecondaryColor3uiEXT")]);
1357
 
   EXPECT_EQ((_glapi_proc) __indirect_glSecondaryColor3uiv, table[_glapi_get_proc_offset("glSecondaryColor3uivEXT")]);
1358
 
   EXPECT_EQ((_glapi_proc) __indirect_glSecondaryColor3us, table[_glapi_get_proc_offset("glSecondaryColor3usEXT")]);
1359
 
   EXPECT_EQ((_glapi_proc) __indirect_glSecondaryColor3usv, table[_glapi_get_proc_offset("glSecondaryColor3usvEXT")]);
1360
 
   EXPECT_EQ((_glapi_proc) __indirect_glSecondaryColorPointer, table[_glapi_get_proc_offset("glSecondaryColorPointerEXT")]);
1361
 
}
1362
 
 
1363
 
TEST_F(IndirectAPI, EXT_multi_draw_arrays)
1364
 
{
1365
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiDrawArrays, table[_glapi_get_proc_offset("glMultiDrawArraysEXT")]);
1366
 
   EXPECT_EQ((_glapi_proc) __indirect_glMultiDrawElementsEXT, table[_glapi_get_proc_offset("glMultiDrawElementsEXT")]);
1367
 
}
1368
 
 
1369
 
TEST_F(IndirectAPI, EXT_fog_coord)
1370
 
{
1371
 
   EXPECT_EQ((_glapi_proc) __indirect_glFogCoordPointer, table[_glapi_get_proc_offset("glFogCoordPointerEXT")]);
1372
 
   EXPECT_EQ((_glapi_proc) __indirect_glFogCoordd, table[_glapi_get_proc_offset("glFogCoorddEXT")]);
1373
 
   EXPECT_EQ((_glapi_proc) __indirect_glFogCoorddv, table[_glapi_get_proc_offset("glFogCoorddvEXT")]);
1374
 
   EXPECT_EQ((_glapi_proc) __indirect_glFogCoordfEXT, table[_glapi_get_proc_offset("glFogCoordfEXT")]);
1375
 
   EXPECT_EQ((_glapi_proc) __indirect_glFogCoordfvEXT, table[_glapi_get_proc_offset("glFogCoordfvEXT")]);
1376
 
}
1377
 
 
1378
 
TEST_F(IndirectAPI, EXT_blend_func_separate)
1379
 
{
1380
 
   EXPECT_EQ((_glapi_proc) __indirect_glBlendFuncSeparate, table[_glapi_get_proc_offset("glBlendFuncSeparateEXT")]);
1381
 
}
1382
 
 
1383
 
TEST_F(IndirectAPI, MESA_window_pos)
1384
 
{
1385
 
   EXPECT_EQ((_glapi_proc) __indirect_glWindowPos2d, table[_glapi_get_proc_offset("glWindowPos2dMESA")]);
1386
 
   EXPECT_EQ((_glapi_proc) __indirect_glWindowPos2dv, table[_glapi_get_proc_offset("glWindowPos2dvMESA")]);
1387
 
   EXPECT_EQ((_glapi_proc) __indirect_glWindowPos2f, table[_glapi_get_proc_offset("glWindowPos2fMESA")]);
1388
 
   EXPECT_EQ((_glapi_proc) __indirect_glWindowPos2fv, table[_glapi_get_proc_offset("glWindowPos2fvMESA")]);
1389
 
   EXPECT_EQ((_glapi_proc) __indirect_glWindowPos2i, table[_glapi_get_proc_offset("glWindowPos2iMESA")]);
1390
 
   EXPECT_EQ((_glapi_proc) __indirect_glWindowPos2iv, table[_glapi_get_proc_offset("glWindowPos2ivMESA")]);
1391
 
   EXPECT_EQ((_glapi_proc) __indirect_glWindowPos2s, table[_glapi_get_proc_offset("glWindowPos2sMESA")]);
1392
 
   EXPECT_EQ((_glapi_proc) __indirect_glWindowPos2sv, table[_glapi_get_proc_offset("glWindowPos2svMESA")]);
1393
 
   EXPECT_EQ((_glapi_proc) __indirect_glWindowPos3d, table[_glapi_get_proc_offset("glWindowPos3dMESA")]);
1394
 
   EXPECT_EQ((_glapi_proc) __indirect_glWindowPos3dv, table[_glapi_get_proc_offset("glWindowPos3dvMESA")]);
1395
 
   EXPECT_EQ((_glapi_proc) __indirect_glWindowPos3f, table[_glapi_get_proc_offset("glWindowPos3fMESA")]);
1396
 
   EXPECT_EQ((_glapi_proc) __indirect_glWindowPos3fv, table[_glapi_get_proc_offset("glWindowPos3fvMESA")]);
1397
 
   EXPECT_EQ((_glapi_proc) __indirect_glWindowPos3i, table[_glapi_get_proc_offset("glWindowPos3iMESA")]);
1398
 
   EXPECT_EQ((_glapi_proc) __indirect_glWindowPos3iv, table[_glapi_get_proc_offset("glWindowPos3ivMESA")]);
1399
 
   EXPECT_EQ((_glapi_proc) __indirect_glWindowPos3s, table[_glapi_get_proc_offset("glWindowPos3sMESA")]);
1400
 
   EXPECT_EQ((_glapi_proc) __indirect_glWindowPos3sv, table[_glapi_get_proc_offset("glWindowPos3svMESA")]);
1401
 
}
1402
 
 
1403
 
TEST_F(IndirectAPI, NV_vertex_program)
1404
 
{
1405
 
   EXPECT_EQ((_glapi_proc) __indirect_glAreProgramsResidentNV, table[_glapi_get_proc_offset("glAreProgramsResidentNV")]);
1406
 
   EXPECT_EQ((_glapi_proc) __indirect_glBindProgramARB, table[_glapi_get_proc_offset("glBindProgramNV")]);
1407
 
   EXPECT_EQ((_glapi_proc) __indirect_glDeleteProgramsARB, table[_glapi_get_proc_offset("glDeleteProgramsNV")]);
1408
 
   EXPECT_EQ((_glapi_proc) __indirect_glExecuteProgramNV, table[_glapi_get_proc_offset("glExecuteProgramNV")]);
1409
 
   EXPECT_EQ((_glapi_proc) __indirect_glGenProgramsARB, table[_glapi_get_proc_offset("glGenProgramsNV")]);
1410
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetProgramParameterdvNV, table[_glapi_get_proc_offset("glGetProgramParameterdvNV")]);
1411
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetProgramParameterfvNV, table[_glapi_get_proc_offset("glGetProgramParameterfvNV")]);
1412
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetProgramStringNV, table[_glapi_get_proc_offset("glGetProgramStringNV")]);
1413
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetProgramivNV, table[_glapi_get_proc_offset("glGetProgramivNV")]);
1414
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetTrackMatrixivNV, table[_glapi_get_proc_offset("glGetTrackMatrixivNV")]);
1415
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetVertexAttribPointerv, table[_glapi_get_proc_offset("glGetVertexAttribPointervNV")]);
1416
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetVertexAttribdvNV, table[_glapi_get_proc_offset("glGetVertexAttribdvNV")]);
1417
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetVertexAttribfvNV, table[_glapi_get_proc_offset("glGetVertexAttribfvNV")]);
1418
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetVertexAttribivNV, table[_glapi_get_proc_offset("glGetVertexAttribivNV")]);
1419
 
   EXPECT_EQ((_glapi_proc) __indirect_glIsProgramARB, table[_glapi_get_proc_offset("glIsProgramNV")]);
1420
 
   EXPECT_EQ((_glapi_proc) __indirect_glLoadProgramNV, table[_glapi_get_proc_offset("glLoadProgramNV")]);
1421
 
   EXPECT_EQ((_glapi_proc) __indirect_glProgramParameters4dvNV, table[_glapi_get_proc_offset("glProgramParameters4dvNV")]);
1422
 
   EXPECT_EQ((_glapi_proc) __indirect_glProgramParameters4fvNV, table[_glapi_get_proc_offset("glProgramParameters4fvNV")]);
1423
 
   EXPECT_EQ((_glapi_proc) __indirect_glRequestResidentProgramsNV, table[_glapi_get_proc_offset("glRequestResidentProgramsNV")]);
1424
 
   EXPECT_EQ((_glapi_proc) __indirect_glTrackMatrixNV, table[_glapi_get_proc_offset("glTrackMatrixNV")]);
1425
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib1dNV, table[_glapi_get_proc_offset("glVertexAttrib1dNV")]);
1426
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib1dvNV, table[_glapi_get_proc_offset("glVertexAttrib1dvNV")]);
1427
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib1fNV, table[_glapi_get_proc_offset("glVertexAttrib1fNV")]);
1428
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib1fvNV, table[_glapi_get_proc_offset("glVertexAttrib1fvNV")]);
1429
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib1sNV, table[_glapi_get_proc_offset("glVertexAttrib1sNV")]);
1430
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib1svNV, table[_glapi_get_proc_offset("glVertexAttrib1svNV")]);
1431
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib2dNV, table[_glapi_get_proc_offset("glVertexAttrib2dNV")]);
1432
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib2dvNV, table[_glapi_get_proc_offset("glVertexAttrib2dvNV")]);
1433
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib2fNV, table[_glapi_get_proc_offset("glVertexAttrib2fNV")]);
1434
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib2fvNV, table[_glapi_get_proc_offset("glVertexAttrib2fvNV")]);
1435
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib2sNV, table[_glapi_get_proc_offset("glVertexAttrib2sNV")]);
1436
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib2svNV, table[_glapi_get_proc_offset("glVertexAttrib2svNV")]);
1437
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib3dNV, table[_glapi_get_proc_offset("glVertexAttrib3dNV")]);
1438
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib3dvNV, table[_glapi_get_proc_offset("glVertexAttrib3dvNV")]);
1439
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib3fNV, table[_glapi_get_proc_offset("glVertexAttrib3fNV")]);
1440
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib3fvNV, table[_glapi_get_proc_offset("glVertexAttrib3fvNV")]);
1441
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib3sNV, table[_glapi_get_proc_offset("glVertexAttrib3sNV")]);
1442
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib3svNV, table[_glapi_get_proc_offset("glVertexAttrib3svNV")]);
1443
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4dNV, table[_glapi_get_proc_offset("glVertexAttrib4dNV")]);
1444
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4dvNV, table[_glapi_get_proc_offset("glVertexAttrib4dvNV")]);
1445
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4fNV, table[_glapi_get_proc_offset("glVertexAttrib4fNV")]);
1446
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4fvNV, table[_glapi_get_proc_offset("glVertexAttrib4fvNV")]);
1447
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4sNV, table[_glapi_get_proc_offset("glVertexAttrib4sNV")]);
1448
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4svNV, table[_glapi_get_proc_offset("glVertexAttrib4svNV")]);
1449
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4ubNV, table[_glapi_get_proc_offset("glVertexAttrib4ubNV")]);
1450
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttrib4ubvNV, table[_glapi_get_proc_offset("glVertexAttrib4ubvNV")]);
1451
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttribPointerNV, table[_glapi_get_proc_offset("glVertexAttribPointerNV")]);
1452
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttribs1dvNV, table[_glapi_get_proc_offset("glVertexAttribs1dvNV")]);
1453
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttribs1fvNV, table[_glapi_get_proc_offset("glVertexAttribs1fvNV")]);
1454
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttribs1svNV, table[_glapi_get_proc_offset("glVertexAttribs1svNV")]);
1455
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttribs2dvNV, table[_glapi_get_proc_offset("glVertexAttribs2dvNV")]);
1456
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttribs2fvNV, table[_glapi_get_proc_offset("glVertexAttribs2fvNV")]);
1457
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttribs2svNV, table[_glapi_get_proc_offset("glVertexAttribs2svNV")]);
1458
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttribs3dvNV, table[_glapi_get_proc_offset("glVertexAttribs3dvNV")]);
1459
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttribs3fvNV, table[_glapi_get_proc_offset("glVertexAttribs3fvNV")]);
1460
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttribs3svNV, table[_glapi_get_proc_offset("glVertexAttribs3svNV")]);
1461
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttribs4dvNV, table[_glapi_get_proc_offset("glVertexAttribs4dvNV")]);
1462
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttribs4fvNV, table[_glapi_get_proc_offset("glVertexAttribs4fvNV")]);
1463
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttribs4svNV, table[_glapi_get_proc_offset("glVertexAttribs4svNV")]);
1464
 
   EXPECT_EQ((_glapi_proc) __indirect_glVertexAttribs4ubvNV, table[_glapi_get_proc_offset("glVertexAttribs4ubvNV")]);
1465
 
}
1466
 
 
1467
 
TEST_F(IndirectAPI, NV_point_sprite)
1468
 
{
1469
 
   EXPECT_EQ((_glapi_proc) __indirect_glPointParameteri, table[_glapi_get_proc_offset("glPointParameteriNV")]);
1470
 
   EXPECT_EQ((_glapi_proc) __indirect_glPointParameteriv, table[_glapi_get_proc_offset("glPointParameterivNV")]);
1471
 
}
1472
 
 
1473
 
TEST_F(IndirectAPI, EXT_stencil_two_side)
1474
 
{
1475
 
   EXPECT_EQ((_glapi_proc) __indirect_glActiveStencilFaceEXT, table[_glapi_get_proc_offset("glActiveStencilFaceEXT")]);
1476
 
}
1477
 
 
1478
 
TEST_F(IndirectAPI, NV_fragment_program)
1479
 
{
1480
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetProgramNamedParameterdvNV, table[_glapi_get_proc_offset("glGetProgramNamedParameterdvNV")]);
1481
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetProgramNamedParameterfvNV, table[_glapi_get_proc_offset("glGetProgramNamedParameterfvNV")]);
1482
 
   EXPECT_EQ((_glapi_proc) __indirect_glProgramNamedParameter4dNV, table[_glapi_get_proc_offset("glProgramNamedParameter4dNV")]);
1483
 
   EXPECT_EQ((_glapi_proc) __indirect_glProgramNamedParameter4dvNV, table[_glapi_get_proc_offset("glProgramNamedParameter4dvNV")]);
1484
 
   EXPECT_EQ((_glapi_proc) __indirect_glProgramNamedParameter4fNV, table[_glapi_get_proc_offset("glProgramNamedParameter4fNV")]);
1485
 
   EXPECT_EQ((_glapi_proc) __indirect_glProgramNamedParameter4fvNV, table[_glapi_get_proc_offset("glProgramNamedParameter4fvNV")]);
1486
 
}
1487
 
 
1488
 
TEST_F(IndirectAPI, EXT_blend_equation_separate)
1489
 
{
1490
 
   EXPECT_EQ((_glapi_proc) __indirect_glBlendEquationSeparate, table[_glapi_get_proc_offset("glBlendEquationSeparateEXT")]);
1491
 
}
1492
 
 
1493
 
TEST_F(IndirectAPI, EXT_framebuffer_object)
1494
 
{
1495
 
   EXPECT_EQ((_glapi_proc) __indirect_glBindFramebufferEXT, table[_glapi_get_proc_offset("glBindFramebufferEXT")]);
1496
 
   EXPECT_EQ((_glapi_proc) __indirect_glBindRenderbufferEXT, table[_glapi_get_proc_offset("glBindRenderbufferEXT")]);
1497
 
   EXPECT_EQ((_glapi_proc) __indirect_glBindFramebuffer, table[_glapi_get_proc_offset("glBindFramebuffer")]);
1498
 
   EXPECT_EQ((_glapi_proc) __indirect_glBindRenderbuffer, table[_glapi_get_proc_offset("glBindRenderbuffer")]);
1499
 
   EXPECT_EQ((_glapi_proc) __indirect_glCheckFramebufferStatus, table[_glapi_get_proc_offset("glCheckFramebufferStatusEXT")]);
1500
 
   EXPECT_EQ((_glapi_proc) __indirect_glDeleteFramebuffers, table[_glapi_get_proc_offset("glDeleteFramebuffersEXT")]);
1501
 
   EXPECT_EQ((_glapi_proc) __indirect_glDeleteRenderbuffers, table[_glapi_get_proc_offset("glDeleteRenderbuffersEXT")]);
1502
 
   EXPECT_EQ((_glapi_proc) __indirect_glFramebufferRenderbuffer, table[_glapi_get_proc_offset("glFramebufferRenderbufferEXT")]);
1503
 
   EXPECT_EQ((_glapi_proc) __indirect_glFramebufferTexture1D, table[_glapi_get_proc_offset("glFramebufferTexture1DEXT")]);
1504
 
   EXPECT_EQ((_glapi_proc) __indirect_glFramebufferTexture2D, table[_glapi_get_proc_offset("glFramebufferTexture2DEXT")]);
1505
 
   EXPECT_EQ((_glapi_proc) __indirect_glFramebufferTexture3D, table[_glapi_get_proc_offset("glFramebufferTexture3DEXT")]);
1506
 
   EXPECT_EQ((_glapi_proc) __indirect_glGenFramebuffers, table[_glapi_get_proc_offset("glGenFramebuffersEXT")]);
1507
 
   EXPECT_EQ((_glapi_proc) __indirect_glGenRenderbuffers, table[_glapi_get_proc_offset("glGenRenderbuffersEXT")]);
1508
 
   EXPECT_EQ((_glapi_proc) __indirect_glGenerateMipmap, table[_glapi_get_proc_offset("glGenerateMipmapEXT")]);
1509
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetFramebufferAttachmentParameteriv, table[_glapi_get_proc_offset("glGetFramebufferAttachmentParameterivEXT")]);
1510
 
   EXPECT_EQ((_glapi_proc) __indirect_glGetRenderbufferParameteriv, table[_glapi_get_proc_offset("glGetRenderbufferParameterivEXT")]);
1511
 
   EXPECT_EQ((_glapi_proc) __indirect_glIsFramebuffer, table[_glapi_get_proc_offset("glIsFramebufferEXT")]);
1512
 
   EXPECT_EQ((_glapi_proc) __indirect_glIsRenderbuffer, table[_glapi_get_proc_offset("glIsRenderbufferEXT")]);
1513
 
   EXPECT_EQ((_glapi_proc) __indirect_glRenderbufferStorage, table[_glapi_get_proc_offset("glRenderbufferStorageEXT")]);
1514
 
}
1515
 
 
1516
 
TEST_F(IndirectAPI, EXT_framebuffer_blit)
1517
 
{
1518
 
   EXPECT_EQ((_glapi_proc) __indirect_glBlitFramebuffer, table[_glapi_get_proc_offset("glBlitFramebufferEXT")]);
1519
 
}
1520
 
 
1521
 
TEST_F(IndirectAPI, EXT_texture_array)
1522
 
{
1523
 
   EXPECT_EQ((_glapi_proc) __indirect_glFramebufferTextureLayer, table[_glapi_get_proc_offset("glFramebufferTextureLayerEXT")]);
1524
 
}
1525
 
 
1526
 
#endif