557 lines
20 KiB
C++
557 lines
20 KiB
C++
/*
|
|
* 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;
|
|
}
|
|
}
|
|
}
|