mewin/glm
1
0
Fork 0
Code Releases Activity

Use 32 bits integers for these tests instead of 64 bits

Browse Source
This commit is contained in:
Christophe Riccio 2011-10-22 19:09:20 +01:00
parent 671ebd40eb
commit 621c266f33
1 changed files with 48 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
test/core/core_func_integer.cpp
View File

@ -8,7 +8,6 @@
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include <glm/gtx/number_precision.hpp>
#include <iostream> #include <iostream>
enum result enum result
@ -19,7 +18,7 @@ enum result
STATIC_ASSERT STATIC_ASSERT
}; };
namespace extractField namespace bitfieldExtract
{ {
template <typename genType, typename sizeType> template <typename genType, typename sizeType>
struct type struct type
@ -31,48 +30,48 @@ namespace extractField
result Result; result Result;
}; };
typedef type<glm::uint64, glm::uint32> typeU64; typedef type<glm::uint, glm::uint> typeU32;
typeU64 const Data64[] = typeU32 const Data32[] =
{ {
{0xffffffffffffffff, 8, 0, 0x0000000000000000, SUCCESS}, {0xffffffff, 8, 0, 0x00000000, SUCCESS},
{0x0000000000000000, 0,64, 0x0000000000000000, SUCCESS}, {0x00000000, 0,32, 0x00000000, SUCCESS},
{0xffffffffffffffff, 0,64, 0xffffffffffffffff, SUCCESS}, {0xffffffff, 0,32, 0xffffffff, SUCCESS},
{0x0f0f0f0f0f0f0f0f, 0,64, 0x0f0f0f0f0f0f0f0f, SUCCESS}, {0x0f0f0f0f, 0,32, 0x0f0f0f0f, SUCCESS},
{0x0000000000000000, 8, 0, 0x0000000000000000, SUCCESS}, {0x00000000, 8, 0, 0x00000000, SUCCESS},
{0x8000000000000000,63, 1, 0x0000000000000001, SUCCESS}, {0x80000000,31, 1, 0x00000001, SUCCESS},
{0x7fffffffffffffff,63, 1, 0x0000000000000000, SUCCESS}, {0x7fffffff,31, 1, 0x00000000, SUCCESS},
{0x0000000000000300, 8, 8, 0x0000000000000003, SUCCESS}, {0x00000300, 8, 8, 0x00000003, SUCCESS},
{0x000000000000ff00, 8, 8, 0x00000000000000ff, SUCCESS}, {0x0000ff00, 8, 8, 0x000000ff, SUCCESS},
{0xfffffffffffffff0, 0, 5, 0x0000000000000010, SUCCESS}, {0xfffffff0, 0, 5, 0x00000010, SUCCESS},
{0x00000000000000ff, 1, 3, 0x0000000000000007, SUCCESS}, {0x000000ff, 1, 3, 0x00000007, SUCCESS},
{0x00000000000000ff, 0, 3, 0x0000000000000007, SUCCESS}, {0x000000ff, 0, 3, 0x00000007, SUCCESS},
{0x0000000000000000, 0, 2, 0x0000000000000000, SUCCESS}, {0x00000000, 0, 2, 0x00000000, SUCCESS},
{0xffffffffffffffff, 0, 8, 0x00000000000000ff, SUCCESS}, {0xffffffff, 0, 8, 0x000000ff, SUCCESS},
{0xffffffff00000000,32,32, 0x00000000ffffffff, SUCCESS}, {0xffff0000,16,16, 0x0000ffff, SUCCESS},
{0xfffffffffffffff0, 0, 8, 0x0000000000000000, FAIL}, {0xfffffff0, 0, 8, 0x00000000, FAIL},
{0xffffffffffffffff,32,32, 0x0000000000000000, FAIL}, {0xffffffff,16,16, 0x00000000, FAIL},
//{0xffffffffffffffff,64, 1, 0x0000000000000000, ASSERT}, // Throw an assert //{0xffffffff,32, 1, 0x00000000, ASSERT}, // Throw an assert
//{0xffffffffffffffff, 0,65, 0x0000000000000000, ASSERT}, // Throw an assert //{0xffffffff, 0,33, 0x00000000, ASSERT}, // Throw an assert
//{0xffffffffffffffff,33,32, 0x0000000000000000, ASSERT}, // Throw an assert //{0xffffffff,16,16, 0x00000000, ASSERT}, // Throw an assert
}; };
int test() int test()
{ {
glm::uint32 count = sizeof(Data64) / sizeof(typeU64); glm::uint count = sizeof(Data32) / sizeof(typeU32);
for(glm::uint32 i = 0; i < count; ++i) for(glm::uint i = 0; i < count; ++i)
{ {
glm::uint64 Return = glm::bitfieldExtract( glm::uint Return = glm::bitfieldExtract(
Data64[i].Value, Data32[i].Value,
Data64[i].BitFirst, Data32[i].BitFirst,
Data64[i].BitCount); Data32[i].BitCount);
bool Compare = Data64[i].Return == Return; bool Compare = Data32[i].Return == Return;
if(Data64[i].Result == SUCCESS && Compare) if(Data32[i].Result == SUCCESS && Compare)
continue; continue;
else if(Data64[i].Result == FAIL && !Compare) else if(Data32[i].Result == FAIL && !Compare)
continue; continue;
std::cout << "glm::bitfieldExtract test fail on test " << i << std::endl; std::cout << "glm::bitfieldExtract test fail on test " << i << std::endl;
@ -83,7 +82,7 @@ namespace extractField
} }
}//extractField }//extractField
namespace bitRevert namespace bitfieldReverse
{ {
template <typename genType> template <typename genType>
struct type struct type
@ -93,32 +92,32 @@ namespace bitRevert
result Result; result Result;
}; };
typedef type<glm::uint64> typeU64; typedef type<glm::uint> typeU32;
typeU64 const Data64[] = typeU32 const Data32[] =
{ {
{0xffffffffffffffff, 0xffffffffffffffff, SUCCESS}, {0xffffffff, 0xffffffff, SUCCESS},
{0x0000000000000000, 0x0000000000000000, SUCCESS}, {0x00000000, 0x00000000, SUCCESS},
{0xf000000000000000, 0x000000000000000f, SUCCESS}, {0xf0000000, 0x0000000f, SUCCESS},
}; };
int test() int test()
{ {
glm::uint32 count = sizeof(Data64) / sizeof(typeU64); glm::uint count = sizeof(Data32) / sizeof(typeU32);
for(glm::uint32 i = 0; i < count; ++i) for(glm::uint i = 0; i < count; ++i)
{ {
glm::uint64 Return = glm::bitfieldReverse( glm::uint Return = glm::bitfieldReverse(
Data64[i].Value); Data32[i].Value);
bool Compare = Data64[i].Return == Return; bool Compare = Data32[i].Return == Return;
if(Data64[i].Result == SUCCESS && Compare) if(Data32[i].Result == SUCCESS && Compare)
continue; continue;
else if(Data64[i].Result == FAIL && !Compare) else if(Data32[i].Result == FAIL && !Compare)
continue; continue;
std::cout << "glm::bitRevert test fail on test " << i << std::endl; std::cout << "glm::bitfieldReverse test fail on test " << i << std::endl;
return 1; return 1;
} }
@ -130,9 +129,8 @@ int main()
{ {
int Error = 0; int Error = 0;
//GLM_STATIC_ASSERT(sizeof(glm::uint64) == 2, "glm::uint64 isn't a 64 bits type"); Error += ::bitfieldExtract::test();
Error += ::bitfieldReverse::test();
Error += ::extractField::test();
Error += ::bitRevert::test();
return Error; return Error;
} }