--- /dev/null
+/*
+ * 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;
+ }
+ }
+}
projects / mesa.git / commitdiff