mesa/progs/tests/getprocaddress.c

/*
 * 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)

/* This macro simplifies the task of querying an extension function
 * pointer and checking to see whether it resolved.
 */
#define DECLARE_GLFUNC_PTR(name,type) \
   type name = (type) glXGetProcAddressARB((const GLubyte *) "gl" #name)

/********************************************************************
 * Generic helper functions used by the test functions.
 */

static void CheckGLError(int line, const char *file, const char *function)
{
    int errorCode;
    glFinish();
    errorCode  = glGetError();
    if (errorCode == GL_NO_ERROR) return;
    while (errorCode != GL_NO_ERROR) {
	fprintf(stderr, "OpenGL error 0x%x (%s) at line %d of file %s in function %s()\n",
	    errorCode,
	    errorCode == GL_INVALID_VALUE? "GL_INVALID_VALUE":
	    errorCode == GL_INVALID_ENUM? "GL_INVALID_ENUM":
	    errorCode == GL_INVALID_OPERATION? "GL_INVALID_OPERATION":
	    errorCode == GL_STACK_OVERFLOW? "GL_STACK_OVERFLOW":
	    errorCode == GL_STACK_UNDERFLOW? "GL_STACK_UNDERFLOW":
	    errorCode == GL_OUT_OF_MEMORY? "GL_OUT_OF_MEMORY":
	    "unknown",
	    line, file, function);
	errorCode = glGetError();
    }
    fflush(stderr);
}

static GLboolean 
compare_bytes(const char *errorLabel, GLuint expectedSize, 
   const GLubyte *expectedData, GLuint actualSize, const GLubyte *actualData)
{
   int i;

   if (expectedSize == actualSize &&
      memcmp(expectedData, actualData, actualSize) == 0) {
      /* All is well */
      return GL_TRUE;
   }

   /* Trouble; we don't match.  Print out why. */
   fprintf(stderr, "%s: actual data is not as expected\n", errorLabel);
   for (i = 0; i <= 1; i++) {
      const GLubyte *ptr;
      int size;
      char *label;
      int j;

      switch(i) {
         case 0:
            label = "expected";
            size = expectedSize;
            ptr = expectedData;
            break;
         case 1:
            label = "  actual";
            size = actualSize;
            ptr = actualData;
            break;
      }
      
      fprintf(stderr, "    %s: size %d: {", label, size);
      for (j = 0; j < size; j++) {
         fprintf(stderr, "%s0x%02x", j > 0 ? ", " : "", ptr[j]);
      }
      fprintf(stderr, "}\n");
   }

   /* We fail if the data is unexpected. */
   return GL_FALSE;
}


static GLboolean 
compare_ints(const char *errorLabel, GLuint expectedSize, 
   const GLint *expectedData, GLuint actualSize, const GLint *actualData)
{
   int i;

   if (expectedSize == actualSize &&
      memcmp(expectedData, actualData, actualSize*sizeof(*expectedData)) == 0) {
      /* All is well */
      return GL_TRUE;
   }

   /* Trouble; we don't match.  Print out why. */
   fprintf(stderr, "%s: actual data is not as expected\n", errorLabel);
   for (i = 0; i <= 1; i++) {
      const GLint *ptr;
      int size;
      char *label;
      int j;

      switch(i) {
         case 0:
            label = "expected";
            size = expectedSize;
            ptr = expectedData;
            break;
         case 1:
            label = "  actual";
            size = actualSize;
            ptr = actualData;
            break;
      }
      
      fprintf(stderr, "    %s: size %d: {", label, size);
      for (j = 0; j < size; j++) {
         fprintf(stderr, "%s%d", j > 0 ? ", " : "", ptr[j]);
      }
      fprintf(stderr, "}\n");
   }

   /* We fail if the data is unexpected. */
   return GL_FALSE;
}

#define MAX_CONVERTED_VALUES 4
static GLboolean 
compare_shorts_to_ints(const char *errorLabel, GLuint expectedSize, 
   const GLshort *expectedData, GLuint actualSize, const GLint *actualData)
{
   int i;
   GLint convertedValues[MAX_CONVERTED_VALUES];

   if (expectedSize > MAX_CONVERTED_VALUES) {
      fprintf(stderr, "%s: too much data [need %d values, have %d values]\n",
         errorLabel, expectedSize, MAX_CONVERTED_VALUES);
      return GL_FALSE;
   }

   for (i = 0; i < expectedSize; i++) {
      convertedValues[i] = (GLint) expectedData[i];
   }

   return compare_ints(errorLabel, expectedSize, convertedValues, 
      actualSize, actualData);
}

static GLboolean 
compare_floats(const char *errorLabel, GLuint expectedSize, 
   const GLfloat *expectedData, GLuint actualSize, const GLfloat *actualData)
{
   int i;

   if (expectedSize == actualSize &&
      memcmp(expectedData, actualData, actualSize*sizeof(*expectedData)) == 0) {
      /* All is well */
      return GL_TRUE;
   }

   /* Trouble; we don't match.  Print out why. */
   fprintf(stderr, "%s: actual data is not as expected\n", errorLabel);
   for (i = 0; i <= 1; i++) {
      const GLfloat *ptr;
      int size;
      char *label;
      int j;

      switch(i) {
         case 0:
            label = "expected";
            size = expectedSize;
            ptr = expectedData;
            break;
         case 1:
            label = "  actual";
            size = actualSize;
            ptr = actualData;
            break;
      }
      
      fprintf(stderr, "    %s: size %d: {", label, size);
      for (j = 0; j < size; j++) {
         fprintf(stderr, "%s%f", j > 0 ? ", " : "", ptr[j]);
      }
      fprintf(stderr, "}\n");
   }

   /* We fail if the data is unexpected. */
   return GL_FALSE;
}

static GLboolean 
compare_doubles(const char *errorLabel, GLuint expectedSize, 
   const GLdouble *expectedData, GLuint actualSize, const GLdouble *actualData)
{
   int i;

   if (expectedSize == actualSize || 
      memcmp(expectedData, actualData, actualSize*sizeof(*expectedData)) == 0) {
      /* All is well */
      return GL_TRUE;
   }

   /* Trouble; we don't match.  Print out why. */
   fprintf(stderr, "%s: actual data is not as expected\n", errorLabel);
   for (i = 0; i <= 1; i++) {
      const GLdouble *ptr;
      int size;
      char *label;
      int j;

      switch(i) {
         case 0:
            label = "expected";
            size = expectedSize;
            ptr = expectedData;
            break;
         case 1:
            label = "  actual";
            size = actualSize;
            ptr = actualData;
            break;
      }
      
      fprintf(stderr, "    %s: size %d: {", label, size);
      for (j = 0; j < size; j++) {
         fprintf(stderr, "%s%f", j > 0 ? ", " : "", ptr[j]);
      }
      fprintf(stderr, "}\n");
   }

   /* We fail if the data is unexpected. */
   return GL_FALSE;
}

/********************************************************************
 * Functions to assist with GL_ARB_texture_compressiong testing
 */

static GLboolean
check_texture_format_supported(GLenum format)
{
   GLint numFormats;
   GLint *formats;
   register int i;

   glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB, &numFormats);
   formats = malloc(numFormats * sizeof(GLint));
   if (formats == NULL) {
      fprintf(stderr, "check_texture_format_supported: could not allocate memory for %d GLints\n", 
         numFormats);
      return GL_FALSE;
   }
   
   memset(formats, 0, numFormats * sizeof(GLint));
   glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS_ARB, formats);

   for (i = 0; i < numFormats; i++) {
      if (formats[i] == format) {
         free(formats);
         return GL_TRUE;
      }
   }

   /* We didn't find the format we were looking for.  Give an error. */
#define FORMAT_NAME(x) (\
   x == GL_COMPRESSED_RGB_FXT1_3DFX ? "GL_COMPRESSED_RGB_FXT1_3DFX" : \
   x == GL_COMPRESSED_RGBA_FXT1_3DFX ? "GL_COMPRESSED_RGBA_FXT1_3DFX" : \
   x == GL_COMPRESSED_RGB_S3TC_DXT1_EXT ? "GL_COMPRESSED_RGB_S3TC_DXT1_EXT" : \
   x == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ? "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT" : \
   x == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ? "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT" : \
   x == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT ? "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT" : \
   x == GL_RGB_S3TC ? "GL_RGB_S3TC" : \
   x == GL_RGB4_S3TC ? "GL_RGB4_S3TC" : \
   x == GL_RGBA_S3TC ? "GL_RGBA_S3TC" : \
   x == GL_RGBA4_S3TC ? "GL_RGBA4_S3TC" : \
   "unknown")
   fprintf(stderr, "check_texture_format_supported: unsupported format 0x%04x [%s]\n",
      format, FORMAT_NAME(format));
   fprintf(stderr, "supported formats:");
   for (i = 0; i < numFormats; i++) {
      fprintf(stderr, " 0x%04x [%s]", formats[i], FORMAT_NAME(formats[i]));
   }
   fprintf(stderr, "\n");
   return GL_FALSE;
}

/* This helper function compresses an RGBA texture and compares it
 * against the expected compressed data.  It returns GL_TRUE if all
 * went as expected, or GL_FALSE in the case of error.
 */
static GLboolean
check_texture_compression(const char *message, GLenum dimension,
   GLint width, GLint height, GLint depth, const GLubyte *texture, 
   int expectedCompressedSize, const GLubyte *expectedCompressedData)
{
   /* These are the data we query about the texture. */
   GLint isCompressed;
   GLenum compressedFormat;
   GLint compressedSize;
   GLubyte *compressedData;

   /* We need this function pointer to operate. */
   DECLARE_GLFUNC_PTR(GetCompressedTexImageARB, PFNGLGETCOMPRESSEDTEXIMAGEARBPROC);
   if (GetCompressedTexImageARB == NULL) {
      fprintf(stderr, 
         "%s: could not query GetCompressedTexImageARB function pointer\n",
         message);
      return GL_FALSE;
   }

   /* Verify that we actually have the GL_COMPRESSED_RGBA_S3TC_DXT3_EXT format available. */
   if (!check_texture_format_supported(GL_COMPRESSED_RGBA_S3TC_DXT3_EXT)) {
      return GL_FALSE;
   }

   CheckGLError(__LINE__, __FILE__, __FUNCTION__);
   /* Set up the base image, requesting that the GL library compress it. */
   switch(dimension) {
      case GL_TEXTURE_1D:
         glTexImage1D(GL_TEXTURE_1D, 0, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 
            width, 0, 
            GL_RGBA, GL_UNSIGNED_BYTE, texture);
         break;
      case GL_TEXTURE_2D:
         glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 
            width, height, 0, 
            GL_RGBA, GL_UNSIGNED_BYTE, texture);
         break;
      case GL_TEXTURE_3D:
         glTexImage3D(GL_TEXTURE_3D, 0, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 
            width, height, depth, 0, 
            GL_RGBA, GL_UNSIGNED_BYTE, texture);
         break;
      default:
         fprintf(stderr, "%s: unknown dimension 0x%04x.\n", message, dimension);
         return GL_FALSE;
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Make sure the texture is compressed, and pull it out if it is. */
   glGetTexLevelParameteriv(dimension, 0, GL_TEXTURE_COMPRESSED_ARB, 
      &isCompressed);
   if (!isCompressed) {
      fprintf(stderr, "%s: could not compress GL_COMPRESSED_RGBA_S3TC_DXT3_EXT texture\n",
         message);
      return GL_FALSE;
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);
   glGetTexLevelParameteriv(dimension, 0, GL_TEXTURE_INTERNAL_FORMAT, 
      (GLint *)&compressedFormat);
   if (compressedFormat != GL_COMPRESSED_RGBA_S3TC_DXT3_EXT) {
      fprintf(stderr, "%s: got internal format 0x%04x, expected GL_COMPRESSED_RGBA_S3TC_DXT3_EXT [0x%04x]\n",
         __FUNCTION__, compressedFormat, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT);
      return GL_FALSE;
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);
   glGetTexLevelParameteriv(dimension, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB, &compressedSize);
   compressedData = malloc(compressedSize);
   if (compressedData == NULL) {
      fprintf(stderr, "%s: could not malloc %d bytes for compressed texture\n",
         message, compressedSize);
      return GL_FALSE;
   }
   memset(compressedData, 0, compressedSize);
   (*GetCompressedTexImageARB)(dimension, 0, compressedData);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Compare it to the expected compressed data. The compare_bytes()
    * call will print out diagnostics in the case of failure.
    */
   if (!compare_bytes(message, 
      expectedCompressedSize, expectedCompressedData,
      compressedSize, compressedData)) {

      free(compressedData);
      return GL_FALSE;
   }

   /* All done.  Free our allocated data and return success. */
   free(compressedData);
   return GL_TRUE;
}

/* We'll use one function to exercise 1D, 2D, and 3D textures. */

/* The test function for compressed 3D texture images requires several
 * different function pointers that have to be queried.  This function
 * gets all the function pointers it needs itself, and so is suitable for 
 * use to test any and all of the incorporated functions.
 */

static GLboolean
exercise_CompressedTextures(GLenum dimension)
{
   /* Set up a basic (uncompressed) texture.  We're doing a blue/yellow
    * checkerboard.  The 8x4/32-pixel board is well-suited to S3TC
    * compression, which works on 4x4 blocks of pixels.
    */
#define B 0,0,255,255
#define Y 255,255,0,255
#define TEXTURE_WIDTH 16 
#define TEXTURE_HEIGHT 4
#define TEXTURE_DEPTH 1
   static GLubyte texture[TEXTURE_WIDTH*TEXTURE_HEIGHT*TEXTURE_DEPTH*4] = {
      B, B, Y, Y, B, B, Y, Y, B, B, Y, Y, B, B, Y, Y,
      B, B, Y, Y, B, B, Y, Y, B, B, Y, Y, B, B, Y, Y,
      Y, Y, B, B, Y, Y, B, B, Y, Y, B, B, Y, Y, B, B, 
      Y, Y, B, B, Y, Y, B, B, Y, Y, B, B, Y, Y, B, B, 
   };
#undef B
#undef Y
   GLubyte uncompressedTexture[TEXTURE_WIDTH*TEXTURE_HEIGHT*TEXTURE_DEPTH*4];

   /* We'll use this as a texture subimage. */
#define R 255,0,0,255
#define G 0,255,0,255
#define SUBTEXTURE_WIDTH 4
#define SUBTEXTURE_HEIGHT 4
#define SUBTEXTURE_DEPTH 1
   static GLubyte subtexture[SUBTEXTURE_WIDTH*SUBTEXTURE_HEIGHT*SUBTEXTURE_DEPTH*4] = {
      G, G, R, R,
      G, G, R, R,
      R, R, G, G,
      R, R, G, G,
   };
#undef R
#undef G

   /* These are the expected compressed textures.  (In the case of
    * a failed comparison, the test program will print out the
    * actual compressed data in a format that can be directly used
    * here, if desired.)  The brave of heart can calculate the compression 
    * themselves based on the formulae described at:
    *   http://en.wikipedia.org/wiki/S3_Texture_Compression
    * In a nutshell, each group of 16 bytes encodes a 4x4 texture block.
    * The first eight bytes of each group are 4-bit alpha values
    * for each of the 16 pixels in the texture block.
    * The next four bytes in each group are LSB-first RGB565 colors; the
    * first two bytes are identified as the color C0, and the next two
    * are the color C1.  (Two more colors C2 and C3 will be calculated 
    * from these, but do not appear in the compression data.)  The
    * last 4 bytes of the group are sixteen 2-bit indices that, for
    * each of the 16 pixels in the texture block, select one of the
    * colors C0, C1, C2, or C3.
    *
    * For example, our blue/yellow checkerboard is made up of
    * four identical 4x4 blocks.  Each of those blocks will
    * be encoded as: eight bytes of 0xff (16 alpha values, each 0xf),
    * C0 as the RGB565 color yellow (0xffe0), encoded LSB-first;
    * C1 as the RGB565 color blue (0x001f), encoded LSB-first;
    * and 4 bytes of 16 2-bit color indices reflecting the
    * choice of color for each of the 16 pixels:
    *     00, 00, 01, 01, = 0x05
    *     00, 00, 01, 01, = 0x05
    *     01, 01, 00, 00, = 0x50
    *     01, 01, 00, 00, = 0x50
    */
   static GLubyte compressedTexture[] = {
      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
      0xe0, 0xff, 0x1f, 0x00, 0x05, 0x05, 0x50, 0x50,
      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
      0xe0, 0xff, 0x1f, 0x00, 0x05, 0x05, 0x50, 0x50,
      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
      0xe0, 0xff, 0x1f, 0x00, 0x05, 0x05, 0x50, 0x50,
      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
      0xe0, 0xff, 0x1f, 0x00, 0x05, 0x05, 0x50, 0x50
   };

   /* The similar calculations for the 4x4 subtexture are left
    * as an exercise for the reader.
    */
   static GLubyte compressedSubTexture[] = {
      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
      0x00, 0xf8, 0xe0, 0x07, 0x05, 0x05, 0x50, 0x50,
   };

   /* The combined texture replaces the initial blue/yellow
    * block with the green/red block.  (I'd wanted to do
    * the more interesting exercise of putting the
    * green/red block in the middle of the blue/yellow
    * texture, which is a non-trivial replacement, but
    * the attempt produces GL_INVALID_OPERATION, showing
    * that you can only replace whole blocks of 
    * subimages with S3TC.)  The combined texture looks
    * like:
    *      G G R R  B B Y Y  B B Y Y  B B Y Y
    *      G G R R  B B Y Y  B B Y Y  B B Y Y
    *      R R G G  Y Y B B  Y Y B B  Y Y B B 
    *      R R G G  Y Y B B  Y Y B B  Y Y B B 
    * which encodes just like the green/red block followed
    * by 3 copies of the yellow/blue block.
    */
   static GLubyte compressedCombinedTexture[] = {
      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
      0x00, 0xf8, 0xe0, 0x07, 0x05, 0x05, 0x50, 0x50,
      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
      0xe0, 0xff, 0x1f, 0x00, 0x05, 0x05, 0x50, 0x50,
      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
      0xe0, 0xff, 0x1f, 0x00, 0x05, 0x05, 0x50, 0x50,
      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
      0xe0, 0xff, 0x1f, 0x00, 0x05, 0x05, 0x50, 0x50
   };

   /* These are the data we query about the texture. */
   GLint queryIsCompressed;
   GLenum queryCompressedFormat;
   GLint queryCompressedSize;
   GLubyte queryCompressedData[sizeof(compressedTexture)];

   /* Query the function pointers we need.  We actually won't need most
    * of these (the "dimension" parameter dictates whether we're testing
    * 1D, 2D, or 3D textures), but we'll have them all ready just in case.
    */
   DECLARE_GLFUNC_PTR(GetCompressedTexImageARB, PFNGLGETCOMPRESSEDTEXIMAGEARBPROC);
   DECLARE_GLFUNC_PTR(CompressedTexImage3DARB, PFNGLCOMPRESSEDTEXIMAGE3DARBPROC);
   DECLARE_GLFUNC_PTR(CompressedTexSubImage3DARB, PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC);
   DECLARE_GLFUNC_PTR(CompressedTexImage2DARB, PFNGLCOMPRESSEDTEXIMAGE2DARBPROC);
   DECLARE_GLFUNC_PTR(CompressedTexSubImage2DARB, PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC);
   DECLARE_GLFUNC_PTR(CompressedTexImage1DARB, PFNGLCOMPRESSEDTEXIMAGE1DARBPROC);
   DECLARE_GLFUNC_PTR(CompressedTexSubImage1DARB, PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC);

   /* If the necessary functions are missing, we can't continue */
   if (GetCompressedTexImageARB == NULL) {
      fprintf(stderr, "%s: GetCompressedTexImageARB function is missing\n",
         __FUNCTION__);
      return GL_FALSE;
   }
   switch (dimension) {
      case GL_TEXTURE_1D:
         if (CompressedTexImage1DARB == NULL || CompressedTexSubImage1DARB == NULL) {
            fprintf(stderr, "%s: 1D compressed texture functions are missing\n",
               __FUNCTION__);
            return GL_FALSE;
         };
         break;
      case GL_TEXTURE_2D:
         if (CompressedTexImage2DARB == NULL || CompressedTexSubImage2DARB == NULL) {
            fprintf(stderr, "%s: 2D compressed texture functions are missing\n",
               __FUNCTION__);
            return GL_FALSE;
         };
         break;
      case GL_TEXTURE_3D:
         if (CompressedTexImage3DARB == NULL || CompressedTexSubImage3DARB == NULL) {
            fprintf(stderr, "%s: 3D compressed texture functions are missing\n",
               __FUNCTION__);
            return GL_FALSE;
         };
         break;
      default:
         fprintf(stderr, "%s: unknown texture dimension 0x%04x passed.\n",
            __FUNCTION__, dimension);
         return GL_FALSE;
   }
   
   /* Check the compression of our base texture image. */
   if (!check_texture_compression("texture compression", dimension,
         TEXTURE_WIDTH, TEXTURE_HEIGHT, TEXTURE_DEPTH, texture,
         sizeof(compressedTexture), compressedTexture)) {

      /* Something's wrong with texture compression.  The function
       * above will have printed an appropriate error.
       */
      return GL_FALSE;
   }

   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Do the same for our texture subimage */
   if (!check_texture_compression("subtexture compression", dimension,
         SUBTEXTURE_WIDTH, SUBTEXTURE_HEIGHT, SUBTEXTURE_DEPTH, subtexture,
         sizeof(compressedSubTexture), compressedSubTexture)) {

      /* Something's wrong with texture compression.  The function
       * above will have printed an appropriate error.
       */
      return GL_FALSE;
   }

   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Send the base compressed texture down to the hardware. */
   switch(dimension) {
      case GL_TEXTURE_3D:
         (*CompressedTexImage3DARB)(GL_TEXTURE_3D, 0, 
            GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 
            TEXTURE_WIDTH, TEXTURE_HEIGHT, TEXTURE_DEPTH, 0, 
            sizeof(compressedTexture), compressedTexture);
         break;

      case GL_TEXTURE_2D:
         (*CompressedTexImage2DARB)(GL_TEXTURE_2D, 0, 
            GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 
            TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, 
            sizeof(compressedTexture), compressedTexture);
         break;

      case GL_TEXTURE_1D:
         (*CompressedTexImage1DARB)(GL_TEXTURE_1D, 0, 
            GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 
            TEXTURE_WIDTH, 0, 
            sizeof(compressedTexture), compressedTexture);
         break;
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* For grins, query it to make sure it is as expected. */
   glGetTexLevelParameteriv(dimension, 0, GL_TEXTURE_COMPRESSED_ARB, 
      &queryIsCompressed);
   if (!queryIsCompressed) {
      fprintf(stderr, "%s: compressed texture did not come back as compressed\n",
         __FUNCTION__);
      return GL_FALSE;
   }
   glGetTexLevelParameteriv(dimension, 0, GL_TEXTURE_INTERNAL_FORMAT, 
      (GLint *)&queryCompressedFormat);
   if (queryCompressedFormat != GL_COMPRESSED_RGBA_S3TC_DXT3_EXT) {
      fprintf(stderr, "%s: got internal format 0x%04x, expected GL_COMPRESSED_RGBA_S3TC_DXT3_EXT [0x%04x]\n",
         __FUNCTION__, queryCompressedFormat, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT);
      return GL_FALSE;
   }
   glGetTexLevelParameteriv(dimension, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB, 
      &queryCompressedSize);
   if (queryCompressedSize != sizeof(compressedTexture)) {
      fprintf(stderr, "%s: compressed 3D texture changed size: expected %lu, actual %d\n",
         __FUNCTION__, (unsigned long) sizeof(compressedTexture), queryCompressedSize);
      return GL_FALSE;
   }
   (*GetCompressedTexImageARB)(dimension, 0, queryCompressedData);
   if (!compare_bytes(
      "exercise_CompressedTextures:doublechecking compressed texture",
      sizeof(compressedTexture), compressedTexture,
      queryCompressedSize, queryCompressedData)) {
      return GL_FALSE;
   }

   /* Now apply the texture subimage.  The current implementation of
    * S3TC requires that subimages be only applied to whole blocks.
    */
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);
   switch(dimension) {
      case GL_TEXTURE_3D:
         (*CompressedTexSubImage3DARB)(GL_TEXTURE_3D, 0, 
            0, 0, 0, /* offsets */
            SUBTEXTURE_WIDTH, SUBTEXTURE_HEIGHT, SUBTEXTURE_DEPTH,
            GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 
            sizeof(compressedSubTexture), compressedSubTexture);
         break;
      case GL_TEXTURE_2D:
         (*CompressedTexSubImage2DARB)(GL_TEXTURE_2D, 0, 
            0, 0, /* offsets */
            SUBTEXTURE_WIDTH, SUBTEXTURE_HEIGHT,
            GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 
            sizeof(compressedSubTexture), compressedSubTexture);
         break;
      case GL_TEXTURE_1D:
         (*CompressedTexSubImage2DARB)(GL_TEXTURE_2D, 0, 
            0, 0, /* offsets */
            SUBTEXTURE_WIDTH, SUBTEXTURE_HEIGHT,
            GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 
            sizeof(compressedSubTexture), compressedSubTexture);
         break;
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Query the compressed texture back now, and see that it
    * is as expected.
    */
   (*GetCompressedTexImageARB)(dimension, 0, queryCompressedData);
   if (!compare_bytes("exercise_CompressedTextures:combined texture",
      sizeof(compressedCombinedTexture), compressedCombinedTexture,
      queryCompressedSize, queryCompressedData)) {
      return GL_FALSE;
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Just for the exercise, uncompress the texture and pull it out. 
    * We don't check it because the compression is lossy, so it won't
    * compare exactly to the source texture; we just 
    * want to exercise the code paths that convert it.
    */
   glGetTexImage(dimension, 0, GL_RGBA, GL_UNSIGNED_BYTE, uncompressedTexture);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* If we survived this far, we pass. */
   return GL_TRUE;
}

/**************************************************************************
 * Functions to assist with GL_EXT_framebuffer_object and
 * GL_EXT_framebuffer_blit testing.
 */

#define FB_STATUS_NAME(x) (\
   x == GL_FRAMEBUFFER_COMPLETE_EXT ? "GL_FRAMEBUFFER_COMPLETE_EXT" : \
   x == GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT ? "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT" : \
   x == GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT ? "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT" : \
   x == GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT ? "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT" : \
   x == GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT ? "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT" : \
   x == GL_FRAMEBUFFER_UNSUPPORTED_EXT ? "GL_FRAMEBUFFER_UNSUPPORTED_EXT" : \
   x == GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT ? "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT" : \
   x == GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT ? "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT" : \
   x == GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT ? "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT" : \
   "unknown")

static GLboolean
exercise_framebuffer(void)
{
   GLuint framebufferID = 0;
   GLuint renderbufferID = 0;
   
   /* Dimensions of the framebuffer and renderbuffers are arbitrary.
    * Since they won't be shown on-screen, we can use whatever we want.
    */
   const GLint Width = 100;
   const GLint Height = 100;

   /* Every function we use will be referenced through function pointers.
    * This will allow this test program to run on OpenGL implementations
    * that *don't* implement these extensions (though the implementation
    * used to compile them must have up-to-date header files).
    */
   DECLARE_GLFUNC_PTR(GenFramebuffersEXT, PFNGLGENFRAMEBUFFERSEXTPROC);
   DECLARE_GLFUNC_PTR(IsFramebufferEXT, PFNGLISFRAMEBUFFEREXTPROC);
   DECLARE_GLFUNC_PTR(DeleteFramebuffersEXT, PFNGLDELETEFRAMEBUFFERSEXTPROC);
   DECLARE_GLFUNC_PTR(BindFramebufferEXT, PFNGLBINDFRAMEBUFFEREXTPROC);
   DECLARE_GLFUNC_PTR(GenRenderbuffersEXT, PFNGLGENRENDERBUFFERSEXTPROC);
   DECLARE_GLFUNC_PTR(IsRenderbufferEXT, PFNGLISRENDERBUFFEREXTPROC);
   DECLARE_GLFUNC_PTR(DeleteRenderbuffersEXT, PFNGLDELETERENDERBUFFERSEXTPROC);
   DECLARE_GLFUNC_PTR(BindRenderbufferEXT, PFNGLBINDRENDERBUFFEREXTPROC);
   DECLARE_GLFUNC_PTR(FramebufferRenderbufferEXT, PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC);
   DECLARE_GLFUNC_PTR(RenderbufferStorageEXT, PFNGLRENDERBUFFERSTORAGEEXTPROC);
   DECLARE_GLFUNC_PTR(CheckFramebufferStatusEXT, PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC);

   /* The BlitFramebuffer function comes from a different extension.
    * It's possible for an implementation to implement all the above,
    * but not BlitFramebuffer; so it's okay if this one comes back
    * NULL, as we can still test the rest.
    */
   DECLARE_GLFUNC_PTR(BlitFramebufferEXT, PFNGLBLITFRAMEBUFFEREXTPROC);

   /* We cannot test unless we have all the function pointers. */
   if (
      GenFramebuffersEXT == NULL ||
      IsFramebufferEXT == NULL || 
      DeleteFramebuffersEXT == NULL ||
      BindFramebufferEXT == NULL ||
      GenRenderbuffersEXT == NULL ||
      IsRenderbufferEXT == NULL ||
      DeleteRenderbuffersEXT == NULL ||
      BindRenderbufferEXT == NULL ||
      FramebufferRenderbufferEXT == NULL ||
      RenderbufferStorageEXT == NULL ||
      CheckFramebufferStatusEXT == NULL
   ) {
      fprintf(stderr, "%s: could not locate all framebuffer functions\n",
         __FUNCTION__);
      return GL_FALSE;
   }

   /* Generate a framebuffer for us to play with. */
   (*GenFramebuffersEXT)(1, &framebufferID);
   if (framebufferID == 0) {
      fprintf(stderr, "%s: failed to generate a frame buffer ID.\n",
         __FUNCTION__);
      return GL_FALSE;
   }
   /* The generated name is not a framebuffer object until bound. */
   (*BindFramebufferEXT)(GL_FRAMEBUFFER_EXT, framebufferID);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);
   if (!(*IsFramebufferEXT)(framebufferID)) {
      fprintf(stderr, "%s: generated a frame buffer ID 0x%x that wasn't a framebuffer\n",
         __FUNCTION__, framebufferID);
      (*BindFramebufferEXT)(GL_FRAMEBUFFER_EXT, 0);
      (*DeleteFramebuffersEXT)(1, &framebufferID);
      return GL_FALSE;
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);
   {
      GLint queriedFramebufferID;
      glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &queriedFramebufferID);
      if (queriedFramebufferID != framebufferID) {
         fprintf(stderr, "%s: bound frame buffer 0x%x, but queried 0x%x\n",
            __FUNCTION__, framebufferID, queriedFramebufferID);
         (*BindFramebufferEXT)(GL_FRAMEBUFFER_EXT, 0);
         (*DeleteFramebuffersEXT)(1, &framebufferID);
         return GL_FALSE;
      }
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Create a color buffer to attach to the frame buffer object, so
    * we can actually operate on it.  We go through the same basic checks
    * with the renderbuffer that we do with the framebuffer.
    */
   (*GenRenderbuffersEXT)(1, &renderbufferID);
   if (renderbufferID == 0) {
      fprintf(stderr, "%s: could not generate a renderbuffer ID\n",
         __FUNCTION__);
      (*BindFramebufferEXT)(GL_FRAMEBUFFER_EXT, 0);
      (*DeleteFramebuffersEXT)(1, &framebufferID);
      return GL_FALSE;
   }
   (*BindRenderbufferEXT)(GL_RENDERBUFFER_EXT, renderbufferID);
   if (!(*IsRenderbufferEXT)(renderbufferID)) {
      fprintf(stderr, "%s: generated renderbuffer 0x%x is not a renderbuffer\n",
         __FUNCTION__, renderbufferID);
      (*BindRenderbufferEXT)(GL_RENDERBUFFER_EXT, 0);
      (*DeleteRenderbuffersEXT)(1, &renderbufferID);
      (*BindFramebufferEXT)(GL_FRAMEBUFFER_EXT, 0);
      (*DeleteFramebuffersEXT)(1, &framebufferID);
      return GL_FALSE;
   }
   {
      GLint queriedRenderbufferID = 0;
      glGetIntegerv(GL_RENDERBUFFER_BINDING_EXT, &queriedRenderbufferID);
      if (renderbufferID != queriedRenderbufferID) {
         fprintf(stderr, "%s: bound renderbuffer 0x%x, but got 0x%x\n",
            __FUNCTION__, renderbufferID, queriedRenderbufferID);
         (*BindRenderbufferEXT)(GL_RENDERBUFFER_EXT, 0);
         (*DeleteRenderbuffersEXT)(1, &renderbufferID);
         (*BindFramebufferEXT)(GL_FRAMEBUFFER_EXT, 0);
         (*DeleteFramebuffersEXT)(1, &framebufferID);
         return GL_FALSE;
      }
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Add the renderbuffer as a color attachment to the current
    * framebuffer (which is our generated framebuffer).
    */
   (*FramebufferRenderbufferEXT)(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT,
      GL_RENDERBUFFER_EXT, renderbufferID);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* The renderbuffer will need some dimensions and storage space. */
   (*RenderbufferStorageEXT)(GL_RENDERBUFFER_EXT, GL_RGB, Width, Height);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* That should be everything we need.  If we set up to draw and to
    * read from our color attachment, we should be "framebuffer complete",
    * meaning the framebuffer is ready to go.
    */
   glDrawBuffer(GL_COLOR_ATTACHMENT1_EXT);
   glReadBuffer(GL_COLOR_ATTACHMENT1_EXT);
   {
      GLenum status = (*CheckFramebufferStatusEXT)(GL_FRAMEBUFFER_EXT);
      if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
         fprintf(stderr, "%s: framebuffer not complete; status = %s [0x%x]\n",
            __FUNCTION__, FB_STATUS_NAME(status), status);
         glReadBuffer(0);
         glDrawBuffer(0);
         (*BindRenderbufferEXT)(GL_RENDERBUFFER_EXT, 0);
         (*DeleteRenderbuffersEXT)(1, &renderbufferID);
         (*BindFramebufferEXT)(GL_FRAMEBUFFER_EXT, 0);
         (*DeleteFramebuffersEXT)(1, &framebufferID);
         return GL_FALSE;
      }
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Define the contents of the frame buffer */
   glClearColor(0.5, 0.5, 0.5, 0.0);
   glClear(GL_COLOR_BUFFER_BIT);

   /* If the GL_EXT_framebuffer_blit is supported, attempt a framebuffer
    * blit from (5,5)-(10,10) to (90,90)-(95,95).  This is *not* an
    * error if framebuffer_blit is *not* supported (as we can still
    * effectively test the other functions).
    */
   if (BlitFramebufferEXT != NULL) {
      (*BlitFramebufferEXT)(5, 5, 10, 10, 90, 90, 95, 95,
         GL_COLOR_BUFFER_BIT, GL_NEAREST);
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* We could now test to see whether the framebuffer had the desired
    * contents.  As this is just a touch test, we'll leave that for now.
    * Clean up and go home.
    */
   glReadBuffer(0);
   glDrawBuffer(0);
   (*BindRenderbufferEXT)(GL_RENDERBUFFER_EXT, 0);
   (*DeleteRenderbuffersEXT)(1, &renderbufferID);
   (*BindFramebufferEXT)(GL_FRAMEBUFFER_EXT, 0);
   (*DeleteFramebuffersEXT)(1, &framebufferID);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   return GL_TRUE;
}

/**************************************************************************
 * Functions to assist with GL_ARB_shader_objects testing.
 */

static void
print_info_log(const char *message, GLhandleARB object)
{
   DECLARE_GLFUNC_PTR(GetObjectParameterivARB, PFNGLGETOBJECTPARAMETERIVARBPROC);
   DECLARE_GLFUNC_PTR(GetInfoLogARB, PFNGLGETINFOLOGARBPROC);
   int logLength, queryLength;
   char *log;

   if (GetObjectParameterivARB == NULL) {
      fprintf(stderr, "%s: could not get GetObjectParameterivARB address\n",
         message);
      return;
   }
   if (GetInfoLogARB == NULL) {
      fprintf(stderr, "%s: could not get GetInfoLogARB address\n",
         message);
      return;
   }

   (*GetObjectParameterivARB)(object, GL_OBJECT_INFO_LOG_LENGTH_ARB, 
      &logLength);
   if (logLength == 0) {
      fprintf(stderr, "%s: info log length is 0\n", message);
      return;
   }
   log = malloc(logLength);
   if (log == NULL) {
      fprintf(stderr, "%s: could not malloc %d bytes for info log\n",
         message, logLength);
   }
   else {
      (*GetInfoLogARB)(object, logLength, &queryLength, log);
      fprintf(stderr, "%s: info log says '%s'\n",
         message, log);
   }
   free(log);
}

static GLboolean
exercise_uniform_start(const char *fragmentShaderText, const char *uniformName,
   GLhandleARB *returnProgram, GLint *returnUniformLocation)
{
   DECLARE_GLFUNC_PTR(CreateShaderObjectARB, PFNGLCREATESHADEROBJECTARBPROC);
   DECLARE_GLFUNC_PTR(ShaderSourceARB, PFNGLSHADERSOURCEARBPROC);
   DECLARE_GLFUNC_PTR(CompileShaderARB, PFNGLCOMPILESHADERARBPROC);
   DECLARE_GLFUNC_PTR(CreateProgramObjectARB, PFNGLCREATEPROGRAMOBJECTARBPROC);
   DECLARE_GLFUNC_PTR(AttachObjectARB, PFNGLATTACHOBJECTARBPROC);
   DECLARE_GLFUNC_PTR(LinkProgramARB, PFNGLLINKPROGRAMARBPROC);
   DECLARE_GLFUNC_PTR(UseProgramObjectARB, PFNGLUSEPROGRAMOBJECTARBPROC);
   DECLARE_GLFUNC_PTR(ValidateProgramARB, PFNGLVALIDATEPROGRAMARBPROC);
   DECLARE_GLFUNC_PTR(GetUniformLocationARB, PFNGLGETUNIFORMLOCATIONARBPROC);
   DECLARE_GLFUNC_PTR(DeleteObjectARB, PFNGLDELETEOBJECTARBPROC);
   DECLARE_GLFUNC_PTR(GetObjectParameterivARB, PFNGLGETOBJECTPARAMETERIVARBPROC);
   GLhandleARB fs, program;
   GLint uniformLocation;
   GLint shaderCompiled, programValidated;

   if (CreateShaderObjectARB == NULL ||
       ShaderSourceARB == NULL ||
       CompileShaderARB == NULL ||
       CreateProgramObjectARB == NULL ||
       AttachObjectARB == NULL ||
       LinkProgramARB == NULL ||
       UseProgramObjectARB == NULL ||
       ValidateProgramARB == NULL ||
       GetUniformLocationARB == NULL ||
       DeleteObjectARB == NULL ||
       GetObjectParameterivARB == NULL ||
       0) {
      return GL_FALSE;
   }

   /* Create the trivial fragment shader and program.  For safety
    * we'll check to make sure they compile and link correctly.
    */
   fs = (*CreateShaderObjectARB)(GL_FRAGMENT_SHADER_ARB);
   (*ShaderSourceARB)(fs, 1, &fragmentShaderText, NULL);
   (*CompileShaderARB)(fs);
   (*GetObjectParameterivARB)(fs, GL_OBJECT_COMPILE_STATUS_ARB,
      &shaderCompiled);
   if (!shaderCompiled) {
      print_info_log("shader did not compile", fs);
      (*DeleteObjectARB)(fs);
      CheckGLError(__LINE__, __FILE__, __FUNCTION__);
      return GL_FALSE;
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   program = (*CreateProgramObjectARB)();
   (*AttachObjectARB)(program, fs);
   (*LinkProgramARB)(program);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Make sure we're going to run successfully */
   (*ValidateProgramARB)(program);
   (*GetObjectParameterivARB)(program, GL_OBJECT_VALIDATE_STATUS_ARB, 
      &programValidated);
   if (!programValidated) {; 
      print_info_log("program did not validate", program);
      (*DeleteObjectARB)(program);
      (*DeleteObjectARB)(fs);
      CheckGLError(__LINE__, __FILE__, __FUNCTION__);
      return GL_FALSE;
   }

   /* Put the program in place.  We're not allowed to assign to uniform
    * variables used by the program until the program is put into use.
    */
   (*UseProgramObjectARB)(program);

   /* Once the shader is in place, we're free to delete it; this
    * won't affect the copy that's part of the program.
    */
   (*DeleteObjectARB)(fs);

   /* Find the location index of the uniform variable we declared;
    * the caller will ned that to set the value.
    */
   uniformLocation = (*GetUniformLocationARB)(program, uniformName);
   if (uniformLocation == -1) {
      fprintf(stderr, "%s: could not determine uniform location\n",
         __FUNCTION__);
      (*DeleteObjectARB)(program);
      CheckGLError(__LINE__, __FILE__, __FUNCTION__);
      return GL_FALSE;
   }

   /* All done with what we're supposed to do - return the program
    * handle and the uniform location to the caller.
    */
   *returnProgram = program;
   *returnUniformLocation = uniformLocation;
   return GL_TRUE;
}

static void
exercise_uniform_end(GLhandleARB program)
{
   DECLARE_GLFUNC_PTR(UseProgramObjectARB, PFNGLUSEPROGRAMOBJECTARBPROC);
   DECLARE_GLFUNC_PTR(DeleteObjectARB, PFNGLDELETEOBJECTARBPROC);
   if (UseProgramObjectARB == NULL || DeleteObjectARB == NULL) {
      return;
   }

   /* Turn off our program by setting the special value 0, and
    * then delete the program object.
    */
   (*UseProgramObjectARB)(0);
   (*DeleteObjectARB)(program);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);
}

/**************************************************************************
 * Exercises for fences
 */
static GLboolean
exercise_fences(void)
{
   DECLARE_GLFUNC_PTR(DeleteFencesNV, PFNGLDELETEFENCESNVPROC);
   DECLARE_GLFUNC_PTR(FinishFenceNV, PFNGLFINISHFENCENVPROC);
   DECLARE_GLFUNC_PTR(GenFencesNV, PFNGLGENFENCESNVPROC);
   DECLARE_GLFUNC_PTR(GetFenceivNV, PFNGLGETFENCEIVNVPROC);
   DECLARE_GLFUNC_PTR(IsFenceNV, PFNGLISFENCENVPROC);
   DECLARE_GLFUNC_PTR(SetFenceNV, PFNGLSETFENCENVPROC);
   DECLARE_GLFUNC_PTR(TestFenceNV, PFNGLTESTFENCENVPROC);
   GLuint fence;
   GLint fenceStatus, fenceCondition;
   int count;

   /* Make sure we have all the function pointers we need. */
   if (GenFencesNV == NULL ||
      SetFenceNV == NULL ||
      IsFenceNV == NULL ||
      GetFenceivNV == NULL ||
      TestFenceNV == NULL ||
      FinishFenceNV == NULL ||
      DeleteFencesNV == NULL) {
      fprintf(stderr, "%s: don't have all the fence functions\n",
         __FUNCTION__);
      return GL_FALSE;
   }

   /* Create and set a simple fence. */
   (*GenFencesNV)(1, &fence);
   (*SetFenceNV)(fence, GL_ALL_COMPLETED_NV);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Make sure it reads as a fence. */
   if (!(*IsFenceNV)(fence)) {
      fprintf(stderr, "%s: set fence is not a fence\n", __FUNCTION__);
      (*DeleteFencesNV)(1, &fence);
      return GL_FALSE;
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Try to read back its current status and condition. */
   (*GetFenceivNV)(fence, GL_FENCE_CONDITION_NV, &fenceCondition);
   if (fenceCondition != GL_ALL_COMPLETED_NV) {
      fprintf(stderr, "%s: expected fence condition 0x%x, got 0x%x\n",
         __FUNCTION__, GL_ALL_COMPLETED_NV, fenceCondition);
      (*DeleteFencesNV)(1, &fence);
      return GL_FALSE;
   }
   (*GetFenceivNV)(fence, GL_FENCE_STATUS_NV, &fenceStatus);
   if (fenceStatus != GL_TRUE && fenceStatus != GL_FALSE) {
      fprintf(stderr,"%s: fence status should be GL_TRUE or GL_FALSE, got 0x%x\n",
         __FUNCTION__, fenceStatus);
      (*DeleteFencesNV)(1, &fence);
      return GL_FALSE;
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Set the fence again, query its status, and wait for it to finish
    * two different ways: once by looping on TestFence(), and a 
    * second time by a simple call to FinishFence();
    */
   (*SetFenceNV)(fence, GL_ALL_COMPLETED_NV);
   glFlush();
   count = 1;
   while (!(*TestFenceNV)(fence)) {
      count++;
      if (count == 0) {
         break;
      }
   }
   if (count == 0) {
      fprintf(stderr, "%s: fence never returned true\n", __FUNCTION__);
      (*DeleteFencesNV)(1, &fence);
      return GL_FALSE;
   }
   (*SetFenceNV)(fence, GL_ALL_COMPLETED_NV);
   (*FinishFenceNV)(fence);
   if ((*TestFenceNV)(fence) != GL_TRUE) {
      fprintf(stderr, "%s: finished fence does not have status GL_TRUE\n",
         __FUNCTION__);
      (*DeleteFencesNV)(1, &fence);
      return GL_FALSE;
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* All done.  Delete the fence and return. */
   (*DeleteFencesNV)(1, &fence);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);
   return GL_TRUE;
}

/**************************************************************************
 * Exercises for buffer objects
 */
enum Map_Buffer_Usage{ Use_Map_Buffer, Use_Map_Buffer_Range};
static GLboolean
exercise_buffer_objects(enum Map_Buffer_Usage usage)
{
#define BUFFER_DATA_SIZE 1024
   GLuint bufferID;
   GLint bufferMapped;
   static GLubyte data[BUFFER_DATA_SIZE] = {0};
   float *dataPtr = NULL;
   const char *extensions = (const char *) glGetString(GL_EXTENSIONS);

   /* Get the function pointers we need.  These are from
    * GL_ARB_vertex_buffer_object and are required in all
    * cases.
    */
   DECLARE_GLFUNC_PTR(GenBuffersARB, PFNGLGENBUFFERSARBPROC);
   DECLARE_GLFUNC_PTR(BindBufferARB, PFNGLBINDBUFFERARBPROC);
   DECLARE_GLFUNC_PTR(BufferDataARB, PFNGLBUFFERDATAARBPROC);
   DECLARE_GLFUNC_PTR(MapBufferARB, PFNGLMAPBUFFERARBPROC);
   DECLARE_GLFUNC_PTR(UnmapBufferARB, PFNGLUNMAPBUFFERARBPROC);
   DECLARE_GLFUNC_PTR(DeleteBuffersARB, PFNGLDELETEBUFFERSARBPROC);
   DECLARE_GLFUNC_PTR(GetBufferParameterivARB, PFNGLGETBUFFERPARAMETERIVARBPROC);

   /* These are from GL_ARB_map_buffer_range, and are optional
    * unless we're given Use_Map_Buffer_Range.  Note that they do *not*
    * have the standard "ARB" suffixes; this is because the extension
    * was introduced *after* a superset was standardized in OpenGL 3.0.
    * (The extension really only exists to allow the functionality on
    * devices that cannot implement a full OpenGL 3.0 driver.)
    */
   DECLARE_GLFUNC_PTR(FlushMappedBufferRange, PFNGLFLUSHMAPPEDBUFFERRANGEPROC);
   DECLARE_GLFUNC_PTR(MapBufferRange, PFNGLMAPBUFFERRANGEPROC);
   
   /* This is from APPLE_flush_buffer_range, and is optional even if
    * we're given Use_Map_Buffer_Range.  Test it before using it.
    */
   DECLARE_GLFUNC_PTR(BufferParameteriAPPLE, PFNGLBUFFERPARAMETERIAPPLEPROC);
   if (!strstr("GL_APPLE_flush_buffer_range", extensions)) {
      BufferParameteriAPPLE = NULL;
   }

   /* Make sure we have all the function pointers we need. */
   if (GenBuffersARB == NULL ||
      BindBufferARB == NULL ||
      BufferDataARB == NULL ||
      MapBufferARB == NULL ||
      UnmapBufferARB == NULL ||
      DeleteBuffersARB == NULL ||
      GetBufferParameterivARB == NULL) {
      fprintf(stderr, "%s: missing basic MapBuffer functions\n", __FUNCTION__);
      return GL_FALSE;
   }
   if (usage == Use_Map_Buffer_Range) {
      if (FlushMappedBufferRange == NULL || MapBufferRange == NULL) {
         fprintf(stderr, "%s: missing MapBufferRange functions\n", __FUNCTION__);
         return GL_FALSE;
      }
   }

   /* Create and define a buffer */
   (*GenBuffersARB)(1, &bufferID);
   (*BindBufferARB)(GL_ARRAY_BUFFER_ARB, bufferID);
   (*BufferDataARB)(GL_ARRAY_BUFFER_ARB, BUFFER_DATA_SIZE, data, 
      GL_DYNAMIC_DRAW_ARB);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* If we're using MapBufferRange, and if the BufferParameteriAPPLE
    * function is present, use it before mapping.  This particular
    * use is a no-op, intended just to exercise the entry point.
    */
   if (usage == Use_Map_Buffer_Range && BufferParameteriAPPLE != NULL) {
      (*BufferParameteriAPPLE)(GL_ARRAY_BUFFER_ARB, 
         GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_TRUE);
   }

   /* Map it, and make sure it's mapped. */
   switch(usage) {
      case Use_Map_Buffer:
         dataPtr = (float *) (*MapBufferARB)(
            GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
         break;
      case Use_Map_Buffer_Range:
         dataPtr = (float *)(*MapBufferRange)(GL_ARRAY_BUFFER_ARB,
            4, 16, GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
         break;
   }
   if (dataPtr == NULL) {
      fprintf(stderr, "%s: %s returned NULL\n", __FUNCTION__,
         usage == Use_Map_Buffer ? "MapBuffer" : "MapBufferRange");
      (*BindBufferARB)(GL_ARRAY_BUFFER_ARB, 0);
      (*DeleteBuffersARB)(1, &bufferID);
      return GL_FALSE;
   }
   (*GetBufferParameterivARB)(GL_ARRAY_BUFFER_ARB, GL_BUFFER_MAPPED_ARB, 
      &bufferMapped);
   if (!bufferMapped) {
      fprintf(stderr, "%s: buffer should be mapped but isn't\n", __FUNCTION__);
      (*BindBufferARB)(GL_ARRAY_BUFFER_ARB, 0);
      (*DeleteBuffersARB)(1, &bufferID);
      return GL_FALSE;
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Write something to it, just to make sure we don't segfault. */
   *dataPtr = 1.5;

   /* Unmap to show we're finished with the buffer.  Note that if we're
    * using MapBufferRange, we first have to flush the range we modified.
    */
   if (usage == Use_Map_Buffer_Range) {
      (*FlushMappedBufferRange)(GL_ARRAY_BUFFER_ARB, 0, 16);
   }
   if (!(*UnmapBufferARB)(GL_ARRAY_BUFFER_ARB)) {
      fprintf(stderr, "%s: UnmapBuffer failed\n", __FUNCTION__);
      (*BindBufferARB)(GL_ARRAY_BUFFER_ARB, 0);
      (*DeleteBuffersARB)(1, &bufferID);
      return GL_FALSE;
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* All done. */
   (*BindBufferARB)(GL_ARRAY_BUFFER_ARB, 0);
   (*DeleteBuffersARB)(1, &bufferID);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);
   return GL_TRUE;

#undef BUFFER_DATA_SIZE
}

/**************************************************************************
 * Exercises for occlusion query
 */
static GLboolean
exercise_occlusion_query(void)
{
   GLuint queryObject;
   GLint queryReady;
   GLuint querySampleCount;
   GLint queryCurrent;
   GLint queryCounterBits;

   /* Get the function pointers we need.  These are from
    * GL_ARB_vertex_buffer_object and are required in all
    * cases.
    */
   DECLARE_GLFUNC_PTR(GenQueriesARB, PFNGLGENQUERIESARBPROC);
   DECLARE_GLFUNC_PTR(BeginQueryARB, PFNGLBEGINQUERYARBPROC);
   DECLARE_GLFUNC_PTR(GetQueryivARB, PFNGLGETQUERYIVARBPROC);
   DECLARE_GLFUNC_PTR(EndQueryARB, PFNGLENDQUERYARBPROC);
   DECLARE_GLFUNC_PTR(IsQueryARB, PFNGLISQUERYARBPROC);
   DECLARE_GLFUNC_PTR(GetQueryObjectivARB, PFNGLGETQUERYOBJECTIVARBPROC);
   DECLARE_GLFUNC_PTR(GetQueryObjectuivARB, PFNGLGETQUERYOBJECTUIVARBPROC);
   DECLARE_GLFUNC_PTR(DeleteQueriesARB, PFNGLDELETEQUERIESARBPROC);

   /* Make sure we have all the function pointers we need. */
   if (GenQueriesARB == NULL ||
      BeginQueryARB == NULL ||
      GetQueryivARB == NULL ||
      EndQueryARB == NULL ||
      IsQueryARB == NULL ||
      GetQueryObjectivARB == NULL ||
      GetQueryObjectuivARB == NULL ||
      DeleteQueriesARB == NULL) {
      fprintf(stderr, "%s: don't have all the Query functions\n", __FUNCTION__);
      return GL_FALSE;
   }

   /* Create a query object, and start a query. */
   (*GenQueriesARB)(1, &queryObject);
   (*BeginQueryARB)(GL_SAMPLES_PASSED_ARB, queryObject);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* While we're in the query, check the functions that are supposed
    * to return which query we're in and how many bits of resolution
    * we get.
    */
   (*GetQueryivARB)(GL_SAMPLES_PASSED_ARB, GL_CURRENT_QUERY_ARB, &queryCurrent);
   if (queryCurrent != queryObject) {
      fprintf(stderr, "%s: current query 0x%x != set query 0x%x\n",
         __FUNCTION__, queryCurrent, queryObject);
      (*EndQueryARB)(GL_SAMPLES_PASSED_ARB);
      (*DeleteQueriesARB)(1, &queryObject);
      return GL_FALSE;
   }
   (*GetQueryivARB)(GL_SAMPLES_PASSED_ARB, GL_QUERY_COUNTER_BITS_ARB, 
      &queryCounterBits);
   if (queryCounterBits < 1) {
      fprintf(stderr, "%s: query counter bits is too small (%d)\n",
         __FUNCTION__, queryCounterBits);
      (*EndQueryARB)(GL_SAMPLES_PASSED_ARB);
      (*DeleteQueriesARB)(1, &queryObject);
      return GL_FALSE;
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Finish up the query.  Since we didn't draw anything, the result
    * should be 0 passed samples.
    */
   (*EndQueryARB)(GL_SAMPLES_PASSED_ARB);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Routine existence test */
   if (!(*IsQueryARB)(queryObject)) {
      fprintf(stderr, "%s: query object 0x%x fails existence test\n",
         __FUNCTION__, queryObject);
      (*DeleteQueriesARB)(1, &queryObject);
      return GL_FALSE;
   }

   /* Loop until the query is ready, then get back the result.  We use
    * the signed query for the boolean value of whether the result is
    * available, but the unsigned query to actually pull the result;
    * this is just to test both entrypoints, but in a real query you may
    * need the extra bit of resolution.
    */
   queryReady = GL_FALSE;
   do {
      (*GetQueryObjectivARB)(queryObject, GL_QUERY_RESULT_AVAILABLE_ARB, 
         &queryReady);
   } while (!queryReady);
   (*GetQueryObjectuivARB)(queryObject, GL_QUERY_RESULT_ARB, &querySampleCount);
   (*DeleteQueriesARB)(1, &queryObject);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* If sample count isn't 0, something's funny. */
   if (querySampleCount > 0) {
      fprintf(stderr, "%s: expected query result of 0, got %ud\n",
         __FUNCTION__, querySampleCount);
      return GL_FALSE;
   }

   /* Here, all is well. */
   return GL_TRUE;
}

/**************************************************************************
 * 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 significant.  The getprocaddress.py script
 * scans this file and extracts these function names.
 */

static GLboolean
test_WeightPointerARB(generic_func func)
{
   /* Assume we have at least 2 vertex units (or this extension makes
    * no sense), and establish a set of 2-element vector weights.
    * We use floats that can be represented exactly in binary
    * floating point formats so we can compare correctly later.
    * We also make sure the 0th entry matches the default weights,
    * so we can restore the default easily.
    */
#define USE_VERTEX_UNITS 2
#define USE_WEIGHT_INDEX 3
   static GLfloat weights[] = {
      1.0,   0.0,
      0.875, 0.125,
      0.75,  0.25,
      0.625, 0.375,
      0.5,   0.5,
      0.375, 0.625,
      0.25,  0.75,
      0.125, 0.875, 
      0.0,   1.0,
   };
   GLint numVertexUnits;
   GLfloat *currentWeights;
   int i;
   int errorCount = 0;

   PFNGLWEIGHTPOINTERARBPROC WeightPointerARB = (PFNGLWEIGHTPOINTERARBPROC) func;

   /* Make sure we have at least two vertex units */
   glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &numVertexUnits);
   if (numVertexUnits < USE_VERTEX_UNITS) {
      fprintf(stderr, "%s: need %d vertex units, got %d\n", 
         __FUNCTION__, USE_VERTEX_UNITS, numVertexUnits);
      return GL_FALSE;
   }
   
   /* Make sure we allocate enough room to query all the current weights */
   currentWeights = (GLfloat *)malloc(numVertexUnits * sizeof(GLfloat));
   if (currentWeights == NULL) {
      fprintf(stderr, "%s: couldn't allocate room for %d floats\n",
         __FUNCTION__, numVertexUnits);
      return GL_FALSE;
   }

   /* Set up the pointer, enable the state, and try to send down a
    * weight vector (we'll arbitrarily send index 2).
    */
   (*WeightPointerARB)(USE_VERTEX_UNITS, GL_FLOAT, 0, weights);
   glEnableClientState(GL_WEIGHT_ARRAY_ARB);
   glArrayElement(USE_WEIGHT_INDEX);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Verify that it changed the current state. */
   glGetFloatv(GL_CURRENT_WEIGHT_ARB, currentWeights);
   for (i = 0; i < numVertexUnits; i++) {
      if (i < USE_VERTEX_UNITS) {
         /* This is one of the units we explicitly set. */
         if (currentWeights[i] != weights[USE_VERTEX_UNITS*USE_WEIGHT_INDEX + i]) {
            fprintf(stderr, "%s: current weight at index %d is %f, should be %f\n",
               __FUNCTION__, i, currentWeights[i], 
               weights[USE_VERTEX_UNITS*USE_WEIGHT_INDEX + i]);
            errorCount++;
         }
      }
      else {
         /* All other weights should be 0. */
         if (currentWeights[i] != 0.0) {
            fprintf(stderr, "%s: current weight at index %d is %f, should be %f\n",
               __FUNCTION__, i, 0.0,
               weights[USE_VERTEX_UNITS*USE_WEIGHT_INDEX + i]);
            errorCount++;
         }
      }
   }
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Restore the old state.  We know the default set of weights is in
    * index 0.
    */
   glArrayElement(0);
   glDisableClientState(GL_WEIGHT_ARRAY_ARB);
   (*WeightPointerARB)(0, GL_FLOAT, 0, NULL);
   free(currentWeights);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* We're fine if we didn't get any mismatches. */
   if (errorCount == 0) {
      return GL_TRUE;
   }
   else {
      return GL_FALSE;
   }
}

/* Wrappers on the exercise_occlusion_query function */
static GLboolean
test_GenQueriesARB(generic_func func)
{
   (void) func;
   return exercise_occlusion_query();
}
static GLboolean
test_BeginQueryARB(generic_func func)
{
   (void) func;
   return exercise_occlusion_query();
}
static GLboolean
test_GetQueryivARB(generic_func func)
{
   (void) func;
   return exercise_occlusion_query();
}
static GLboolean
test_EndQueryARB(generic_func func)
{
   (void) func;
   return exercise_occlusion_query();
}
static GLboolean
test_IsQueryARB(generic_func func)
{
   (void) func;
   return exercise_occlusion_query();
}
static GLboolean
test_GetQueryObjectivARB(generic_func func)
{
   (void) func;
   return exercise_occlusion_query();
}
static GLboolean
test_GetQueryObjectuivARB(generic_func func)
{
   (void) func;
   return exercise_occlusion_query();
}
static GLboolean
test_DeleteQueriesARB(generic_func func)
{
   (void) func;
   return exercise_occlusion_query();
}

/* Wrappers on the exercise_buffer_objects() function */
static GLboolean
test_GenBuffersARB(generic_func func)
{
   (void) func;
   return exercise_buffer_objects(Use_Map_Buffer);
}
static GLboolean
test_BindBufferARB(generic_func func)
{
   (void) func;
   return exercise_buffer_objects(Use_Map_Buffer);
}
static GLboolean
test_BufferDataARB(generic_func func)
{
   (void) func;
   return exercise_buffer_objects(Use_Map_Buffer);
}
static GLboolean
test_MapBufferARB(generic_func func)
{
   (void) func;
   return exercise_buffer_objects(Use_Map_Buffer);
}
static GLboolean
test_UnmapBufferARB(generic_func func)
{
   (void) func;
   return exercise_buffer_objects(Use_Map_Buffer);
}
static GLboolean
test_DeleteBuffersARB(generic_func func)
{
   (void) func;
   return exercise_buffer_objects(Use_Map_Buffer);
}
static GLboolean
test_GetBufferParameterivARB(generic_func func)
{
   (void) func;
   return exercise_buffer_objects(Use_Map_Buffer);
}
static GLboolean
test_FlushMappedBufferRange(generic_func func)
{
   (void) func;
   return exercise_buffer_objects(Use_Map_Buffer_Range);
}
static GLboolean
test_MapBufferRange(generic_func func)
{
   (void) func;
   return exercise_buffer_objects(Use_Map_Buffer_Range);
}
static GLboolean
test_BufferParameteriAPPLE(generic_func func)
{
   (void) func;
   return exercise_buffer_objects(Use_Map_Buffer_Range);
}

/* Wrappers on the exercise_framebuffer() function */
static GLboolean
test_BindFramebufferEXT(generic_func func)
{
   (void) func;
   return exercise_framebuffer();
}
static GLboolean
test_BindRenderbufferEXT(generic_func func)
{
   (void) func;
   return exercise_framebuffer();
}
static GLboolean
test_CheckFramebufferStatusEXT(generic_func func)
{
   (void) func;
   return exercise_framebuffer();
}
static GLboolean
test_DeleteFramebuffersEXT(generic_func func)
{
   (void) func;
   return exercise_framebuffer();
}
static GLboolean
test_DeleteRenderbuffersEXT(generic_func func)
{
   (void) func;
   return exercise_framebuffer();
}
static GLboolean
test_FramebufferRenderbufferEXT(generic_func func)
{
   (void) func;
   return exercise_framebuffer();
}
static GLboolean
test_GenFramebuffersEXT(generic_func func)
{
   (void) func;
   return exercise_framebuffer();
}
static GLboolean
test_GenRenderbuffersEXT(generic_func func)
{
   (void) func;
   return exercise_framebuffer();
}
static GLboolean
test_IsFramebufferEXT(generic_func func)
{
   (void) func;
   return exercise_framebuffer();
}
static GLboolean
test_IsRenderbufferEXT(generic_func func)
{
   (void) func;
   return exercise_framebuffer();
}
static GLboolean
test_RenderbufferStorageEXT(generic_func func)
{
   (void) func;
   return exercise_framebuffer();
}
static GLboolean
test_BlitFramebufferEXT(generic_func func)
{
   (void) func;
   return exercise_framebuffer();
}

/* These are wrappers on the exercise_CompressedTextures function. 
 * Unfortunately, we cannot test the 1D counterparts, because the
 * texture compressions available all support 2D and higher only.
 */
static GLboolean
test_CompressedTexImage2DARB(generic_func func)
{
   (void) func;
   return exercise_CompressedTextures(GL_TEXTURE_2D);
}
static GLboolean
test_CompressedTexSubImage2DARB(generic_func func)
{
   (void) func;
   return exercise_CompressedTextures(GL_TEXTURE_2D);
}
static GLboolean
test_CompressedTexImage3DARB(generic_func func)
{
   (void) func;
   return exercise_CompressedTextures(GL_TEXTURE_3D);
}
static GLboolean
test_CompressedTexSubImage3DARB(generic_func func)
{
   (void) func;
   return exercise_CompressedTextures(GL_TEXTURE_3D);
}
static GLboolean
test_GetCompressedTexImageARB(generic_func func)
{
   (void) func;
   return exercise_CompressedTextures(GL_TEXTURE_3D);
}

/* Wrappers on exercise_fences(). */
static GLboolean
test_DeleteFencesNV(generic_func func)
{
   (void) func;
   return exercise_fences();
}
static GLboolean
test_GenFencesNV(generic_func func)
{
   (void) func;
   return exercise_fences();
}
static GLboolean
test_SetFenceNV(generic_func func)
{
   (void) func;
   return exercise_fences();
}
static GLboolean
test_TestFenceNV(generic_func func)
{
   (void) func;
   return exercise_fences();
}
static GLboolean
test_FinishFenceNV(generic_func func)
{
   (void) func;
   return exercise_fences();
}
static GLboolean
test_GetFenceivNV(generic_func func)
{
   (void) func;
   return exercise_fences();
}
static GLboolean
test_IsFenceNV(generic_func func)
{
   (void) func;
   return exercise_fences();
}

/* A bunch of glUniform*() tests */
static GLboolean
test_Uniform1iv(generic_func func)
{
   PFNGLUNIFORM1IVARBPROC Uniform1ivARB = (PFNGLUNIFORM1IVARBPROC) func;
   DECLARE_GLFUNC_PTR(GetUniformivARB, PFNGLGETUNIFORMIVARBPROC);

   /* This is a trivial fragment shader that sets the color of the
    * fragment to the uniform value passed in.
    */
   static const char *fragmentShaderText = 
      "uniform int uniformColor;" 
      "void main() {gl_FragColor.r = uniformColor;}";
   static const char *uniformName = "uniformColor";

   GLhandleARB program;
   GLint uniformLocation;
   const GLint uniform[1] = {1};
   GLint queriedUniform[1];

   if (GetUniformivARB == NULL) {
      return GL_FALSE;
   }

   /* Call a helper function to compile up the shader and give
    * us back the validated program and uniform location.
    * If it fails, something's wrong and we can't continue.
    */
   if (!exercise_uniform_start(fragmentShaderText, uniformName, 
      &program, &uniformLocation)) {
      return GL_FALSE;
   }

   /* Set the value of the program uniform.  Note that you must
    * use a compatible type.  Our uniform above is an integer
    * so we must set it using integer versions
    * of the Uniform* functions.  The "1" means we're setting
    * one vector's worth of information.
    */
   (*Uniform1ivARB)(uniformLocation, 1, uniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Query it back */
   (*GetUniformivARB)(program, uniformLocation, queriedUniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Clean up before we check to see whether it came back unscathed */
   exercise_uniform_end(program);

   /* Now check to see whether the uniform came back as expected.  This
    * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed.
    */
   return compare_ints(__FUNCTION__, 1, uniform, 1, queriedUniform);
}

static GLboolean
test_Uniform1i(generic_func func)
{
   PFNGLUNIFORM1IARBPROC Uniform1iARB = (PFNGLUNIFORM1IARBPROC) func;
   DECLARE_GLFUNC_PTR(GetUniformivARB, PFNGLGETUNIFORMIVARBPROC);

   /* This is a trivial fragment shader that sets the color of the
    * fragment to the uniform value passed in.
    */
   static const char *fragmentShaderText = 
      "uniform int uniformColor;"
      "void main() {gl_FragColor.r = uniformColor;}";
   static const char *uniformName = "uniformColor";

   GLhandleARB program;
   GLint uniformLocation;
   const GLint uniform[1] = {1};
   GLint queriedUniform[4];

   if (GetUniformivARB == NULL) {
      return GL_FALSE;
   }

   /* Call a helper function to compile up the shader and give
    * us back the validated program and uniform location.
    * If it fails, something's wrong and we can't continue.
    */
   if (!exercise_uniform_start(fragmentShaderText, uniformName, 
      &program, &uniformLocation)) {
      return GL_FALSE;
   }

   /* Set the value of the program uniform.  Note that you must
    * use a compatible type.  Our uniform above is an integer
    * so we must set it using integer versions
    * of the Uniform* functions.
    */
   (*Uniform1iARB)(uniformLocation, uniform[0]);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Query it back */
   (*GetUniformivARB)(program, uniformLocation, queriedUniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Clean up before we check to see whether it came back unscathed */
   exercise_uniform_end(program);

   /* Now check to see whether the uniform came back as expected.  This
    * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed.
    */
   return compare_ints(__FUNCTION__, 1, uniform, 1, queriedUniform);
}

static GLboolean
test_Uniform1fv(generic_func func)
{
   PFNGLUNIFORM1FVARBPROC Uniform1fvARB = (PFNGLUNIFORM1FVARBPROC) func;
   DECLARE_GLFUNC_PTR(GetUniformfvARB, PFNGLGETUNIFORMFVARBPROC);

   /* This is a trivial fragment shader that sets the color of the
    * fragment to the uniform value passed in.
    */
   static const char *fragmentShaderText = 
      "uniform float uniformColor;"
      "void main() {gl_FragColor.r = uniformColor;}";
   static const char *uniformName = "uniformColor";

   GLhandleARB program;
   GLint uniformLocation;
   const GLfloat uniform[1] = {1.1};
   GLfloat queriedUniform[1];

   if (GetUniformfvARB == NULL) {
      return GL_FALSE;
   }

   /* Call a helper function to compile up the shader and give
    * us back the validated program and uniform location.
    * If it fails, something's wrong and we can't continue.
    */
   if (!exercise_uniform_start(fragmentShaderText, uniformName, 
      &program, &uniformLocation)) {
      return GL_FALSE;
   }

   /* Set the value of the program uniform.  Note that you must
    * use a compatible type.  Our uniform above is a float
    * so we must set it using float versions
    * of the Uniform* functions.  The "1" means we're setting
    * one vector's worth of information.
    */
   (*Uniform1fvARB)(uniformLocation, 1, uniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Query it back */
   (*GetUniformfvARB)(program, uniformLocation, queriedUniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Clean up before we check to see whether it came back unscathed */
   exercise_uniform_end(program);

   /* Now check to see whether the uniform came back as expected.  This
    * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed.
    */
   return compare_floats(__FUNCTION__, 1, uniform, 1, queriedUniform);
}

static GLboolean
test_Uniform1f(generic_func func)
{
   PFNGLUNIFORM1FARBPROC Uniform1fARB = (PFNGLUNIFORM1FARBPROC) func;
   DECLARE_GLFUNC_PTR(GetUniformfvARB, PFNGLGETUNIFORMFVARBPROC);

   /* This is a trivial fragment shader that sets the color of the
    * fragment to the uniform value passed in.
    */
   static const char *fragmentShaderText = 
      "uniform float uniformColor;"
      "void main() {gl_FragColor.r = uniformColor;}";
   static const char *uniformName = "uniformColor";

   GLhandleARB program;
   GLint uniformLocation;
   const GLfloat uniform[1] = {1.1};
   GLfloat queriedUniform[1];

   if (GetUniformfvARB == NULL) {
      return GL_FALSE;
   }

   /* Call a helper function to compile up the shader and give
    * us back the validated program and uniform location.
    * If it fails, something's wrong and we can't continue.
    */
   if (!exercise_uniform_start(fragmentShaderText, uniformName, 
      &program, &uniformLocation)) {
      return GL_FALSE;
   }

   /* Set the value of the program uniform.  Note that you must
    * use a compatible type.  Our uniform above is a float
    * so we must set it using float versions
    * of the Uniform* functions.
    */
   (*Uniform1fARB)(uniformLocation, uniform[0]);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Query it back */
   (*GetUniformfvARB)(program, uniformLocation, queriedUniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Clean up before we check to see whether it came back unscathed */
   exercise_uniform_end(program);

   /* Now check to see whether the uniform came back as expected.  This
    * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed.
    */
   return compare_floats(__FUNCTION__, 1, uniform, 1, queriedUniform);
}

static GLboolean
test_Uniform2iv(generic_func func)
{
   PFNGLUNIFORM2IVARBPROC Uniform2ivARB = (PFNGLUNIFORM2IVARBPROC) func;
   DECLARE_GLFUNC_PTR(GetUniformivARB, PFNGLGETUNIFORMIVARBPROC);

   /* This is a trivial fragment shader that sets the color of the
    * fragment to the uniform value passed in.
    */
   static const char *fragmentShaderText = 
      "uniform ivec2 uniformColor;" 
      "void main() {gl_FragColor.rg = uniformColor;}";
   static const char *uniformName = "uniformColor";

   GLhandleARB program;
   GLint uniformLocation;
   const GLint uniform[2] = {1,2};
   GLint queriedUniform[2];

   if (GetUniformivARB == NULL) {
      return GL_FALSE;
   }

   /* Call a helper function to compile up the shader and give
    * us back the validated program and uniform location.
    * If it fails, something's wrong and we can't continue.
    */
   if (!exercise_uniform_start(fragmentShaderText, uniformName, 
      &program, &uniformLocation)) {
      return GL_FALSE;
   }

   /* Set the value of the program uniform.  Note that you must
    * use a compatible type.  Our uniform above is an integer
    * vector 2 (ivec2), so we must set it using integer versions
    * of the Uniform* functions.  The "1" means we're setting
    * one vector's worth of information.
    */
   (*Uniform2ivARB)(uniformLocation, 1, uniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Query it back */
   (*GetUniformivARB)(program, uniformLocation, queriedUniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Clean up before we check to see whether it came back unscathed */
   exercise_uniform_end(program);

   /* Now check to see whether the uniform came back as expected.  This
    * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed.
    */
   return compare_ints(__FUNCTION__, 2, uniform, 2, queriedUniform);
}

static GLboolean
test_Uniform2i(generic_func func)
{
   PFNGLUNIFORM2IARBPROC Uniform2iARB = (PFNGLUNIFORM2IARBPROC) func;
   DECLARE_GLFUNC_PTR(GetUniformivARB, PFNGLGETUNIFORMIVARBPROC);

   /* This is a trivial fragment shader that sets the color of the
    * fragment to the uniform value passed in.
    */
   static const char *fragmentShaderText = 
      "uniform ivec2 uniformColor;"
      "void main() {gl_FragColor.rg = uniformColor;}";
   static const char *uniformName = "uniformColor";

   GLhandleARB program;
   GLint uniformLocation;
   const GLint uniform[2] = {1,2};
   GLint queriedUniform[4];

   if (GetUniformivARB == NULL) {
      return GL_FALSE;
   }

   /* Call a helper function to compile up the shader and give
    * us back the validated program and uniform location.
    * If it fails, something's wrong and we can't continue.
    */
   if (!exercise_uniform_start(fragmentShaderText, uniformName, 
      &program, &uniformLocation)) {
      return GL_FALSE;
   }

   /* Set the value of the program uniform.  Note that you must
    * use a compatible type.  Our uniform above is an integer
    * vector 2 (ivec2), so we must set it using integer versions
    * of the Uniform* functions.
    */
   (*Uniform2iARB)(uniformLocation, uniform[0], uniform[1]);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Query it back */
   (*GetUniformivARB)(program, uniformLocation, queriedUniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Clean up before we check to see whether it came back unscathed */
   exercise_uniform_end(program);

   /* Now check to see whether the uniform came back as expected.  This
    * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed.
    */
   return compare_ints(__FUNCTION__, 2, uniform, 2, queriedUniform);
}

static GLboolean
test_Uniform2fv(generic_func func)
{
   PFNGLUNIFORM2FVARBPROC Uniform2fvARB = (PFNGLUNIFORM2FVARBPROC) func;
   DECLARE_GLFUNC_PTR(GetUniformfvARB, PFNGLGETUNIFORMFVARBPROC);

   /* This is a trivial fragment shader that sets the color of the
    * fragment to the uniform value passed in.
    */
   static const char *fragmentShaderText = 
      "uniform vec2 uniformColor;"
      "void main() {gl_FragColor.rg = uniformColor;}";
   static const char *uniformName = "uniformColor";

   GLhandleARB program;
   GLint uniformLocation;
   const GLfloat uniform[2] = {1.1,2.2};
   GLfloat queriedUniform[2];

   if (GetUniformfvARB == NULL) {
      return GL_FALSE;
   }

   /* Call a helper function to compile up the shader and give
    * us back the validated program and uniform location.
    * If it fails, something's wrong and we can't continue.
    */
   if (!exercise_uniform_start(fragmentShaderText, uniformName, 
      &program, &uniformLocation)) {
      return GL_FALSE;
   }

   /* Set the value of the program uniform.  Note that you must
    * use a compatible type.  Our uniform above is a float
    * vector 2 (vec2), so we must set it using float versions
    * of the Uniform* functions.  The "1" means we're setting
    * one vector's worth of information.
    */
   (*Uniform2fvARB)(uniformLocation, 1, uniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Query it back */
   (*GetUniformfvARB)(program, uniformLocation, queriedUniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Clean up before we check to see whether it came back unscathed */
   exercise_uniform_end(program);

   /* Now check to see whether the uniform came back as expected.  This
    * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed.
    */
   return compare_floats(__FUNCTION__, 2, uniform, 2, queriedUniform);
}

static GLboolean
test_Uniform2f(generic_func func)
{
   PFNGLUNIFORM2FARBPROC Uniform2fARB = (PFNGLUNIFORM2FARBPROC) func;
   DECLARE_GLFUNC_PTR(GetUniformfvARB, PFNGLGETUNIFORMFVARBPROC);

   /* This is a trivial fragment shader that sets the color of the
    * fragment to the uniform value passed in.
    */
   static const char *fragmentShaderText = 
      "uniform vec2 uniformColor;"
      "void main() {gl_FragColor.rg = uniformColor;}";
   static const char *uniformName = "uniformColor";

   GLhandleARB program;
   GLint uniformLocation;
   const GLfloat uniform[2] = {1.1,2.2};
   GLfloat queriedUniform[2];

   if (GetUniformfvARB == NULL) {
      return GL_FALSE;
   }

   /* Call a helper function to compile up the shader and give
    * us back the validated program and uniform location.
    * If it fails, something's wrong and we can't continue.
    */
   if (!exercise_uniform_start(fragmentShaderText, uniformName, 
      &program, &uniformLocation)) {
      return GL_FALSE;
   }

   /* Set the value of the program uniform.  Note that you must
    * use a compatible type.  Our uniform above is a float
    * vector 2 (vec2), so we must set it using float versions
    * of the Uniform* functions.
    */
   (*Uniform2fARB)(uniformLocation, uniform[0], uniform[1]);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Query it back */
   (*GetUniformfvARB)(program, uniformLocation, queriedUniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Clean up before we check to see whether it came back unscathed */
   exercise_uniform_end(program);

   /* Now check to see whether the uniform came back as expected.  This
    * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed.
    */
   return compare_floats(__FUNCTION__, 2, uniform, 2, queriedUniform);
}

static GLboolean
test_Uniform3iv(generic_func func)
{
   PFNGLUNIFORM3IVARBPROC Uniform3ivARB = (PFNGLUNIFORM3IVARBPROC) func;
   DECLARE_GLFUNC_PTR(GetUniformivARB, PFNGLGETUNIFORMIVARBPROC);

   /* This is a trivial fragment shader that sets the color of the
    * fragment to the uniform value passed in.
    */
   static const char *fragmentShaderText = 
      "uniform ivec3 uniformColor;" 
      "void main() {gl_FragColor.rgb = uniformColor;}";
   static const char *uniformName = "uniformColor";

   GLhandleARB program;
   GLint uniformLocation;
   const GLint uniform[3] = {1,2,3};
   GLint queriedUniform[3];

   if (GetUniformivARB == NULL) {
      return GL_FALSE;
   }

   /* Call a helper function to compile up the shader and give
    * us back the validated program and uniform location.
    * If it fails, something's wrong and we can't continue.
    */
   if (!exercise_uniform_start(fragmentShaderText, uniformName, 
      &program, &uniformLocation)) {
      return GL_FALSE;
   }

   /* Set the value of the program uniform.  Note that you must
    * use a compatible type.  Our uniform above is an integer
    * vector 3 (ivec3), so we must set it using integer versions
    * of the Uniform* functions.  The "1" means we're setting
    * one vector's worth of information.
    */
   (*Uniform3ivARB)(uniformLocation, 1, uniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Query it back */
   (*GetUniformivARB)(program, uniformLocation, queriedUniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Clean up before we check to see whether it came back unscathed */
   exercise_uniform_end(program);

   /* Now check to see whether the uniform came back as expected.  This
    * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed.
    */
   return compare_ints(__FUNCTION__, 3, uniform, 3, queriedUniform);
}

static GLboolean
test_Uniform3i(generic_func func)
{
   PFNGLUNIFORM3IARBPROC Uniform3iARB = (PFNGLUNIFORM3IARBPROC) func;
   DECLARE_GLFUNC_PTR(GetUniformivARB, PFNGLGETUNIFORMIVARBPROC);

   /* This is a trivial fragment shader that sets the color of the
    * fragment to the uniform value passed in.
    */
   static const char *fragmentShaderText = 
      "uniform ivec3 uniformColor;"
      "void main() {gl_FragColor.rgb = uniformColor;}";
   static const char *uniformName = "uniformColor";

   GLhandleARB program;
   GLint uniformLocation;
   const GLint uniform[3] = {1,2,3};
   GLint queriedUniform[4];

   if (GetUniformivARB == NULL) {
      return GL_FALSE;
   }

   /* Call a helper function to compile up the shader and give
    * us back the validated program and uniform location.
    * If it fails, something's wrong and we can't continue.
    */
   if (!exercise_uniform_start(fragmentShaderText, uniformName, 
      &program, &uniformLocation)) {
      return GL_FALSE;
   }

   /* Set the value of the program uniform.  Note that you must
    * use a compatible type.  Our uniform above is an integer
    * vector 3 (ivec3), so we must set it using integer versions
    * of the Uniform* functions.
    */
   (*Uniform3iARB)(uniformLocation, uniform[0], uniform[1], uniform[2]);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Query it back */
   (*GetUniformivARB)(program, uniformLocation, queriedUniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Clean up before we check to see whether it came back unscathed */
   exercise_uniform_end(program);

   /* Now check to see whether the uniform came back as expected.  This
    * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed.
    */
   return compare_ints(__FUNCTION__, 3, uniform, 3, queriedUniform);
}

static GLboolean
test_Uniform3fv(generic_func func)
{
   PFNGLUNIFORM3FVARBPROC Uniform3fvARB = (PFNGLUNIFORM3FVARBPROC) func;
   DECLARE_GLFUNC_PTR(GetUniformfvARB, PFNGLGETUNIFORMFVARBPROC);

   /* This is a trivial fragment shader that sets the color of the
    * fragment to the uniform value passed in.
    */
   static const char *fragmentShaderText = 
      "uniform vec3 uniformColor;"
      "void main() {gl_FragColor.rgb = uniformColor;}";
   static const char *uniformName = "uniformColor";

   GLhandleARB program;
   GLint uniformLocation;
   const GLfloat uniform[3] = {1.1,2.2,3.3};
   GLfloat queriedUniform[3];

   if (GetUniformfvARB == NULL) {
      return GL_FALSE;
   }

   /* Call a helper function to compile up the shader and give
    * us back the validated program and uniform location.
    * If it fails, something's wrong and we can't continue.
    */
   if (!exercise_uniform_start(fragmentShaderText, uniformName, 
      &program, &uniformLocation)) {
      return GL_FALSE;
   }

   /* Set the value of the program uniform.  Note that you must
    * use a compatible type.  Our uniform above is a float
    * vector 3 (vec3), so we must set it using float versions
    * of the Uniform* functions.  The "1" means we're setting
    * one vector's worth of information.
    */
   (*Uniform3fvARB)(uniformLocation, 1, uniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Query it back */
   (*GetUniformfvARB)(program, uniformLocation, queriedUniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Clean up before we check to see whether it came back unscathed */
   exercise_uniform_end(program);

   /* Now check to see whether the uniform came back as expected.  This
    * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed.
    */
   return compare_floats(__FUNCTION__, 3, uniform, 3, queriedUniform);
}

static GLboolean
test_Uniform3f(generic_func func)
{
   PFNGLUNIFORM3FARBPROC Uniform3fARB = (PFNGLUNIFORM3FARBPROC) func;
   DECLARE_GLFUNC_PTR(GetUniformfvARB, PFNGLGETUNIFORMFVARBPROC);

   /* This is a trivial fragment shader that sets the color of the
    * fragment to the uniform value passed in.
    */
   static const char *fragmentShaderText = 
      "uniform vec3 uniformColor;"
      "void main() {gl_FragColor.rgb = uniformColor;}";
   static const char *uniformName = "uniformColor";

   GLhandleARB program;
   GLint uniformLocation;
   const GLfloat uniform[3] = {1.1,2.2,3.3};
   GLfloat queriedUniform[3];

   if (GetUniformfvARB == NULL) {
      return GL_FALSE;
   }

   /* Call a helper function to compile up the shader and give
    * us back the validated program and uniform location.
    * If it fails, something's wrong and we can't continue.
    */
   if (!exercise_uniform_start(fragmentShaderText, uniformName, 
      &program, &uniformLocation)) {
      return GL_FALSE;
   }

   /* Set the value of the program uniform.  Note that you must
    * use a compatible type.  Our uniform above is a float
    * vector 3 (vec3), so we must set it using float versions
    * of the Uniform* functions.
    */
   (*Uniform3fARB)(uniformLocation, uniform[0], uniform[1], uniform[2]);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Query it back */
   (*GetUniformfvARB)(program, uniformLocation, queriedUniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Clean up before we check to see whether it came back unscathed */
   exercise_uniform_end(program);

   /* Now check to see whether the uniform came back as expected.  This
    * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed.
    */
   return compare_floats(__FUNCTION__, 3, uniform, 3, queriedUniform);
}

static GLboolean
test_Uniform4iv(generic_func func)
{
   PFNGLUNIFORM4IVARBPROC Uniform4ivARB = (PFNGLUNIFORM4IVARBPROC) func;
   DECLARE_GLFUNC_PTR(GetUniformivARB, PFNGLGETUNIFORMIVARBPROC);

   /* This is a trivial fragment shader that sets the color of the
    * fragment to the uniform value passed in.
    */
   static const char *fragmentShaderText = 
      "uniform ivec4 uniformColor; void main() {gl_FragColor = uniformColor;}";
   static const char *uniformName = "uniformColor";

   GLhandleARB program;
   GLint uniformLocation;
   const GLint uniform[4] = {1,2,3,4};
   GLint queriedUniform[4];

   if (GetUniformivARB == NULL) {
      return GL_FALSE;
   }

   /* Call a helper function to compile up the shader and give
    * us back the validated program and uniform location.
    * If it fails, something's wrong and we can't continue.
    */
   if (!exercise_uniform_start(fragmentShaderText, uniformName, 
      &program, &uniformLocation)) {
      return GL_FALSE;
   }

   /* Set the value of the program uniform.  Note that you must
    * use a compatible type.  Our uniform above is an integer
    * vector (ivec4), so we must set it using integer versions
    * of the Uniform* functions.  The "1" means we're setting
    * one vector's worth of information.
    */
   (*Uniform4ivARB)(uniformLocation, 1, uniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Query it back */
   (*GetUniformivARB)(program, uniformLocation, queriedUniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Clean up before we check to see whether it came back unscathed */
   exercise_uniform_end(program);

   /* Now check to see whether the uniform came back as expected.  This
    * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed.
    */
   return compare_ints(__FUNCTION__, 4, uniform, 4, queriedUniform);
}

static GLboolean
test_Uniform4i(generic_func func)
{
   PFNGLUNIFORM4IARBPROC Uniform4iARB = (PFNGLUNIFORM4IARBPROC) func;
   DECLARE_GLFUNC_PTR(GetUniformivARB, PFNGLGETUNIFORMIVARBPROC);

   /* This is a trivial fragment shader that sets the color of the
    * fragment to the uniform value passed in.
    */
   static const char *fragmentShaderText = 
      "uniform ivec4 uniformColor; void main() {gl_FragColor = uniformColor;}";
   static const char *uniformName = "uniformColor";

   GLhandleARB program;
   GLint uniformLocation;
   const GLint uniform[4] = {1,2,3,4};
   GLint queriedUniform[4];

   if (GetUniformivARB == NULL) {
      return GL_FALSE;
   }

   /* Call a helper function to compile up the shader and give
    * us back the validated program and uniform location.
    * If it fails, something's wrong and we can't continue.
    */
   if (!exercise_uniform_start(fragmentShaderText, uniformName, 
      &program, &uniformLocation)) {
      return GL_FALSE;
   }

   /* Set the value of the program uniform.  Note that you must
    * use a compatible type.  Our uniform above is an integer
    * vector (ivec4), so we must set it using integer versions
    * of the Uniform* functions.
    */
   (*Uniform4iARB)(uniformLocation, uniform[0], uniform[1], uniform[2],
      uniform[3]);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Query it back */
   (*GetUniformivARB)(program, uniformLocation, queriedUniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Clean up before we check to see whether it came back unscathed */
   exercise_uniform_end(program);

   /* Now check to see whether the uniform came back as expected.  This
    * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed.
    */
   return compare_ints(__FUNCTION__, 4, uniform, 4, queriedUniform);
}

static GLboolean
test_Uniform4fv(generic_func func)
{
   PFNGLUNIFORM4FVARBPROC Uniform4fvARB = (PFNGLUNIFORM4FVARBPROC) func;
   DECLARE_GLFUNC_PTR(GetUniformfvARB, PFNGLGETUNIFORMFVARBPROC);

   /* This is a trivial fragment shader that sets the color of the
    * fragment to the uniform value passed in.
    */
   static const char *fragmentShaderText = 
      "uniform vec4 uniformColor; void main() {gl_FragColor = uniformColor;}";
   static const char *uniformName = "uniformColor";

   GLhandleARB program;
   GLint uniformLocation;
   const GLfloat uniform[4] = {1.1,2.2,3.3,4.4};
   GLfloat queriedUniform[4];

   if (GetUniformfvARB == NULL) {
      return GL_FALSE;
   }

   /* Call a helper function to compile up the shader and give
    * us back the validated program and uniform location.
    * If it fails, something's wrong and we can't continue.
    */
   if (!exercise_uniform_start(fragmentShaderText, uniformName, 
      &program, &uniformLocation)) {
      return GL_FALSE;
   }

   /* Set the value of the program uniform.  Note that you must
    * use a compatible type.  Our uniform above is a float
    * vector (vec4), so we must set it using float versions
    * of the Uniform* functions.  The "1" means we're setting
    * one vector's worth of information.
    */
   (*Uniform4fvARB)(uniformLocation, 1, uniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Query it back */
   (*GetUniformfvARB)(program, uniformLocation, queriedUniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Clean up before we check to see whether it came back unscathed */
   exercise_uniform_end(program);

   /* Now check to see whether the uniform came back as expected.  This
    * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed.
    */
   return compare_floats(__FUNCTION__, 4, uniform, 4, queriedUniform);
}

static GLboolean
test_Uniform4f(generic_func func)
{
   PFNGLUNIFORM4FARBPROC Uniform4fARB = (PFNGLUNIFORM4FARBPROC) func;
   DECLARE_GLFUNC_PTR(GetUniformfvARB, PFNGLGETUNIFORMFVARBPROC);

   /* This is a trivial fragment shader that sets the color of the
    * fragment to the uniform value passed in.
    */
   static const char *fragmentShaderText = 
      "uniform vec4 uniformColor; void main() {gl_FragColor = uniformColor;}";
   static const char *uniformName = "uniformColor";

   GLhandleARB program;
   GLint uniformLocation;
   const GLfloat uniform[4] = {1.1,2.2,3.3,4.4};
   GLfloat queriedUniform[4];

   if (GetUniformfvARB == NULL) {
      return GL_FALSE;
   }

   /* Call a helper function to compile up the shader and give
    * us back the validated program and uniform location.
    * If it fails, something's wrong and we can't continue.
    */
   if (!exercise_uniform_start(fragmentShaderText, uniformName, 
      &program, &uniformLocation)) {
      return GL_FALSE;
   }

   /* Set the value of the program uniform.  Note that you must
    * use a compatible type.  Our uniform above is an integer
    * vector (ivec4), so we must set it using integer versions
    * of the Uniform* functions.
    */
   (*Uniform4fARB)(uniformLocation, uniform[0], uniform[1], uniform[2],
      uniform[3]);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Query it back */
   (*GetUniformfvARB)(program, uniformLocation, queriedUniform);
   CheckGLError(__LINE__, __FILE__, __FUNCTION__);

   /* Clean up before we check to see whether it came back unscathed */
   exercise_uniform_end(program);

   /* Now check to see whether the uniform came back as expected.  This
    * will return GL_TRUE if all is well, or GL_FALSE if the comparison failed.
    */
   return compare_floats(__FUNCTION__, 4, uniform, 4, queriedUniform);
}

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_VertexAttrib1dvARB(generic_func func)
{
   PFNGLVERTEXATTRIB1DVARBPROC vertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC) func;
   PFNGLGETVERTEXATTRIBDVARBPROC getVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvARB");

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

static GLboolean
test_VertexAttrib1svARB(generic_func func)
{
   PFNGLVERTEXATTRIB1SVARBPROC vertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC) func;
   PFNGLGETVERTEXATTRIBIVARBPROC getVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivARB");

   const GLshort v[1] = {25.0};
   const GLshort def[1] = {0};
   GLint res[4];
   GLboolean pass;
   (*vertexAttrib1svARB)(6, v);
   (*getVertexAttribivARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res);
   pass = (res[0] == 25 && res[1] == 0 && res[2] == 0 && res[3] == 1);
   (*vertexAttrib1svARB)(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_VertexAttrib1sNV(generic_func func)
{
   PFNGLVERTEXATTRIB1SNVPROC vertexAttrib1sNV = (PFNGLVERTEXATTRIB1SNVPROC) func;
   PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV");

   const GLshort v[4] = {2, 0, 0, 1};
   const GLshort def[4] = {0, 0, 0, 1};
   GLint res[4];
   (*vertexAttrib1sNV)(6, v[0]);
   (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib1sNV)(6, def[0]);
   return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib1fNV(generic_func func)
{
   PFNGLVERTEXATTRIB1FNVPROC vertexAttrib1fNV = (PFNGLVERTEXATTRIB1FNVPROC) func;
   PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

   const GLfloat v[4] = {2.5, 0.0, 0.0, 1.0};
   const GLfloat def[4] = {0, 0, 0, 1};
   GLfloat res[4];
   (*vertexAttrib1fNV)(6, v[0]);
   (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib1fNV)(6, def[0]);
   return compare_floats(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib1dNV(generic_func func)
{
   PFNGLVERTEXATTRIB1DNVPROC vertexAttrib1dNV = (PFNGLVERTEXATTRIB1DNVPROC) func;
   PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV");

   const GLdouble v[4] = {2.5, 0.0, 0.0, 1.0};
   const GLdouble def[4] = {0, 0, 0, 1};
   GLdouble res[4];
   (*vertexAttrib1dNV)(6, v[0]);
   (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib1dNV)(6, def[0]);
   return compare_doubles(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib2sNV(generic_func func)
{
   PFNGLVERTEXATTRIB2SNVPROC vertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC) func;
   PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV");

   const GLshort v[4] = {2, 4, 0, 1};
   const GLshort def[4] = {0, 0, 0, 1};
   GLint res[4];
   (*vertexAttrib2sNV)(6, v[0], v[1]);
   (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib2sNV)(6, def[0], def[1]);
   return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib2fNV(generic_func func)
{
   PFNGLVERTEXATTRIB2FNVPROC vertexAttrib2fNV = (PFNGLVERTEXATTRIB2FNVPROC) func;
   PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

   const GLfloat v[4] = {2.5, 4.25, 0.0, 1.0};
   const GLfloat def[4] = {0, 0, 0, 1};
   GLfloat res[4];
   (*vertexAttrib2fNV)(6, v[0], v[1]);
   (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib2fNV)(6, def[0], def[1]);
   return compare_floats(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib2dNV(generic_func func)
{
   PFNGLVERTEXATTRIB2DNVPROC vertexAttrib2dNV = (PFNGLVERTEXATTRIB2DNVPROC) func;
   PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV");

   const GLdouble v[4] = {2.5, 4.25, 0.0, 1.0};
   const GLdouble def[4] = {0, 0, 0, 1};
   GLdouble res[4];
   (*vertexAttrib2dNV)(6, v[0], v[1]);
   (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib2dNV)(6, def[0], def[1]);
   return compare_doubles(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib3sNV(generic_func func)
{
   PFNGLVERTEXATTRIB3SNVPROC vertexAttrib3sNV = (PFNGLVERTEXATTRIB3SNVPROC) func;
   PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV");

   const GLshort v[4] = {2, 4, 7, 1};
   const GLshort def[4] = {0, 0, 0, 1};
   GLint res[4];
   (*vertexAttrib3sNV)(6, v[0], v[1], v[2]);
   (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib3sNV)(6, def[0], def[1], def[2]);
   return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res);
}

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

   const GLfloat v[4] = {2.5, 4.25, 7.125, 1.0};
   const GLfloat def[4] = {0, 0, 0, 1};
   GLfloat res[4];
   (*vertexAttrib3fNV)(6, v[0], v[1], v[2]);
   (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib3fNV)(6, def[0], def[1], def[2]);
   return compare_floats(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib3dNV(generic_func func)
{
   PFNGLVERTEXATTRIB3DNVPROC vertexAttrib3dNV = (PFNGLVERTEXATTRIB3DNVPROC) func;
   PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV");

   const GLdouble v[4] = {2.5, 4.25, 7.125, 1.0};
   const GLdouble def[4] = {0, 0, 0, 1};
   GLdouble res[4];
   (*vertexAttrib3dNV)(6, v[0], v[1], v[2]);
   (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib3dNV)(6, def[0], def[1], def[2]);
   return compare_doubles(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib4sNV(generic_func func)
{
   PFNGLVERTEXATTRIB4SNVPROC vertexAttrib4sNV = (PFNGLVERTEXATTRIB4SNVPROC) func;
   PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV");

   const GLshort v[4] = {2, 4, 7, 5};
   const GLshort def[4] = {0, 0, 0, 1};
   GLint res[4];
   (*vertexAttrib4sNV)(6, v[0], v[1], v[2], v[3]);
   (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib4sNV)(6, def[0], def[1], def[2], def[3]);
   return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib4fNV(generic_func func)
{
   PFNGLVERTEXATTRIB4FNVPROC vertexAttrib4fNV = (PFNGLVERTEXATTRIB4FNVPROC) func;
   PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

   const GLfloat v[4] = {2.5, 4.25, 7.125, 5.0625};
   const GLfloat def[4] = {0, 0, 0, 1};
   GLfloat res[4];
   (*vertexAttrib4fNV)(6, v[0], v[1], v[2], v[3]);
   (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib4fNV)(6, def[0], def[1], def[2], def[3]);
   return compare_floats(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib4dNV(generic_func func)
{
   PFNGLVERTEXATTRIB4DNVPROC vertexAttrib4dNV = (PFNGLVERTEXATTRIB4DNVPROC) func;
   PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV");

   const GLdouble v[4] = {2.5, 4.25, 7.125, 5.0625};
   const GLdouble def[4] = {0, 0, 0, 1};
   GLdouble res[4];
   (*vertexAttrib4dNV)(6, v[0], v[1], v[2], v[3]);
   (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib4dNV)(6, def[0], def[1], def[2], def[3]);
   return compare_doubles(__FUNCTION__, 4, v, 4, res);
}

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];
   /* There's no byte-value query; so we use the float-value query.
    * Bytes are interpreted as steps between 0 and 1, so the
    * expected float values will be 0.0 for byte value 0 and 1.0 for
    * byte value 255.
    */
   GLfloat expectedResults[4] = {1.0, 0.0, 1.0, 0.0};
   (*vertexAttrib4ubNV)(6, v[0], v[1], v[2], v[3]);
   (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib4ubNV)(6, def[0], def[1], def[2], def[3]);
   return compare_floats(__FUNCTION__, 4, expectedResults, 4, res);
}

static GLboolean
test_VertexAttrib1fvNV(generic_func func)
{
   PFNGLVERTEXATTRIB1FVNVPROC vertexAttrib1fvNV = (PFNGLVERTEXATTRIB1FVNVPROC) func;
   PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

   const GLfloat v[4] = {2.5, 0.0, 0.0, 1.0};
   const GLfloat def[4] = {0, 0, 0, 1};
   GLfloat res[4];
   (*vertexAttrib1fvNV)(6, v);
   (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib1fvNV)(6, def);
   return compare_floats(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib1dvNV(generic_func func)
{
   PFNGLVERTEXATTRIB1DVNVPROC vertexAttrib1dvNV = (PFNGLVERTEXATTRIB1DVNVPROC) func;
   PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV");

   const GLdouble v[4] = {2.5, 0.0, 0.0, 1.0};
   const GLdouble def[4] = {0, 0, 0, 1};
   GLdouble res[4];
   (*vertexAttrib1dvNV)(6, v);
   (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib1dvNV)(6, def);
   return compare_doubles(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib2svNV(generic_func func)
{
   PFNGLVERTEXATTRIB2SVNVPROC vertexAttrib2svNV = (PFNGLVERTEXATTRIB2SVNVPROC) func;
   PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV");

   const GLshort v[4] = {2, 4, 0, 1};
   const GLshort def[4] = {0, 0, 0, 1};
   GLint res[4];
   (*vertexAttrib2svNV)(6, v);
   (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib2svNV)(6, def);
   return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib2fvNV(generic_func func)
{
   PFNGLVERTEXATTRIB2FVNVPROC vertexAttrib2fvNV = (PFNGLVERTEXATTRIB2FVNVPROC) func;
   PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

   const GLfloat v[4] = {2.5, 4.25, 0.0, 1.0};
   const GLfloat def[4] = {0, 0, 0, 1};
   GLfloat res[4];
   (*vertexAttrib2fvNV)(6, v);
   (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib2fvNV)(6, def);
   return compare_floats(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib2dvNV(generic_func func)
{
   PFNGLVERTEXATTRIB2DVNVPROC vertexAttrib2dvNV = (PFNGLVERTEXATTRIB2DVNVPROC) func;
   PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV");

   const GLdouble v[4] = {2.5, 4.25, 0.0, 1.0};
   const GLdouble def[4] = {0, 0, 0, 1};
   GLdouble res[4];
   (*vertexAttrib2dvNV)(6, v);
   (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib2dvNV)(6, def);
   return compare_doubles(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib3svNV(generic_func func)
{
   PFNGLVERTEXATTRIB3SVNVPROC vertexAttrib3svNV = (PFNGLVERTEXATTRIB3SVNVPROC) func;
   PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV");

   const GLshort v[4] = {2, 4, 7, 1};
   const GLshort def[4] = {0, 0, 0, 1};
   GLint res[4];
   (*vertexAttrib3svNV)(6, v);
   (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib3svNV)(6, def);
   return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib3fvNV(generic_func func)
{
   PFNGLVERTEXATTRIB3FVNVPROC vertexAttrib3fvNV = (PFNGLVERTEXATTRIB3FVNVPROC) func;
   PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

   const GLfloat v[4] = {2.5, 4.25, 7.125, 1.0};
   const GLfloat def[4] = {0, 0, 0, 1};
   GLfloat res[4];
   (*vertexAttrib3fvNV)(6, v);
   (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib3fvNV)(6, def);
   return compare_floats(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib3dvNV(generic_func func)
{
   PFNGLVERTEXATTRIB3DVNVPROC vertexAttrib3dvNV = (PFNGLVERTEXATTRIB3DVNVPROC) func;
   PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV");

   const GLdouble v[4] = {2.5, 4.25, 7.125, 1.0};
   const GLdouble def[4] = {0, 0, 0, 1};
   GLdouble res[4];
   (*vertexAttrib3dvNV)(6, v);
   (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib3dvNV)(6, def);
   return compare_doubles(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib4svNV(generic_func func)
{
   PFNGLVERTEXATTRIB4SVNVPROC vertexAttrib4svNV = (PFNGLVERTEXATTRIB4SVNVPROC) func;
   PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV");

   const GLshort v[4] = {2, 4, 7, 5};
   const GLshort def[4] = {0, 0, 0, 1};
   GLint res[4];
   (*vertexAttrib4svNV)(6, v);
   (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib4svNV)(6, def);
   return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib4fvNV(generic_func func)
{
   PFNGLVERTEXATTRIB4FVNVPROC vertexAttrib4fvNV = (PFNGLVERTEXATTRIB4FVNVPROC) func;
   PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

   const GLfloat v[4] = {2.5, 4.25, 7.125, 5.0625};
   const GLfloat def[4] = {0, 0, 0, 1};
   GLfloat res[4];
   (*vertexAttrib4fvNV)(6, v);
   (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib4fvNV)(6, def);
   return compare_floats(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib4dvNV(generic_func func)
{
   PFNGLVERTEXATTRIB4DVNVPROC vertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC) func;
   PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV");

   const GLdouble v[4] = {2.5, 4.25, 7.125, 5.0625};
   const GLdouble def[4] = {0, 0, 0, 1};
   GLdouble res[4];
   (*vertexAttrib4dvNV)(6, v);
   (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib4dvNV)(6, def);
   return compare_doubles(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttrib4ubvNV(generic_func func)
{
   PFNGLVERTEXATTRIB4UBVNVPROC vertexAttrib4ubvNV = (PFNGLVERTEXATTRIB4UBVNVPROC) 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];
   /* There's no byte-value query; so we use the float-value query.
    * Bytes are interpreted as steps between 0 and 1, so the
    * expected float values will be 0.0 for byte value 0 and 1.0 for
    * byte value 255.
    */
   GLfloat expectedResults[4] = {1.0, 0.0, 1.0, 0.0};
   (*vertexAttrib4ubvNV)(6, v);
   (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttrib4ubvNV)(6, def);
   return compare_floats(__FUNCTION__, 4, expectedResults, 4, res);
}

static GLboolean
test_VertexAttribs1fvNV(generic_func func)
{
   PFNGLVERTEXATTRIBS1FVNVPROC vertexAttribs1fvNV = (PFNGLVERTEXATTRIBS1FVNVPROC) func;
   PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

   const GLfloat v[4] = {2.5, 0.0, 0.0, 1.0};
   const GLfloat def[4] = {0, 0, 0, 1};
   GLfloat res[4];
   (*vertexAttribs1fvNV)(6, 1, v);
   (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttribs1fvNV)(6, 1, def);
   return compare_floats(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttribs1dvNV(generic_func func)
{
   PFNGLVERTEXATTRIBS1DVNVPROC vertexAttribs1dvNV = (PFNGLVERTEXATTRIBS1DVNVPROC) func;
   PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV");

   const GLdouble v[4] = {2.5, 0.0, 0.0, 1.0};
   const GLdouble def[4] = {0, 0, 0, 1};
   GLdouble res[4];
   (*vertexAttribs1dvNV)(6, 1, v);
   (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttribs1dvNV)(6, 1, def);
   return compare_doubles(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttribs2svNV(generic_func func)
{
   PFNGLVERTEXATTRIBS2SVNVPROC vertexAttribs2svNV = (PFNGLVERTEXATTRIBS2SVNVPROC) func;
   PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV");

   const GLshort v[4] = {2, 4, 0, 1};
   const GLshort def[4] = {0, 0, 0, 1};
   GLint res[4];
   (*vertexAttribs2svNV)(6, 1, v);
   (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttribs2svNV)(6, 1, def);
   return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttribs2fvNV(generic_func func)
{
   PFNGLVERTEXATTRIBS2FVNVPROC vertexAttribs2fvNV = (PFNGLVERTEXATTRIBS2FVNVPROC) func;
   PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

   const GLfloat v[4] = {2.5, 4.25, 0.0, 1.0};
   const GLfloat def[4] = {0, 0, 0, 1};
   GLfloat res[4];
   (*vertexAttribs2fvNV)(6, 1, v);
   (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttribs2fvNV)(6, 1, def);
   return compare_floats(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttribs2dvNV(generic_func func)
{
   PFNGLVERTEXATTRIBS2DVNVPROC vertexAttribs2dvNV = (PFNGLVERTEXATTRIBS2DVNVPROC) func;
   PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV");

   const GLdouble v[4] = {2.5, 4.25, 0.0, 1.0};
   const GLdouble def[4] = {0, 0, 0, 1};
   GLdouble res[4];
   (*vertexAttribs2dvNV)(6, 1, v);
   (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttribs2dvNV)(6, 1, def);
   return compare_doubles(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttribs3svNV(generic_func func)
{
   PFNGLVERTEXATTRIBS3SVNVPROC vertexAttribs3svNV = (PFNGLVERTEXATTRIBS3SVNVPROC) func;
   PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV");

   const GLshort v[4] = {2, 4, 7, 1};
   const GLshort def[4] = {0, 0, 0, 1};
   GLint res[4];
   (*vertexAttribs3svNV)(6, 1, v);
   (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttribs3svNV)(6, 1, def);
   return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttribs3fvNV(generic_func func)
{
   PFNGLVERTEXATTRIBS3FVNVPROC vertexAttribs3fvNV = (PFNGLVERTEXATTRIBS3FVNVPROC) func;
   PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

   const GLfloat v[4] = {2.5, 4.25, 7.125, 1.0};
   const GLfloat def[4] = {0, 0, 0, 1};
   GLfloat res[4];
   (*vertexAttribs3fvNV)(6, 1, v);
   (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttribs3fvNV)(6, 1, def);
   return compare_floats(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttribs3dvNV(generic_func func)
{
   PFNGLVERTEXATTRIBS3DVNVPROC vertexAttribs3dvNV = (PFNGLVERTEXATTRIBS3DVNVPROC) func;
   PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV");

   const GLdouble v[4] = {2.5, 4.25, 7.125, 1.0};
   const GLdouble def[4] = {0, 0, 0, 1};
   GLdouble res[4];
   (*vertexAttribs3dvNV)(6, 1, v);
   (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttribs3dvNV)(6, 1, def);
   return compare_doubles(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttribs4svNV(generic_func func)
{
   PFNGLVERTEXATTRIBS4SVNVPROC vertexAttribs4svNV = (PFNGLVERTEXATTRIBS4SVNVPROC) func;
   PFNGLGETVERTEXATTRIBIVNVPROC getVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribivNV");

   const GLshort v[4] = {2, 4, 7, 5};
   const GLshort def[4] = {0, 0, 0, 1};
   GLint res[4];
   (*vertexAttribs4svNV)(6, 1, v);
   (*getVertexAttribivNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttribs4svNV)(6, 1, def);
   return compare_shorts_to_ints(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttribs4fvNV(generic_func func)
{
   PFNGLVERTEXATTRIBS4FVNVPROC vertexAttribs4fvNV = (PFNGLVERTEXATTRIBS4FVNVPROC) func;
   PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV");

   const GLfloat v[4] = {2.5, 4.25, 7.125, 5.0625};
   const GLfloat def[4] = {0, 0, 0, 1};
   GLfloat res[4];
   (*vertexAttribs4fvNV)(6, 1, v);
   (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttribs4fvNV)(6, 1, def);
   return compare_floats(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttribs4dvNV(generic_func func)
{
   PFNGLVERTEXATTRIBS4DVNVPROC vertexAttribs4dvNV = (PFNGLVERTEXATTRIBS4DVNVPROC) func;
   PFNGLGETVERTEXATTRIBDVNVPROC getVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribdvNV");

   const GLdouble v[4] = {2.5, 4.25, 7.125, 5.0625};
   const GLdouble def[4] = {0, 0, 0, 1};
   GLdouble res[4];
   (*vertexAttribs4dvNV)(6, 1, v);
   (*getVertexAttribdvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttribs4dvNV)(6, 1, def);
   return compare_doubles(__FUNCTION__, 4, v, 4, res);
}

static GLboolean
test_VertexAttribs4ubvNV(generic_func func)
{
   PFNGLVERTEXATTRIBS4UBVNVPROC vertexAttribs4ubvNV = (PFNGLVERTEXATTRIBS4UBVNVPROC) 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];
   /* There's no byte-value query; so we use the float-value query.
    * Bytes are interpreted as steps between 0 and 1, so the
    * expected float values will be 0.0 for byte value 0 and 1.0 for
    * byte value 255.
    */
   GLfloat expectedResults[4] = {1.0, 0.0, 1.0, 0.0};
   (*vertexAttribs4ubvNV)(6, 1, v);
   (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res);
   (*vertexAttribs4ubvNV)(6, 1, def);
   return compare_floats(__FUNCTION__, 4, expectedResults, 4, res);
}

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;
}


/* Run all the known extension function tests, if the extension is supported.
 * Return a count of how many failed.
 */
static int
check_functions( const char *extensions )
{
   struct name_test_pair *entry;
   int failures = 0, passes = 0, untested = 0;
   int totalFail = 0, totalPass = 0, totalUntested = 0, totalUnsupported = 0;
   int doTests = 0;
   const char *version = (const char *) glGetString(GL_VERSION);

   /* The functions list will have "real" entries (consisting of
    * a GL function name and a pointer to an exercise function for
    * that GL function), and "group" entries (indicated as
    * such by having a "-" as the first character of the name).
    * "Group" names always start with the "-" character, and can
    * be numeric (e.g. "-1.0", "-2.1"), indicating that a particular
    * OpenGL version is required for the following functions; or can be
    * an extension name (e.g. "-GL_ARB_multitexture") that means
    * that the named extension is required for the following functions.
    */
   for (entry = functions; entry->name; entry++) {
      /* Check if this is a group indicator */
      if (entry->name[0] == '-') {
         /* A group indicator; check if it's an OpenGL version group */
         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);
         }

         /* doTests is now set if we're starting an OpenGL version
          * group, and the running OpenGL version is at least the
          * version required; or if we're starting an OpenGL extension
          * group, and the extension is supported.
          */
         if (doTests)
            printf("Testing %s functions\n", entry->name + 1);

         /* Each time we hit a title function, reset the function
          * counts.
          */
         failures = 0;
         passes = 0;
         untested = 0;
      }
      else if (doTests) {
         /* Here, we know we're trying to exercise a function for
          * a supported extension.  See whether we have a test for
          * it, and try to run it.
          */
         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++;
                  totalPass++;
               }
               else {
                  printf(" FAIL!!!\n");
                  failures++;
                  totalFail++;
               }
            }
            else {
               untested++;
               totalUntested++;
            }
         }
         else {
            printf("   glXGetProcAddress(%s) failed!\n", entry->name);
            failures++;
            totalFail++;
         }
      }
      else {
         /* Here, we have a function that belongs to a group that
          * is known to be unsupported.
          */
         totalUnsupported++;
      }

      /* Make sure a poor test case doesn't leave any lingering
       * OpenGL errors.
       */
      CheckGLError(__LINE__, __FILE__, __FUNCTION__);

      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);
         }
         if (untested > 0) {
            printf("   %d untested.\n", untested);
         }
      }
   }

   printf("-----------------------------\n");
   printf("Total: %d pass  %d fail  %d untested  %d unsupported  %d total\n", 
      totalPass, totalFail, totalUntested, totalUnsupported,
      totalPass + totalFail + totalUntested + totalUnsupported);

   return totalFail;
}


/* Return an error code */
#define ERROR_NONE 0
#define ERROR_NO_VISUAL 1
#define ERROR_NO_CONTEXT 2
#define ERROR_NO_MAKECURRENT 3
#define ERROR_FAILED 4

static int
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;
   int failures;

   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 ERROR_NO_VISUAL;
      }
   }

   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 ERROR_NO_CONTEXT;
   }

   if (!glXMakeCurrent(dpy, win, ctx)) {
      fprintf(stderr, "Error: glXMakeCurrent failed\n");
      glXDestroyContext(dpy, ctx);
      XDestroyWindow(dpy, win);
      return ERROR_NO_MAKECURRENT;
   }

   failures = check_functions( (const char *) glGetString(GL_EXTENSIONS) );
   glXDestroyContext(dpy, ctx);
   XDestroyWindow(dpy, win);

   return (failures == 0 ? ERROR_NONE : ERROR_FAILED);
}

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

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

   returnCode = print_screen_info(dpy, 0, GL_TRUE);

   XCloseDisplay(dpy);

   return returnCode;
}