diff options
Diffstat (limited to 'src/glx/tests')
| -rw-r--r-- | src/glx/tests/Makefile.am | 1 | ||||
| -rw-r--r-- | src/glx/tests/enum_sizes.cpp | 556 |
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; + } + } +} |