progs/tests/getprocaddress.c - fp2-dev/platform/external/mesa3d - Gitiles

 /*
  * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */

 /*
  * Test that glXGetProcAddress works.
  */

 #define GLX_GLXEXT_PROTOTYPES

 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <GL/gl.h>
 #include <GL/glx.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>


 typedef void (*generic_func)();

 #define EQUAL(X, Y)  (fabs((X) - (Y)) < 0.001)

 /**
  * The following functions are used to check that the named OpenGL function
  * actually does what it's supposed to do.
  * The naming of these functions is signficant.  The getprocaddress.py script
  * scans this file and extracts these function names.
  */


 static GLboolean
 test_ActiveTextureARB(generic_func func)
 {
    PFNGLACTIVETEXTUREARBPROC activeTexture = (PFNGLACTIVETEXTUREARBPROC) func;
    GLint t;
    GLboolean pass;
    (*activeTexture)(GL_TEXTURE1_ARB);
    glGetIntegerv(GL_ACTIVE_TEXTURE_ARB, &t);
    pass = (t == GL_TEXTURE1_ARB);
    (*activeTexture)(GL_TEXTURE0_ARB);  /* restore default */
    return pass;
 }


 static GLboolean
 test_SecondaryColor3fEXT(generic_func func)
 {
    PFNGLSECONDARYCOLOR3FEXTPROC secColor3f = (PFNGLSECONDARYCOLOR3FEXTPROC) func;
    GLfloat color[4];
    GLboolean pass;
    (*secColor3f)(1.0, 1.0, 0.0);
    glGetFloatv(GL_CURRENT_SECONDARY_COLOR_EXT, color);
    pass = (color[0] == 1.0 && color[1] == 1.0 && color[2] == 0.0);
    (*secColor3f)(0.0, 0.0, 0.0);  /* restore default */
    return pass;
 }


 static GLboolean
 test_ActiveStencilFaceEXT(generic_func func)
 {
    PFNGLACTIVESTENCILFACEEXTPROC activeFace = (PFNGLACTIVESTENCILFACEEXTPROC) func;
    GLint face;
    GLboolean pass;
    (*activeFace)(GL_BACK);
    glGetIntegerv(GL_ACTIVE_STENCIL_FACE_EXT, &face);
    pass = (face == GL_BACK);
    (*activeFace)(GL_FRONT);  /* restore default */
    return pass;
 }


 static GLboolean
 test_VertexAttrib1fvARB(generic_func func)
 {
    PFNGLVERTEXATTRIB1FVARBPROC vertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC) func;
    PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB");

    const GLfloat v[1] = {25.0};
    const GLfloat def[1] = {0};
    GLfloat res[4];
    GLboolean pass;
    (*vertexAttrib1fvARB)(6, v);
    (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res);
    pass = (res[0] == 25.0 && res[1] == 0.0 && res[2] == 0.0 && res[3] == 1.0);
    (*vertexAttrib1fvARB)(6, def);
    return pass;
 }

 static GLboolean
 test_VertexAttrib4NubvARB(generic_func func)
 {
    PFNGLVERTEXATTRIB4NUBVARBPROC vertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC) func;
    PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB");

    const GLubyte v[4] = {255, 0, 255, 0};
    const GLubyte def[4] = {0, 0, 0, 255};
    GLfloat res[4];
    GLboolean pass;
    (*vertexAttrib4NubvARB)(6, v);
    (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res);
    pass = (res[0] == 1.0 && res[1] == 0.0 && res[2] == 1.0 && res[3] == 0.0);
    (*vertexAttrib4NubvARB)(6, def);
    return pass;
 }


 static GLboolean
 test_VertexAttrib4NuivARB(generic_func func)
 {
    PFNGLVERTEXATTRIB4NUIVARBPROC vertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC) func;
    PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB");

    const GLuint v[4] = {0xffffffff, 0, 0xffffffff, 0};
    const GLuint def[4] = {0, 0, 0, 0xffffffff};
    GLfloat res[4];
    GLboolean pass;
    (*vertexAttrib4NuivARB)(6, v);
    (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res);
    pass = (EQUAL(res[0], 1.0) && EQUAL(res[1], 0.0) && EQUAL(res[2], 1.0) && EQUAL(res[3], 0.0));
    (*vertexAttrib4NuivARB)(6, def);
    return pass;
 }


 static GLboolean
 test_VertexAttrib4ivARB(generic_func func)
 {
    PFNGLVERTEXATTRIB4IVARBPROC vertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC) func;
    PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB");

    const GLint v[4] = {1, 2, -3, 4};
    const GLint def[4] = {0, 0, 0, 1};
    GLfloat res[4];
    GLboolean pass;
    (*vertexAttrib4ivARB)(6, v);
    (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res);
    pass = (EQUAL(res[0], 1.0) && EQUAL(res[1], 2.0) && EQUAL(res[2], -3.0) && EQUAL(res[3], 4.0));
    (*vertexAttrib4ivARB)(6, def);
    return pass;
 }


 static GLboolean
 test_VertexAttrib4NsvARB(generic_func func)
 {
    PFNGLVERTEXATTRIB4NSVARBPROC vertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC) func;
    PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB");

    const GLshort v[4] = {0, 32767, 32767, 0};
    const GLshort def[4] = {0, 0, 0, 32767};
    GLfloat res[4];
    GLboolean pass;
    (*vertexAttrib4NsvARB)(6, v);
    (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res);
    pass = (EQUAL(res[0], 0.0) && EQUAL(res[1], 1.0) && EQUAL(res[2], 1.0) && EQUAL(res[3], 0.0));
    (*vertexAttrib4NsvARB)(6, def);
    return pass;
 }


 static GLboolean
 test_VertexAttrib4NusvARB(generic_func func)
 {
    PFNGLVERTEXATTRIB4NUSVARBPROC vertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC) func;
    PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB");

    const GLushort v[4] = {0xffff, 0, 0xffff, 0};
    const GLushort def[4] = {0, 0, 0, 0xffff};
    GLfloat res[4];
    GLboolean pass;
    (*vertexAttrib4NusvARB)(6, v);
    (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res);
    pass = (EQUAL(res[0], 1.0) && EQUAL(res[1], 0.0) && EQUAL(res[2], 1.0) && EQUAL(res[3], 0.0));
    (*vertexAttrib4NusvARB)(6, def);
    return pass;
 }


 static GLboolean
 test_VertexAttrib4ubNV(generic_func func)
 {
    PFNGLVERTEXATTRIB4UBNVPROC vertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC) func;
    PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

    const GLubyte v[4] = {255, 0, 255, 0};
    const GLubyte def[4] = {0, 0, 0, 255};
    GLfloat res[4];
    GLboolean pass;
    (*vertexAttrib4ubNV)(6, v[0], v[1], v[2], v[3]);
    (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
    pass = (res[0] == 1.0 && res[1] == 0.0 && res[2] == 1.0 && res[3] == 0.0);
    (*vertexAttrib4ubNV)(6, def[0], def[1], def[2], def[3]);
    return pass;
 }


 static GLboolean
 test_VertexAttrib2sNV(generic_func func)
 {
    PFNGLVERTEXATTRIB2SNVPROC vertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC) func;
    PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

    const GLshort v[2] = {2, -4,};
    const GLshort def[2] = {0, 0};
    GLfloat res[4];
    GLboolean pass;
    (*vertexAttrib2sNV)(6, v[0], v[1]);
    (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
    pass = (EQUAL(res[0], 2) && EQUAL(res[1], -4) && EQUAL(res[2], 0) && res[3] == 1.0);
    (*vertexAttrib2sNV)(6, def[0], def[1]);
    return pass;
 }


 static GLboolean
 test_VertexAttrib3fNV(generic_func func)
 {
    PFNGLVERTEXATTRIB3FNVPROC vertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC) func;
    PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

    const GLfloat v[3] = {0.2, 0.4, 0.8};
    const GLfloat def[3] = {0, 0, 0};
    GLfloat res[4];
    GLboolean pass;
    (*vertexAttrib3fNV)(6, v[0], v[1], v[2]);
    (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
    pass = (EQUAL(res[0], 0.2) && EQUAL(res[1], 0.4) && EQUAL(res[2], 0.8) && res[3] == 1.0);
    (*vertexAttrib3fNV)(6, def[0], def[1], def[2]);
    return pass;
 }


 static GLboolean
 test_VertexAttrib4dvNV(generic_func func)
 {
    PFNGLVERTEXATTRIB4DVNVPROC vertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC) func;
    PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

    const GLdouble v[4] = {0.2, 0.4, 0.8, 1.2};
    const GLdouble def[4] = {0, 0, 0, 1};
    GLfloat res[4];
    GLboolean pass;
    (*vertexAttrib4dvNV)(6, v);
    (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
    pass = (EQUAL(res[0], 0.2) && EQUAL(res[1], 0.4) && EQUAL(res[2], 0.8) && EQUAL(res[3], 1.2));
    (*vertexAttrib4dvNV)(6, def);
    return pass;
 }


 static GLboolean
 test_StencilFuncSeparateATI(generic_func func)
 {
 #ifdef GL_ATI_separate_stencil
    PFNGLSTENCILFUNCSEPARATEATIPROC stencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC) func;
    GLint frontFunc, backFunc;
    GLint frontRef, backRef;
    GLint frontMask, backMask;
    (*stencilFuncSeparateATI)(GL_LESS, GL_GREATER, 2, 0xa);
    glGetIntegerv(GL_STENCIL_FUNC, &frontFunc);
    glGetIntegerv(GL_STENCIL_BACK_FUNC, &backFunc);
    glGetIntegerv(GL_STENCIL_REF, &frontRef);
    glGetIntegerv(GL_STENCIL_BACK_REF, &backRef);
    glGetIntegerv(GL_STENCIL_VALUE_MASK, &frontMask);
    glGetIntegerv(GL_STENCIL_BACK_VALUE_MASK, &backMask);
    if (frontFunc != GL_LESS ||
        backFunc != GL_GREATER ||
        frontRef != 2 ||
        backRef != 2 ||
        frontMask != 0xa ||
        backMask != 0xa)
       return GL_FALSE;
 #endif
    return GL_TRUE;
 }

 static GLboolean
 test_StencilFuncSeparate(generic_func func)
 {
 #ifdef GL_VERSION_2_0
    PFNGLSTENCILFUNCSEPARATEPROC stencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC) func;
    GLint frontFunc, backFunc;
    GLint frontRef, backRef;
    GLint frontMask, backMask;
    (*stencilFuncSeparate)(GL_BACK, GL_GREATER, 2, 0xa);
    glGetIntegerv(GL_STENCIL_FUNC, &frontFunc);
    glGetIntegerv(GL_STENCIL_BACK_FUNC, &backFunc);
    glGetIntegerv(GL_STENCIL_REF, &frontRef);
    glGetIntegerv(GL_STENCIL_BACK_REF, &backRef);
    glGetIntegerv(GL_STENCIL_VALUE_MASK, &frontMask);
    glGetIntegerv(GL_STENCIL_BACK_VALUE_MASK, &backMask);
    if (frontFunc != GL_ALWAYS ||
        backFunc != GL_GREATER ||
        frontRef != 0 ||
        backRef != 2 ||
        frontMask == 0xa || /* might be 0xff or ~0 */
        backMask != 0xa)
       return GL_FALSE;
 #endif
    return GL_TRUE;
 }

 static GLboolean
 test_StencilOpSeparate(generic_func func)
 {
 #ifdef GL_VERSION_2_0
    PFNGLSTENCILOPSEPARATEPROC stencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC) func;
    GLint frontFail, backFail;
    GLint frontZFail, backZFail;
    GLint frontZPass, backZPass;
    (*stencilOpSeparate)(GL_BACK, GL_INCR, GL_DECR, GL_INVERT);
    glGetIntegerv(GL_STENCIL_FAIL, &frontFail);
    glGetIntegerv(GL_STENCIL_BACK_FAIL, &backFail);
    glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &frontZFail);
    glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_FAIL, &backZFail);
    glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &frontZPass);
    glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_PASS, &backZPass);
    if (frontFail != GL_KEEP ||
        backFail != GL_INCR ||
        frontZFail != GL_KEEP ||
        backZFail != GL_DECR ||
        frontZPass != GL_KEEP ||
        backZPass != GL_INVERT)
       return GL_FALSE;
 #endif
    return GL_TRUE;
 }

 static GLboolean
 test_StencilMaskSeparate(generic_func func)
 {
 #ifdef GL_VERSION_2_0
    PFNGLSTENCILMASKSEPARATEPROC stencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC) func;
    GLint frontMask, backMask;
    (*stencilMaskSeparate)(GL_BACK, 0x1b);
    glGetIntegerv(GL_STENCIL_WRITEMASK, &frontMask);
    glGetIntegerv(GL_STENCIL_BACK_WRITEMASK, &backMask);
    if (frontMask == 0x1b ||
        backMask != 0x1b)
       return GL_FALSE;
 #endif
    return GL_TRUE;
 }


 /*
  * The following file is auto-generated with Python.
  */
 #include "getproclist.h"


 static int
 extension_supported(const char *haystack, const char *needle)
 {
    const char *p = strstr(haystack, needle);
    if (p) {
       /* found string, make sure next char is space or zero */
       const int len = strlen(needle);
       if (p[len] == ' ' || p[len] == 0)
          return 1;
       else
          return 0;
    }
    else
       return 0;
 }


 static void
 check_functions( const char *extensions )
 {
    struct name_test_pair *entry;
    int failures = 0, passes = 0;
    int totalFail = 0, totalPass = 0;
    int doTests;

    for (entry = functions; entry->name; entry++) {
       if (entry->name[0] == '-') {
          const char *version = (const char *) glGetString(GL_VERSION);
          if (entry->name[1] == '1') {
             /* check GL version 1.x */
             if (version[0] == '1' &&
                 version[1] == '.' &&
                 version[2] >= entry->name[3])
                doTests = 1;
             else
                doTests = 0;
          }
          else if (entry->name[1] == '2') {
             if (version[0] == '2' &&
                 version[1] == '.' &&
                 version[2] >= entry->name[3])
                doTests = 1;
             else
                doTests = 0;
          }
          else {
             /* check if the named extension is available */
             doTests = extension_supported(extensions, entry->name+1);
          }
          if (doTests)
             printf("Testing %s functions\n", entry->name + 1);
          totalFail += failures;
          totalPass += passes;
          failures = 0;
          passes = 0;
       }
       else if (doTests) {
          generic_func funcPtr = (generic_func) glXGetProcAddressARB((const GLubyte *) entry->name);
          if (funcPtr) {
             if (entry->test) {
                GLboolean b;
                printf("   Validating %s:", entry->name);
                b = (*entry->test)(funcPtr);
                if (b) {
                   printf(" Pass\n");
                   passes++;
                }
                else {
                   printf(" FAIL!!!\n");
                   failures++;
                }
             }
             else {
                passes++;
             }
          }
          else {
             printf("   glXGetProcAddress(%s) failed!\n", entry->name);
             failures++;
          }
       }

       if (doTests && (!(entry+1)->name || (entry+1)->name[0] == '-')) {
          if (failures > 0) {
             printf("   %d failed.\n", failures);
          }
          if (passes > 0) {
             printf("   %d passed.\n", passes);
          }
       }
    }
    totalFail += failures;
    totalPass += passes;

    printf("-----------------------------\n");
    printf("Total: %d pass  %d fail\n", totalPass, totalFail);
 }


 static void
 print_screen_info(Display *dpy, int scrnum, Bool allowDirect)
 {
    Window win;
    int attribSingle[] = {
       GLX_RGBA,
       GLX_RED_SIZE, 1,
       GLX_GREEN_SIZE, 1,
       GLX_BLUE_SIZE, 1,
       GLX_STENCIL_SIZE, 1,
       None };
    int attribDouble[] = {
       GLX_RGBA,
       GLX_RED_SIZE, 1,
       GLX_GREEN_SIZE, 1,
       GLX_BLUE_SIZE, 1,
       GLX_STENCIL_SIZE, 1,
       GLX_DOUBLEBUFFER,
       None };

    XSetWindowAttributes attr;
    unsigned long mask;
    Window root;
    GLXContext ctx;
    XVisualInfo *visinfo;
    int width = 100, height = 100;

    root = RootWindow(dpy, scrnum);

    visinfo = glXChooseVisual(dpy, scrnum, attribSingle);
    if (!visinfo) {
       visinfo = glXChooseVisual(dpy, scrnum, attribDouble);
       if (!visinfo) {
          fprintf(stderr, "Error: couldn't find RGB GLX visual\n");
          return;
       }
    }

    attr.background_pixel = 0;
    attr.border_pixel = 0;
    attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
    attr.event_mask = StructureNotifyMask | ExposureMask;
    mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
    win = XCreateWindow(dpy, root, 0, 0, width, height,
 		       0, visinfo->depth, InputOutput,
 		       visinfo->visual, mask, &attr);

    ctx = glXCreateContext( dpy, visinfo, NULL, allowDirect );
    if (!ctx) {
       fprintf(stderr, "Error: glXCreateContext failed\n");
       XDestroyWindow(dpy, win);
       return;
    }

    if (glXMakeCurrent(dpy, win, ctx)) {
       check_functions( (const char *) glGetString(GL_EXTENSIONS) );
    }
    else {
       fprintf(stderr, "Error: glXMakeCurrent failed\n");
    }

    glXDestroyContext(dpy, ctx);
    XDestroyWindow(dpy, win);
 }


 int
 main(int argc, char *argv[])
 {
    char *displayName = NULL;
    Display *dpy;

    dpy = XOpenDisplay(displayName);
    if (!dpy) {
       fprintf(stderr, "Error: unable to open display %s\n", displayName);
       return -1;
    }

    print_screen_info(dpy, 0, GL_TRUE);

    XCloseDisplay(dpy);

    return 0;
 }
	/*
	* Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
	*
	* Permission is hereby granted, free of charge, to any person obtaining a
	* copy of this software and associated documentation files (the "Software"),
	* to deal in the Software without restriction, including without limitation
	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	* and/or sell copies of the Software, and to permit persons to whom the
	* Software is furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice shall be included
	* in all copies or substantial portions of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
	* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	*/

	/*
	* Test that glXGetProcAddress works.
	*/

	#define GLX_GLXEXT_PROTOTYPES

	#include <X11/Xlib.h>
	#include <X11/Xutil.h>
	#include <GL/gl.h>
	#include <GL/glx.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <math.h>


	typedef void (*generic_func)();

	#define EQUAL(X, Y) (fabs((X) - (Y)) < 0.001)

	/**
	* The following functions are used to check that the named OpenGL function
	* actually does what it's supposed to do.
	* The naming of these functions is signficant. The getprocaddress.py script
	* scans this file and extracts these function names.
	*/


	static GLboolean
	test_ActiveTextureARB(generic_func func)
	{
	PFNGLACTIVETEXTUREARBPROC activeTexture = (PFNGLACTIVETEXTUREARBPROC) func;
	GLint t;
	GLboolean pass;
	(*activeTexture)(GL_TEXTURE1_ARB);
	glGetIntegerv(GL_ACTIVE_TEXTURE_ARB, &t);
	pass = (t == GL_TEXTURE1_ARB);
	(activeTexture)(GL_TEXTURE0_ARB); / restore default */
	return pass;
	}


	static GLboolean
	test_SecondaryColor3fEXT(generic_func func)
	{
	PFNGLSECONDARYCOLOR3FEXTPROC secColor3f = (PFNGLSECONDARYCOLOR3FEXTPROC) func;
	GLfloat color[4];
	GLboolean pass;
	(*secColor3f)(1.0, 1.0, 0.0);
	glGetFloatv(GL_CURRENT_SECONDARY_COLOR_EXT, color);
	pass = (color[0] == 1.0 && color[1] == 1.0 && color[2] == 0.0);
	(secColor3f)(0.0, 0.0, 0.0); / restore default */
	return pass;
	}


	static GLboolean
	test_ActiveStencilFaceEXT(generic_func func)
	{
	PFNGLACTIVESTENCILFACEEXTPROC activeFace = (PFNGLACTIVESTENCILFACEEXTPROC) func;
	GLint face;
	GLboolean pass;
	(*activeFace)(GL_BACK);
	glGetIntegerv(GL_ACTIVE_STENCIL_FACE_EXT, &face);
	pass = (face == GL_BACK);
	(activeFace)(GL_FRONT); / restore default */
	return pass;
	}


	static GLboolean
	test_VertexAttrib1fvARB(generic_func func)
	{
	PFNGLVERTEXATTRIB1FVARBPROC vertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC) func;
	PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB");

	const GLfloat v[1] = {25.0};
	const GLfloat def[1] = {0};
	GLfloat res[4];
	GLboolean pass;
	(*vertexAttrib1fvARB)(6, v);
	(*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res);
	pass = (res[0] == 25.0 && res[1] == 0.0 && res[2] == 0.0 && res[3] == 1.0);
	(*vertexAttrib1fvARB)(6, def);
	return pass;
	}

	static GLboolean
	test_VertexAttrib4NubvARB(generic_func func)
	{
	PFNGLVERTEXATTRIB4NUBVARBPROC vertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC) func;
	PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB");

	const GLubyte v[4] = {255, 0, 255, 0};
	const GLubyte def[4] = {0, 0, 0, 255};
	GLfloat res[4];
	GLboolean pass;
	(*vertexAttrib4NubvARB)(6, v);
	(*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res);
	pass = (res[0] == 1.0 && res[1] == 0.0 && res[2] == 1.0 && res[3] == 0.0);
	(*vertexAttrib4NubvARB)(6, def);
	return pass;
	}


	static GLboolean
	test_VertexAttrib4NuivARB(generic_func func)
	{
	PFNGLVERTEXATTRIB4NUIVARBPROC vertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC) func;
	PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB");

	const GLuint v[4] = {0xffffffff, 0, 0xffffffff, 0};
	const GLuint def[4] = {0, 0, 0, 0xffffffff};
	GLfloat res[4];
	GLboolean pass;
	(*vertexAttrib4NuivARB)(6, v);
	(*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res);
	pass = (EQUAL(res[0], 1.0) && EQUAL(res[1], 0.0) && EQUAL(res[2], 1.0) && EQUAL(res[3], 0.0));
	(*vertexAttrib4NuivARB)(6, def);
	return pass;
	}


	static GLboolean
	test_VertexAttrib4ivARB(generic_func func)
	{
	PFNGLVERTEXATTRIB4IVARBPROC vertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC) func;
	PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB");

	const GLint v[4] = {1, 2, -3, 4};
	const GLint def[4] = {0, 0, 0, 1};
	GLfloat res[4];
	GLboolean pass;
	(*vertexAttrib4ivARB)(6, v);
	(*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res);
	pass = (EQUAL(res[0], 1.0) && EQUAL(res[1], 2.0) && EQUAL(res[2], -3.0) && EQUAL(res[3], 4.0));
	(*vertexAttrib4ivARB)(6, def);
	return pass;
	}


	static GLboolean
	test_VertexAttrib4NsvARB(generic_func func)
	{
	PFNGLVERTEXATTRIB4NSVARBPROC vertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC) func;
	PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB");

	const GLshort v[4] = {0, 32767, 32767, 0};
	const GLshort def[4] = {0, 0, 0, 32767};
	GLfloat res[4];
	GLboolean pass;
	(*vertexAttrib4NsvARB)(6, v);
	(*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res);
	pass = (EQUAL(res[0], 0.0) && EQUAL(res[1], 1.0) && EQUAL(res[2], 1.0) && EQUAL(res[3], 0.0));
	(*vertexAttrib4NsvARB)(6, def);
	return pass;
	}


	static GLboolean
	test_VertexAttrib4NusvARB(generic_func func)
	{
	PFNGLVERTEXATTRIB4NUSVARBPROC vertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC) func;
	PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB");

	const GLushort v[4] = {0xffff, 0, 0xffff, 0};
	const GLushort def[4] = {0, 0, 0, 0xffff};
	GLfloat res[4];
	GLboolean pass;
	(*vertexAttrib4NusvARB)(6, v);
	(*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res);
	pass = (EQUAL(res[0], 1.0) && EQUAL(res[1], 0.0) && EQUAL(res[2], 1.0) && EQUAL(res[3], 0.0));
	(*vertexAttrib4NusvARB)(6, def);
	return pass;
	}


	static GLboolean
	test_VertexAttrib4ubNV(generic_func func)
	{
	PFNGLVERTEXATTRIB4UBNVPROC vertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC) func;
	PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

	const GLubyte v[4] = {255, 0, 255, 0};
	const GLubyte def[4] = {0, 0, 0, 255};
	GLfloat res[4];
	GLboolean pass;
	(*vertexAttrib4ubNV)(6, v[0], v[1], v[2], v[3]);
	(*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
	pass = (res[0] == 1.0 && res[1] == 0.0 && res[2] == 1.0 && res[3] == 0.0);
	(*vertexAttrib4ubNV)(6, def[0], def[1], def[2], def[3]);
	return pass;
	}


	static GLboolean
	test_VertexAttrib2sNV(generic_func func)
	{
	PFNGLVERTEXATTRIB2SNVPROC vertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC) func;
	PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

	const GLshort v[2] = {2, -4,};
	const GLshort def[2] = {0, 0};
	GLfloat res[4];
	GLboolean pass;
	(*vertexAttrib2sNV)(6, v[0], v[1]);
	(*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
	pass = (EQUAL(res[0], 2) && EQUAL(res[1], -4) && EQUAL(res[2], 0) && res[3] == 1.0);
	(*vertexAttrib2sNV)(6, def[0], def[1]);
	return pass;
	}


	static GLboolean
	test_VertexAttrib3fNV(generic_func func)
	{
	PFNGLVERTEXATTRIB3FNVPROC vertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC) func;
	PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

	const GLfloat v[3] = {0.2, 0.4, 0.8};
	const GLfloat def[3] = {0, 0, 0};
	GLfloat res[4];
	GLboolean pass;
	(*vertexAttrib3fNV)(6, v[0], v[1], v[2]);
	(*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
	pass = (EQUAL(res[0], 0.2) && EQUAL(res[1], 0.4) && EQUAL(res[2], 0.8) && res[3] == 1.0);
	(*vertexAttrib3fNV)(6, def[0], def[1], def[2]);
	return pass;
	}


	static GLboolean
	test_VertexAttrib4dvNV(generic_func func)
	{
	PFNGLVERTEXATTRIB4DVNVPROC vertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC) func;
	PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

	const GLdouble v[4] = {0.2, 0.4, 0.8, 1.2};
	const GLdouble def[4] = {0, 0, 0, 1};
	GLfloat res[4];
	GLboolean pass;
	(*vertexAttrib4dvNV)(6, v);
	(*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
	pass = (EQUAL(res[0], 0.2) && EQUAL(res[1], 0.4) && EQUAL(res[2], 0.8) && EQUAL(res[3], 1.2));
	(*vertexAttrib4dvNV)(6, def);
	return pass;
	}


	static GLboolean
	test_StencilFuncSeparateATI(generic_func func)
	{
	#ifdef GL_ATI_separate_stencil
	PFNGLSTENCILFUNCSEPARATEATIPROC stencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC) func;
	GLint frontFunc, backFunc;
	GLint frontRef, backRef;
	GLint frontMask, backMask;
	(*stencilFuncSeparateATI)(GL_LESS, GL_GREATER, 2, 0xa);
	glGetIntegerv(GL_STENCIL_FUNC, &frontFunc);
	glGetIntegerv(GL_STENCIL_BACK_FUNC, &backFunc);
	glGetIntegerv(GL_STENCIL_REF, &frontRef);
	glGetIntegerv(GL_STENCIL_BACK_REF, &backRef);
	glGetIntegerv(GL_STENCIL_VALUE_MASK, &frontMask);
	glGetIntegerv(GL_STENCIL_BACK_VALUE_MASK, &backMask);
	if (frontFunc != GL_LESS \|\|
	backFunc != GL_GREATER \|\|
	frontRef != 2 \|\|
	backRef != 2 \|\|
	frontMask != 0xa \|\|
	backMask != 0xa)
	return GL_FALSE;
	#endif
	return GL_TRUE;
	}

	static GLboolean
	test_StencilFuncSeparate(generic_func func)
	{
	#ifdef GL_VERSION_2_0
	PFNGLSTENCILFUNCSEPARATEPROC stencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC) func;
	GLint frontFunc, backFunc;
	GLint frontRef, backRef;
	GLint frontMask, backMask;
	(*stencilFuncSeparate)(GL_BACK, GL_GREATER, 2, 0xa);
	glGetIntegerv(GL_STENCIL_FUNC, &frontFunc);
	glGetIntegerv(GL_STENCIL_BACK_FUNC, &backFunc);
	glGetIntegerv(GL_STENCIL_REF, &frontRef);
	glGetIntegerv(GL_STENCIL_BACK_REF, &backRef);
	glGetIntegerv(GL_STENCIL_VALUE_MASK, &frontMask);
	glGetIntegerv(GL_STENCIL_BACK_VALUE_MASK, &backMask);
	if (frontFunc != GL_ALWAYS \|\|
	backFunc != GL_GREATER \|\|
	frontRef != 0 \|\|
	backRef != 2 \|\|
	frontMask == 0xa \|\| /* might be 0xff or ~0 */
	backMask != 0xa)
	return GL_FALSE;
	#endif
	return GL_TRUE;
	}

	static GLboolean
	test_StencilOpSeparate(generic_func func)
	{
	#ifdef GL_VERSION_2_0
	PFNGLSTENCILOPSEPARATEPROC stencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC) func;
	GLint frontFail, backFail;
	GLint frontZFail, backZFail;
	GLint frontZPass, backZPass;
	(*stencilOpSeparate)(GL_BACK, GL_INCR, GL_DECR, GL_INVERT);
	glGetIntegerv(GL_STENCIL_FAIL, &frontFail);
	glGetIntegerv(GL_STENCIL_BACK_FAIL, &backFail);
	glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &frontZFail);
	glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_FAIL, &backZFail);
	glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &frontZPass);
	glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_PASS, &backZPass);
	if (frontFail != GL_KEEP \|\|
	backFail != GL_INCR \|\|
	frontZFail != GL_KEEP \|\|
	backZFail != GL_DECR \|\|
	frontZPass != GL_KEEP \|\|
	backZPass != GL_INVERT)
	return GL_FALSE;
	#endif
	return GL_TRUE;
	}

	static GLboolean
	test_StencilMaskSeparate(generic_func func)
	{
	#ifdef GL_VERSION_2_0
	PFNGLSTENCILMASKSEPARATEPROC stencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC) func;
	GLint frontMask, backMask;
	(*stencilMaskSeparate)(GL_BACK, 0x1b);
	glGetIntegerv(GL_STENCIL_WRITEMASK, &frontMask);
	glGetIntegerv(GL_STENCIL_BACK_WRITEMASK, &backMask);
	if (frontMask == 0x1b \|\|
	backMask != 0x1b)
	return GL_FALSE;
	#endif
	return GL_TRUE;
	}


	/*
	* The following file is auto-generated with Python.
	*/
	#include "getproclist.h"



	static int
	extension_supported(const char haystack, const char needle)
	{
	const char *p = strstr(haystack, needle);
	if (p) {
	/* found string, make sure next char is space or zero */
	const int len = strlen(needle);
	if (p[len] == ' ' \|\| p[len] == 0)
	return 1;
	else
	return 0;
	}
	else
	return 0;
	}


	static void
	check_functions( const char *extensions )
	{
	struct name_test_pair *entry;
	int failures = 0, passes = 0;
	int totalFail = 0, totalPass = 0;
	int doTests;

	for (entry = functions; entry->name; entry++) {
	if (entry->name[0] == '-') {
	const char version = (const char ) glGetString(GL_VERSION);
	if (entry->name[1] == '1') {
	/* check GL version 1.x */
	if (version[0] == '1' &&
	version[1] == '.' &&
	version[2] >= entry->name[3])
	doTests = 1;
	else
	doTests = 0;
	}
	else if (entry->name[1] == '2') {
	if (version[0] == '2' &&
	version[1] == '.' &&
	version[2] >= entry->name[3])
	doTests = 1;
	else
	doTests = 0;
	}
	else {
	/* check if the named extension is available */
	doTests = extension_supported(extensions, entry->name+1);
	}
	if (doTests)
	printf("Testing %s functions\n", entry->name + 1);
	totalFail += failures;
	totalPass += passes;
	failures = 0;
	passes = 0;
	}
	else if (doTests) {
	generic_func funcPtr = (generic_func) glXGetProcAddressARB((const GLubyte *) entry->name);
	if (funcPtr) {
	if (entry->test) {
	GLboolean b;
	printf(" Validating %s:", entry->name);
	b = (*entry->test)(funcPtr);
	if (b) {
	printf(" Pass\n");
	passes++;
	}
	else {
	printf(" FAIL!!!\n");
	failures++;
	}
	}
	else {
	passes++;
	}
	}
	else {
	printf(" glXGetProcAddress(%s) failed!\n", entry->name);
	failures++;
	}
	}

	if (doTests && (!(entry+1)->name \|\| (entry+1)->name[0] == '-')) {
	if (failures > 0) {
	printf(" %d failed.\n", failures);
	}
	if (passes > 0) {
	printf(" %d passed.\n", passes);
	}
	}
	}
	totalFail += failures;
	totalPass += passes;

	printf("-----------------------------\n");
	printf("Total: %d pass %d fail\n", totalPass, totalFail);
	}



	static void
	print_screen_info(Display *dpy, int scrnum, Bool allowDirect)
	{
	Window win;
	int attribSingle[] = {
	GLX_RGBA,
	GLX_RED_SIZE, 1,
	GLX_GREEN_SIZE, 1,
	GLX_BLUE_SIZE, 1,
	GLX_STENCIL_SIZE, 1,
	None };
	int attribDouble[] = {
	GLX_RGBA,
	GLX_RED_SIZE, 1,
	GLX_GREEN_SIZE, 1,
	GLX_BLUE_SIZE, 1,
	GLX_STENCIL_SIZE, 1,
	GLX_DOUBLEBUFFER,
	None };

	XSetWindowAttributes attr;
	unsigned long mask;
	Window root;
	GLXContext ctx;
	XVisualInfo *visinfo;
	int width = 100, height = 100;

	root = RootWindow(dpy, scrnum);

	visinfo = glXChooseVisual(dpy, scrnum, attribSingle);
	if (!visinfo) {
	visinfo = glXChooseVisual(dpy, scrnum, attribDouble);
	if (!visinfo) {
	fprintf(stderr, "Error: couldn't find RGB GLX visual\n");
	return;
	}
	}

	attr.background_pixel = 0;
	attr.border_pixel = 0;
	attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
	attr.event_mask = StructureNotifyMask \| ExposureMask;
	mask = CWBackPixel \| CWBorderPixel \| CWColormap \| CWEventMask;
	win = XCreateWindow(dpy, root, 0, 0, width, height,
	0, visinfo->depth, InputOutput,
	visinfo->visual, mask, &attr);

	ctx = glXCreateContext( dpy, visinfo, NULL, allowDirect );
	if (!ctx) {
	fprintf(stderr, "Error: glXCreateContext failed\n");
	XDestroyWindow(dpy, win);
	return;
	}

	if (glXMakeCurrent(dpy, win, ctx)) {
	check_functions( (const char *) glGetString(GL_EXTENSIONS) );
	}
	else {
	fprintf(stderr, "Error: glXMakeCurrent failed\n");
	}

	glXDestroyContext(dpy, ctx);
	XDestroyWindow(dpy, win);
	}


	int
	main(int argc, char *argv[])
	{
	char *displayName = NULL;
	Display *dpy;

	dpy = XOpenDisplay(displayName);
	if (!dpy) {
	fprintf(stderr, "Error: unable to open display %s\n", displayName);
	return -1;
	}

	print_screen_info(dpy, 0, GL_TRUE);

	XCloseDisplay(dpy);

	return 0;
	}