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, __glPointParameterfv_size(GL_POINT_SIZE_MIN)); |
EXPECT_EQ(1, __glPointParameterfv_size(GL_POINT_SIZE_MIN_ARB)); |
EXPECT_EQ(1, __glPointParameterfv_size(GL_POINT_SIZE_MIN_SGIS)); |
EXPECT_EQ(1, __glPointParameterfv_size(GL_POINT_SIZE_MAX)); |
EXPECT_EQ(1, __glPointParameterfv_size(GL_POINT_SIZE_MAX_ARB)); |
EXPECT_EQ(1, __glPointParameterfv_size(GL_POINT_SIZE_MAX_SGIS)); |
EXPECT_EQ(1, __glPointParameterfv_size(GL_POINT_FADE_THRESHOLD_SIZE)); |
EXPECT_EQ(1, __glPointParameterfv_size(GL_POINT_FADE_THRESHOLD_SIZE_ARB)); |
EXPECT_EQ(1, __glPointParameterfv_size(GL_POINT_FADE_THRESHOLD_SIZE_SGIS)); |
EXPECT_EQ(1, __glPointParameterfv_size(GL_POINT_SPRITE_R_MODE_NV)); |
EXPECT_EQ(1, __glPointParameterfv_size(GL_POINT_SPRITE_COORD_ORIGIN)); |
EXPECT_EQ(3, __glPointParameterfv_size(GL_POINT_DISTANCE_ATTENUATION)); |
EXPECT_EQ(3, __glPointParameterfv_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, __glPointParameterfv_size(i)) << "i = 0x" << |
std::setw(4) << std::setfill('0') << std::hex << i; |
} |
} |
} |