glx/tests: Add unit tests for generated code in indirect_size.c

Signed-off-by: Ian Romanick <[email protected]>
Reviewed-by: Brian Paul <[email protected]>

2 files changed, 557 insertions, 0 deletions

diff --git a/src/glx/tests/Makefile.am b/src/glx/tests/Makefile.am
index 5ecebe7710a..a8a957d5b85 100644
--- a/src/glx/tests/Makefile.am
+++ b/src/glx/tests/Makefile.am
@@ -12,6 +12,7 @@ check_PROGRAMS = glx-test
 glx_test_SOURCES =			\
 	clientinfo_unittest.cpp		\
 	create_context_unittest.cpp	\
+	enum_sizes.cpp			\
 	fake_glx_screen.cpp
 
 glx_test_LDADD = \
diff --git a/src/glx/tests/enum_sizes.cpp b/src/glx/tests/enum_sizes.cpp
new file mode 100644
index 00000000000..7ceeb031f68
--- /dev/null
+++ b/src/glx/tests/enum_sizes.cpp
@@ -0,0 +1,556 @@
+/*
+ * Copyright © 2012 Intel Corporation
+ *
+ * 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 (including the next
+ * paragraph) 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
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
+ */
+
+/**
+ * \file enum_sizes.cpp
+ * Validate the generated code in indirect_size.c
+ *
+ * The functions in indirect_size.c determine how many data values are
+ * associated with each enumerant that can be passed to various OpenGL
+ * functions.  Tests in this file probe each function in indirect_size.c with
+ * each of the possible valid enums and verify that the correct size is
+ * returned.  Tests in this file also probe each function in indirect_size.c
+ * with a larger number of \b invalid enums and verify that zero is returned.
+ */
+
+#include <gtest/gtest.h>
+#include <GL/gl.h>
+extern "C" {
+#include "../indirect_size.h"
+}
+
+TEST(ValidEnumSizes, CallLists)
+{
+   EXPECT_EQ(1, __glCallLists_size(GL_BYTE));
+   EXPECT_EQ(1, __glCallLists_size(GL_UNSIGNED_BYTE));
+   EXPECT_EQ(2, __glCallLists_size(GL_SHORT));
+   EXPECT_EQ(2, __glCallLists_size(GL_UNSIGNED_SHORT));
+   EXPECT_EQ(2, __glCallLists_size(GL_2_BYTES));
+   EXPECT_EQ(2, __glCallLists_size(GL_HALF_FLOAT));
+   EXPECT_EQ(3, __glCallLists_size(GL_3_BYTES));
+   EXPECT_EQ(4, __glCallLists_size(GL_INT));
+   EXPECT_EQ(4, __glCallLists_size(GL_UNSIGNED_INT));
+   EXPECT_EQ(4, __glCallLists_size(GL_FLOAT));
+   EXPECT_EQ(4, __glCallLists_size(GL_4_BYTES));
+}
+
+TEST(InvalidEnumSizes, CallLists)
+{
+   for (unsigned i = 0; i < 0x10004; i++) {
+      switch (i) {
+      case GL_BYTE:
+      case GL_UNSIGNED_BYTE:
+      case GL_SHORT:
+      case GL_UNSIGNED_SHORT:
+      case GL_2_BYTES:
+      case GL_HALF_FLOAT:
+      case GL_3_BYTES:
+      case GL_INT:
+      case GL_UNSIGNED_INT:
+      case GL_FLOAT:
+      case GL_4_BYTES:
+         break;
+      default:
+         EXPECT_EQ(0, __glCallLists_size(i)) << "i = 0x" <<
+            std::setw(4) << std::setfill('0') << std::hex << i;
+      }
+   }
+}
+
+TEST(ValidEnumSizes, Fogfv)
+{
+   EXPECT_EQ(1, __glFogfv_size(GL_FOG_INDEX));
+   EXPECT_EQ(1, __glFogfv_size(GL_FOG_DENSITY));
+   EXPECT_EQ(1, __glFogfv_size(GL_FOG_START));
+   EXPECT_EQ(1, __glFogfv_size(GL_FOG_END));
+   EXPECT_EQ(1, __glFogfv_size(GL_FOG_MODE));
+   EXPECT_EQ(1, __glFogfv_size(GL_FOG_OFFSET_VALUE_SGIX));
+   EXPECT_EQ(1, __glFogfv_size(GL_FOG_DISTANCE_MODE_NV));
+   EXPECT_EQ(4, __glFogfv_size(GL_FOG_COLOR));
+}
+
+TEST(InvalidEnumSizes, Fogfv)
+{
+   for (unsigned i = 0; i < 0x10004; i++) {
+      switch (i) {
+      case GL_FOG_INDEX:
+      case GL_FOG_DENSITY:
+      case GL_FOG_START:
+      case GL_FOG_END:
+      case GL_FOG_MODE:
+      case GL_FOG_OFFSET_VALUE_SGIX:
+      case GL_FOG_DISTANCE_MODE_NV:
+      case GL_FOG_COLOR:
+         break;
+      default:
+         EXPECT_EQ(0, __glFogfv_size(i)) << "i = 0x" <<
+            std::setw(4) << std::setfill('0') << std::hex << i;
+      }
+   }
+}
+
+TEST(ValidEnumSizes, Lightfv)
+{
+   EXPECT_EQ(1, __glLightfv_size(GL_SPOT_EXPONENT));
+   EXPECT_EQ(1, __glLightfv_size(GL_SPOT_CUTOFF));
+   EXPECT_EQ(1, __glLightfv_size(GL_CONSTANT_ATTENUATION));
+   EXPECT_EQ(1, __glLightfv_size(GL_LINEAR_ATTENUATION));
+   EXPECT_EQ(1, __glLightfv_size(GL_QUADRATIC_ATTENUATION));
+   EXPECT_EQ(3, __glLightfv_size(GL_SPOT_DIRECTION));
+   EXPECT_EQ(4, __glLightfv_size(GL_AMBIENT));
+   EXPECT_EQ(4, __glLightfv_size(GL_DIFFUSE));
+   EXPECT_EQ(4, __glLightfv_size(GL_SPECULAR));
+   EXPECT_EQ(4, __glLightfv_size(GL_POSITION));
+}
+
+TEST(InvalidEnumSizes, Lightfv)
+{
+   for (unsigned i = 0; i < 0x10004; i++) {
+      switch (i) {
+      case GL_SPOT_EXPONENT:
+      case GL_SPOT_CUTOFF:
+      case GL_CONSTANT_ATTENUATION:
+      case GL_LINEAR_ATTENUATION:
+      case GL_QUADRATIC_ATTENUATION:
+      case GL_SPOT_DIRECTION:
+      case GL_AMBIENT:
+      case GL_DIFFUSE:
+      case GL_SPECULAR:
+      case GL_POSITION:
+         break;
+      default:
+         EXPECT_EQ(0, __glLightfv_size(i)) << "i = 0x" <<
+            std::setw(4) << std::setfill('0') << std::hex << i;
+      }
+   }
+}
+
+TEST(ValidEnumSizes, LightModelfv)
+{
+   EXPECT_EQ(1, __glLightModelfv_size(GL_LIGHT_MODEL_LOCAL_VIEWER));
+   EXPECT_EQ(1, __glLightModelfv_size(GL_LIGHT_MODEL_TWO_SIDE));
+   EXPECT_EQ(1, __glLightModelfv_size(GL_LIGHT_MODEL_COLOR_CONTROL));
+   EXPECT_EQ(1, __glLightModelfv_size(GL_LIGHT_MODEL_COLOR_CONTROL_EXT));
+   EXPECT_EQ(4, __glLightModelfv_size(GL_LIGHT_MODEL_AMBIENT));
+}
+
+TEST(InvalidEnumSizes, LightModelfv)
+{
+   for (unsigned i = 0; i < 0x10004; i++) {
+      switch (i) {
+      case GL_LIGHT_MODEL_LOCAL_VIEWER:
+      case GL_LIGHT_MODEL_TWO_SIDE:
+      case GL_LIGHT_MODEL_COLOR_CONTROL:
+/*      case GL_LIGHT_MODEL_COLOR_CONTROL_EXT:*/
+      case GL_LIGHT_MODEL_AMBIENT:
+         break;
+      default:
+         EXPECT_EQ(0, __glLightModelfv_size(i)) << "i = 0x" <<
+            std::setw(4) << std::setfill('0') << std::hex << i;
+      }
+   }
+}
+
+TEST(ValidEnumSizes, Materialfv)
+{
+   EXPECT_EQ(1, __glMaterialfv_size(GL_SHININESS));
+   EXPECT_EQ(3, __glMaterialfv_size(GL_COLOR_INDEXES));
+   EXPECT_EQ(4, __glMaterialfv_size(GL_AMBIENT));
+   EXPECT_EQ(4, __glMaterialfv_size(GL_DIFFUSE));
+   EXPECT_EQ(4, __glMaterialfv_size(GL_SPECULAR));
+   EXPECT_EQ(4, __glMaterialfv_size(GL_EMISSION));
+   EXPECT_EQ(4, __glMaterialfv_size(GL_AMBIENT_AND_DIFFUSE));
+}
+
+TEST(InvalidEnumSizes, Materialfv)
+{
+   for (unsigned i = 0; i < 0x10004; i++) {
+      switch (i) {
+      case GL_SHININESS:
+      case GL_COLOR_INDEXES:
+      case GL_AMBIENT:
+      case GL_DIFFUSE:
+      case GL_SPECULAR:
+      case GL_EMISSION:
+      case GL_AMBIENT_AND_DIFFUSE:
+         break;
+      default:
+         EXPECT_EQ(0, __glMaterialfv_size(i)) << "i = 0x" <<
+            std::setw(4) << std::setfill('0') << std::hex << i;
+      }
+   }
+}
+
+TEST(ValidEnumSizes, TexParameterfv)
+{
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_MAG_FILTER));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_MIN_FILTER));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_WRAP_S));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_WRAP_T));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_PRIORITY));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_WRAP_R));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_COMPARE_FAIL_VALUE_ARB));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_SHADOW_AMBIENT_SGIX));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_MIN_LOD));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_MAX_LOD));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_BASE_LEVEL));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_MAX_LEVEL));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_CLIPMAP_FRAME_SGIX));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_LOD_BIAS_S_SGIX));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_LOD_BIAS_T_SGIX));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_LOD_BIAS_R_SGIX));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_GENERATE_MIPMAP));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_GENERATE_MIPMAP_SGIS));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_COMPARE_SGIX));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_COMPARE_OPERATOR_SGIX));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_MAX_CLAMP_S_SGIX));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_MAX_CLAMP_T_SGIX));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_MAX_CLAMP_R_SGIX));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_MAX_ANISOTROPY_EXT));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_LOD_BIAS));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_LOD_BIAS_EXT));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_STORAGE_HINT_APPLE));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_STORAGE_PRIVATE_APPLE));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_STORAGE_CACHED_APPLE));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_STORAGE_SHARED_APPLE));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_DEPTH_TEXTURE_MODE));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_DEPTH_TEXTURE_MODE_ARB));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_COMPARE_MODE));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_COMPARE_MODE_ARB));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_COMPARE_FUNC));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_COMPARE_FUNC_ARB));
+   EXPECT_EQ(1, __glTexParameterfv_size(GL_TEXTURE_UNSIGNED_REMAP_MODE_NV));
+   EXPECT_EQ(2, __glTexParameterfv_size(GL_TEXTURE_CLIPMAP_CENTER_SGIX));
+   EXPECT_EQ(2, __glTexParameterfv_size(GL_TEXTURE_CLIPMAP_OFFSET_SGIX));
+   EXPECT_EQ(3, __glTexParameterfv_size(GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX));
+   EXPECT_EQ(4, __glTexParameterfv_size(GL_TEXTURE_BORDER_COLOR));
+   EXPECT_EQ(4, __glTexParameterfv_size(GL_POST_TEXTURE_FILTER_BIAS_SGIX));
+   EXPECT_EQ(4, __glTexParameterfv_size(GL_POST_TEXTURE_FILTER_SCALE_SGIX));
+}
+
+TEST(InvalidEnumSizes, TexParameterfv)
+{
+   for (unsigned i = 0; i < 0x10004; i++) {
+      switch (i) {
+      case GL_TEXTURE_MAG_FILTER:
+      case GL_TEXTURE_MIN_FILTER:
+      case GL_TEXTURE_WRAP_S:
+      case GL_TEXTURE_WRAP_T:
+      case GL_TEXTURE_PRIORITY:
+      case GL_TEXTURE_WRAP_R:
+      case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
+/*      case GL_SHADOW_AMBIENT_SGIX:*/
+      case GL_TEXTURE_MIN_LOD:
+      case GL_TEXTURE_MAX_LOD:
+      case GL_TEXTURE_BASE_LEVEL:
+      case GL_TEXTURE_MAX_LEVEL:
+      case GL_TEXTURE_CLIPMAP_FRAME_SGIX:
+      case GL_TEXTURE_LOD_BIAS_S_SGIX:
+      case GL_TEXTURE_LOD_BIAS_T_SGIX:
+      case GL_TEXTURE_LOD_BIAS_R_SGIX:
+      case GL_GENERATE_MIPMAP:
+/*      case GL_GENERATE_MIPMAP_SGIS:*/
+      case GL_TEXTURE_COMPARE_SGIX:
+      case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
+      case GL_TEXTURE_MAX_CLAMP_S_SGIX:
+      case GL_TEXTURE_MAX_CLAMP_T_SGIX:
+      case GL_TEXTURE_MAX_CLAMP_R_SGIX:
+      case GL_TEXTURE_MAX_ANISOTROPY_EXT:
+      case GL_TEXTURE_LOD_BIAS:
+/*      case GL_TEXTURE_LOD_BIAS_EXT:*/
+      case GL_TEXTURE_STORAGE_HINT_APPLE:
+      case GL_STORAGE_PRIVATE_APPLE:
+      case GL_STORAGE_CACHED_APPLE:
+      case GL_STORAGE_SHARED_APPLE:
+      case GL_DEPTH_TEXTURE_MODE:
+/*      case GL_DEPTH_TEXTURE_MODE_ARB:*/
+      case GL_TEXTURE_COMPARE_MODE:
+/*      case GL_TEXTURE_COMPARE_MODE_ARB:*/
+      case GL_TEXTURE_COMPARE_FUNC:
+/*      case GL_TEXTURE_COMPARE_FUNC_ARB:*/
+      case GL_TEXTURE_UNSIGNED_REMAP_MODE_NV:
+      case GL_TEXTURE_CLIPMAP_CENTER_SGIX:
+      case GL_TEXTURE_CLIPMAP_OFFSET_SGIX:
+      case GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX:
+      case GL_TEXTURE_BORDER_COLOR:
+      case GL_POST_TEXTURE_FILTER_BIAS_SGIX:
+      case GL_POST_TEXTURE_FILTER_SCALE_SGIX:
+         break;
+      default:
+         EXPECT_EQ(0, __glTexParameterfv_size(i)) << "i = 0x" <<
+            std::setw(4) << std::setfill('0') << std::hex << i;
+      }
+   }
+}
+
+TEST(ValidEnumSizes, TexEnvfv)
+{
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_ALPHA_SCALE));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_TEXTURE_ENV_MODE));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_TEXTURE_LOD_BIAS));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_COMBINE_RGB));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_COMBINE_ALPHA));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_RGB_SCALE));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_SOURCE0_RGB));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_SOURCE1_RGB));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_SOURCE2_RGB));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_SOURCE3_RGB_NV));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_SOURCE0_ALPHA));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_SOURCE1_ALPHA));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_SOURCE2_ALPHA));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_SOURCE3_ALPHA_NV));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_OPERAND0_RGB));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_OPERAND1_RGB));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_OPERAND2_RGB));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_OPERAND3_RGB_NV));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_OPERAND0_ALPHA));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_OPERAND1_ALPHA));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_OPERAND2_ALPHA));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_OPERAND3_ALPHA_NV));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_BUMP_TARGET_ATI));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_COORD_REPLACE_ARB));
+   EXPECT_EQ(1, __glTexEnvfv_size(GL_COORD_REPLACE_NV));
+   EXPECT_EQ(4, __glTexEnvfv_size(GL_TEXTURE_ENV_COLOR));
+}
+
+TEST(InvalidEnumSizes, TexEnvfv)
+{
+   for (unsigned i = 0; i < 0x10004; i++) {
+      switch (i) {
+      case GL_ALPHA_SCALE:
+      case GL_TEXTURE_ENV_MODE:
+      case GL_TEXTURE_LOD_BIAS:
+      case GL_COMBINE_RGB:
+      case GL_COMBINE_ALPHA:
+      case GL_RGB_SCALE:
+      case GL_SOURCE0_RGB:
+      case GL_SOURCE1_RGB:
+      case GL_SOURCE2_RGB:
+      case GL_SOURCE3_RGB_NV:
+      case GL_SOURCE0_ALPHA:
+      case GL_SOURCE1_ALPHA:
+      case GL_SOURCE2_ALPHA:
+      case GL_SOURCE3_ALPHA_NV:
+      case GL_OPERAND0_RGB:
+      case GL_OPERAND1_RGB:
+      case GL_OPERAND2_RGB:
+      case GL_OPERAND3_RGB_NV:
+      case GL_OPERAND0_ALPHA:
+      case GL_OPERAND1_ALPHA:
+      case GL_OPERAND2_ALPHA:
+      case GL_OPERAND3_ALPHA_NV:
+      case GL_BUMP_TARGET_ATI:
+      case GL_COORD_REPLACE_ARB:
+/*      case GL_COORD_REPLACE_NV:*/
+      case GL_TEXTURE_ENV_COLOR:
+         break;
+      default:
+         EXPECT_EQ(0, __glTexEnvfv_size(i)) << "i = 0x" <<
+            std::setw(4) << std::setfill('0') << std::hex << i;
+      }
+   }
+}
+
+TEST(ValidEnumSizes, TexGendv)
+{
+   EXPECT_EQ(1, __glTexGendv_size(GL_TEXTURE_GEN_MODE));
+   EXPECT_EQ(4, __glTexGendv_size(GL_OBJECT_PLANE));
+   EXPECT_EQ(4, __glTexGendv_size(GL_EYE_PLANE));
+}
+
+TEST(InvalidEnumSizes, TexGendv)
+{
+   for (unsigned i = 0; i < 0x10004; i++) {
+      switch (i) {
+      case GL_TEXTURE_GEN_MODE:
+      case GL_OBJECT_PLANE:
+      case GL_EYE_PLANE:
+         break;
+      default:
+         EXPECT_EQ(0, __glTexGendv_size(i)) << "i = 0x" <<
+            std::setw(4) << std::setfill('0') << std::hex << i;
+      }
+   }
+}
+
+TEST(ValidEnumSizes, Map1d)
+{
+   EXPECT_EQ(1, __glMap1d_size(GL_MAP1_INDEX));
+   EXPECT_EQ(1, __glMap1d_size(GL_MAP1_TEXTURE_COORD_1));
+   EXPECT_EQ(2, __glMap1d_size(GL_MAP1_TEXTURE_COORD_2));
+   EXPECT_EQ(3, __glMap1d_size(GL_MAP1_NORMAL));
+   EXPECT_EQ(3, __glMap1d_size(GL_MAP1_TEXTURE_COORD_3));
+   EXPECT_EQ(3, __glMap1d_size(GL_MAP1_VERTEX_3));
+   EXPECT_EQ(4, __glMap1d_size(GL_MAP1_COLOR_4));
+   EXPECT_EQ(4, __glMap1d_size(GL_MAP1_TEXTURE_COORD_4));
+   EXPECT_EQ(4, __glMap1d_size(GL_MAP1_VERTEX_4));
+}
+
+TEST(InvalidEnumSizes, Map1d)
+{
+   for (unsigned i = 0; i < 0x10004; i++) {
+      switch (i) {
+      case GL_MAP1_INDEX:
+      case GL_MAP1_TEXTURE_COORD_1:
+      case GL_MAP1_TEXTURE_COORD_2:
+      case GL_MAP1_NORMAL:
+      case GL_MAP1_TEXTURE_COORD_3:
+      case GL_MAP1_VERTEX_3:
+      case GL_MAP1_COLOR_4:
+      case GL_MAP1_TEXTURE_COORD_4:
+      case GL_MAP1_VERTEX_4:
+         break;
+      default:
+         EXPECT_EQ(0, __glMap1d_size(i)) << "i = 0x" <<
+            std::setw(4) << std::setfill('0') << std::hex << i;
+      }
+   }
+}
+
+TEST(ValidEnumSizes, Map2d)
+{
+   EXPECT_EQ(1, __glMap2d_size(GL_MAP2_INDEX));
+   EXPECT_EQ(1, __glMap2d_size(GL_MAP2_TEXTURE_COORD_1));
+   EXPECT_EQ(2, __glMap2d_size(GL_MAP2_TEXTURE_COORD_2));
+   EXPECT_EQ(3, __glMap2d_size(GL_MAP2_NORMAL));
+   EXPECT_EQ(3, __glMap2d_size(GL_MAP2_TEXTURE_COORD_3));
+   EXPECT_EQ(3, __glMap2d_size(GL_MAP2_VERTEX_3));
+   EXPECT_EQ(4, __glMap2d_size(GL_MAP2_COLOR_4));
+   EXPECT_EQ(4, __glMap2d_size(GL_MAP2_TEXTURE_COORD_4));
+   EXPECT_EQ(4, __glMap2d_size(GL_MAP2_VERTEX_4));
+}
+
+TEST(InvalidEnumSizes, Map2d)
+{
+   for (unsigned i = 0; i < 0x10004; i++) {
+      switch (i) {
+      case GL_MAP2_INDEX:
+      case GL_MAP2_TEXTURE_COORD_1:
+      case GL_MAP2_TEXTURE_COORD_2:
+      case GL_MAP2_NORMAL:
+      case GL_MAP2_TEXTURE_COORD_3:
+      case GL_MAP2_VERTEX_3:
+      case GL_MAP2_COLOR_4:
+      case GL_MAP2_TEXTURE_COORD_4:
+      case GL_MAP2_VERTEX_4:
+         break;
+      default:
+         EXPECT_EQ(0, __glMap2d_size(i)) << "i = 0x" <<
+            std::setw(4) << std::setfill('0') << std::hex << i;
+      }
+   }
+}
+
+TEST(ValidEnumSizes, ColorTableParameterfv)
+{
+   EXPECT_EQ(4, __glColorTableParameterfv_size(GL_COLOR_TABLE_SCALE));
+   EXPECT_EQ(4, __glColorTableParameterfv_size(GL_COLOR_TABLE_BIAS));
+}
+
+TEST(InvalidEnumSizes, ColorTableParameterfv)
+{
+   for (unsigned i = 0; i < 0x10004; i++) {
+      switch (i) {
+      case GL_COLOR_TABLE_SCALE:
+      case GL_COLOR_TABLE_BIAS:
+         break;
+      default:
+         EXPECT_EQ(0, __glColorTableParameterfv_size(i)) << "i = 0x" <<
+            std::setw(4) << std::setfill('0') << std::hex << i;
+      }
+   }
+}
+
+TEST(ValidEnumSizes, ConvolutionParameterfv)
+{
+   EXPECT_EQ(1, __glConvolutionParameterfv_size(GL_CONVOLUTION_BORDER_MODE));
+   EXPECT_EQ(1, __glConvolutionParameterfv_size(GL_CONVOLUTION_BORDER_MODE_EXT));
+   EXPECT_EQ(4, __glConvolutionParameterfv_size(GL_CONVOLUTION_FILTER_SCALE));
+   EXPECT_EQ(4, __glConvolutionParameterfv_size(GL_CONVOLUTION_FILTER_SCALE_EXT));
+   EXPECT_EQ(4, __glConvolutionParameterfv_size(GL_CONVOLUTION_FILTER_BIAS));
+   EXPECT_EQ(4, __glConvolutionParameterfv_size(GL_CONVOLUTION_FILTER_BIAS_EXT));
+   EXPECT_EQ(4, __glConvolutionParameterfv_size(GL_CONVOLUTION_BORDER_COLOR));
+   EXPECT_EQ(4, __glConvolutionParameterfv_size(GL_CONVOLUTION_BORDER_COLOR_HP));
+}
+
+TEST(InvalidEnumSizes, ConvolutionParameterfv)
+{
+   for (unsigned i = 0; i < 0x10004; i++) {
+      switch (i) {
+      case GL_CONVOLUTION_BORDER_MODE:
+/*      case GL_CONVOLUTION_BORDER_MODE_EXT:*/
+      case GL_CONVOLUTION_FILTER_SCALE:
+/*      case GL_CONVOLUTION_FILTER_SCALE_EXT:*/
+      case GL_CONVOLUTION_FILTER_BIAS:
+/*      case GL_CONVOLUTION_FILTER_BIAS_EXT:*/
+      case GL_CONVOLUTION_BORDER_COLOR:
+/*      case GL_CONVOLUTION_BORDER_COLOR_HP:*/
+         break;
+      default:
+         EXPECT_EQ(0, __glConvolutionParameterfv_size(i)) << "i = 0x" <<
+            std::setw(4) << std::setfill('0') << std::hex << i;
+      }
+   }
+}
+
+TEST(ValidEnumSizes, PointParameterfv)
+{
+   EXPECT_EQ(1, __glPointParameterfvEXT_size(GL_POINT_SIZE_MIN));
+   EXPECT_EQ(1, __glPointParameterfvEXT_size(GL_POINT_SIZE_MIN_ARB));
+   EXPECT_EQ(1, __glPointParameterfvEXT_size(GL_POINT_SIZE_MIN_SGIS));
+   EXPECT_EQ(1, __glPointParameterfvEXT_size(GL_POINT_SIZE_MAX));
+   EXPECT_EQ(1, __glPointParameterfvEXT_size(GL_POINT_SIZE_MAX_ARB));
+   EXPECT_EQ(1, __glPointParameterfvEXT_size(GL_POINT_SIZE_MAX_SGIS));
+   EXPECT_EQ(1, __glPointParameterfvEXT_size(GL_POINT_FADE_THRESHOLD_SIZE));
+   EXPECT_EQ(1, __glPointParameterfvEXT_size(GL_POINT_FADE_THRESHOLD_SIZE_ARB));
+   EXPECT_EQ(1, __glPointParameterfvEXT_size(GL_POINT_FADE_THRESHOLD_SIZE_SGIS));
+   EXPECT_EQ(1, __glPointParameterfvEXT_size(GL_POINT_SPRITE_R_MODE_NV));
+   EXPECT_EQ(1, __glPointParameterfvEXT_size(GL_POINT_SPRITE_COORD_ORIGIN));
+   EXPECT_EQ(3, __glPointParameterfvEXT_size(GL_POINT_DISTANCE_ATTENUATION));
+   EXPECT_EQ(3, __glPointParameterfvEXT_size(GL_POINT_DISTANCE_ATTENUATION_ARB));
+}
+
+TEST(InvalidEnumSizes, PointParameterfv)
+{
+   for (unsigned i = 0; i < 0x10004; i++) {
+      switch (i) {
+      case GL_POINT_SIZE_MIN:
+/*      case GL_POINT_SIZE_MIN_ARB:*/
+/*      case GL_POINT_SIZE_MIN_SGIS:*/
+      case GL_POINT_SIZE_MAX:
+/*      case GL_POINT_SIZE_MAX_ARB:*/
+/*      case GL_POINT_SIZE_MAX_SGIS:*/
+      case GL_POINT_FADE_THRESHOLD_SIZE:
+/*      case GL_POINT_FADE_THRESHOLD_SIZE_ARB:*/
+/*      case GL_POINT_FADE_THRESHOLD_SIZE_SGIS:*/
+      case GL_POINT_SPRITE_R_MODE_NV:
+      case GL_POINT_SPRITE_COORD_ORIGIN:
+      case GL_POINT_DISTANCE_ATTENUATION:
+/*      case GL_POINT_DISTANCE_ATTENUATION_ARB:*/
+         break;
+      default:
+         EXPECT_EQ(0, __glPointParameterfvEXT_size(i)) << "i = 0x" <<
+            std::setw(4) << std::setfill('0') << std::hex << i;
+      }
+   }
+}