Christophe Riccio
ago%!(EXTRA string=6 years)
parent
07c6d56b5f
commit
a91fb705db
4 changed files with 272 additions and 464 deletions
@ -1,211 +1,309 @@ |
||||
#include <glm/ext/vector_integer.hpp> |
||||
#include <glm/ext/vector_int1.hpp> |
||||
#include <glm/ext/vector_int2.hpp> |
||||
#include <glm/ext/vector_int3.hpp> |
||||
#include <glm/ext/vector_int4.hpp> |
||||
#include <glm/ext/vector_uint1.hpp> |
||||
#include <glm/ext/vector_uint2.hpp> |
||||
#include <glm/ext/vector_uint3.hpp> |
||||
#include <glm/ext/vector_uint4.hpp> |
||||
#include <glm/vector_relational.hpp> |
||||
|
||||
template <typename genType> |
||||
static int test_operators() |
||||
#include <glm/ext/scalar_int_sized.hpp> |
||||
#include <glm/ext/scalar_uint_sized.hpp> |
||||
#include <vector> |
||||
#include <ctime> |
||||
#include <cstdio> |
||||
|
||||
namespace isPowerOfTwo |
||||
{ |
||||
int Error = 0; |
||||
template<typename genType> |
||||
struct type |
||||
{ |
||||
genType Value; |
||||
bool Return; |
||||
}; |
||||
|
||||
int test_int16() |
||||
{ |
||||
genType const A(1); |
||||
genType const B(1); |
||||
type<glm::int16> const Data[] = |
||||
{ |
||||
{ 0x0001, true }, |
||||
{ 0x0002, true }, |
||||
{ 0x0004, true }, |
||||
{ 0x0080, true }, |
||||
{ 0x0000, true }, |
||||
{ 0x0003, false } |
||||
}; |
||||
|
||||
int Error = 0; |
||||
|
||||
for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::int16>); i < n; ++i) |
||||
{ |
||||
bool Result = glm::isPowerOfTwo(Data[i].Value); |
||||
Error += Data[i].Return == Result ? 0 : 1; |
||||
} |
||||
|
||||
return Error; |
||||
} |
||||
|
||||
bool const R = A != B; |
||||
bool const S = A == B; |
||||
Error += (S && !R) ? 0 : 1; |
||||
int test_uint16() |
||||
{ |
||||
type<glm::uint16> const Data[] = |
||||
{ |
||||
{ 0x0001, true }, |
||||
{ 0x0002, true }, |
||||
{ 0x0004, true }, |
||||
{ 0x0000, true }, |
||||
{ 0x0000, true }, |
||||
{ 0x0003, false } |
||||
}; |
||||
|
||||
int Error = 0; |
||||
|
||||
for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::uint16>); i < n; ++i) |
||||
{ |
||||
bool Result = glm::isPowerOfTwo(Data[i].Value); |
||||
Error += Data[i].Return == Result ? 0 : 1; |
||||
} |
||||
|
||||
return Error; |
||||
} |
||||
|
||||
int test_int32() |
||||
{ |
||||
genType const A(1); |
||||
genType const B(1); |
||||
type<int> const Data[] = |
||||
{ |
||||
{ 0x00000001, true }, |
||||
{ 0x00000002, true }, |
||||
{ 0x00000004, true }, |
||||
{ 0x0000000f, false }, |
||||
{ 0x00000000, true }, |
||||
{ 0x00000003, false } |
||||
}; |
||||
|
||||
int Error = 0; |
||||
|
||||
for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<int>); i < n; ++i) |
||||
{ |
||||
bool Result = glm::isPowerOfTwo(Data[i].Value); |
||||
Error += Data[i].Return == Result ? 0 : 1; |
||||
} |
||||
|
||||
return Error; |
||||
} |
||||
|
||||
genType const C = A + B; |
||||
Error += C == genType(2) ? 0 : 1; |
||||
int test_uint32() |
||||
{ |
||||
type<glm::uint> const Data[] = |
||||
{ |
||||
{ 0x00000001, true }, |
||||
{ 0x00000002, true }, |
||||
{ 0x00000004, true }, |
||||
{ 0x80000000, true }, |
||||
{ 0x00000000, true }, |
||||
{ 0x00000003, false } |
||||
}; |
||||
|
||||
int Error = 0; |
||||
|
||||
for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::uint>); i < n; ++i) |
||||
{ |
||||
bool Result = glm::isPowerOfTwo(Data[i].Value); |
||||
Error += Data[i].Return == Result ? 0 : 1; |
||||
} |
||||
|
||||
return Error; |
||||
} |
||||
|
||||
genType const D = A - B; |
||||
Error += D == genType(0) ? 0 : 1; |
||||
int test() |
||||
{ |
||||
int Error = 0; |
||||
|
||||
genType const E = A * B; |
||||
Error += E == genType(1) ? 0 : 1; |
||||
Error += test_int16(); |
||||
Error += test_uint16(); |
||||
Error += test_int32(); |
||||
Error += test_uint32(); |
||||
|
||||
genType const F = A / B; |
||||
Error += F == genType(1) ? 0 : 1; |
||||
return Error; |
||||
} |
||||
}//isPowerOfTwo
|
||||
|
||||
namespace prevPowerOfTwo |
||||
{ |
||||
template <typename T> |
||||
int run() |
||||
{ |
||||
genType const A(3); |
||||
genType const B(2); |
||||
int Error = 0; |
||||
|
||||
T const A = glm::prevPowerOfTwo(static_cast<T>(7)); |
||||
Error += A == static_cast<T>(4) ? 0 : 1; |
||||
|
||||
T const B = glm::prevPowerOfTwo(static_cast<T>(15)); |
||||
Error += B == static_cast<T>(8) ? 0 : 1; |
||||
|
||||
T const C = glm::prevPowerOfTwo(static_cast<T>(31)); |
||||
Error += C == static_cast<T>(16) ? 0 : 1; |
||||
|
||||
genType const C = A % B; |
||||
Error += C == genType(1) ? 0 : 1; |
||||
T const D = glm::prevPowerOfTwo(static_cast<T>(32)); |
||||
Error += D == static_cast<T>(32) ? 0 : 1; |
||||
|
||||
return Error; |
||||
} |
||||
|
||||
int test() |
||||
{ |
||||
genType const A(1); |
||||
genType const B(1); |
||||
genType const C(0); |
||||
int Error = 0; |
||||
|
||||
genType const I = A & B; |
||||
Error += I == genType(1) ? 0 : 1; |
||||
genType const D = A & C; |
||||
Error += D == genType(0) ? 0 : 1; |
||||
Error += run<glm::int8>(); |
||||
Error += run<glm::int16>(); |
||||
Error += run<glm::int32>(); |
||||
Error += run<glm::int64>(); |
||||
|
||||
genType const E = A | B; |
||||
Error += E == genType(1) ? 0 : 1; |
||||
genType const F = A | C; |
||||
Error += F == genType(1) ? 0 : 1; |
||||
Error += run<glm::uint8>(); |
||||
Error += run<glm::uint16>(); |
||||
Error += run<glm::uint32>(); |
||||
Error += run<glm::uint64>(); |
||||
|
||||
genType const G = A ^ B; |
||||
Error += G == genType(0) ? 0 : 1; |
||||
genType const H = A ^ C; |
||||
Error += H == genType(1) ? 0 : 1; |
||||
return Error; |
||||
} |
||||
}//namespace prevPowerOfTwo
|
||||
|
||||
namespace nextPowerOfTwo |
||||
{ |
||||
template <typename T> |
||||
int run() |
||||
{ |
||||
genType const A(0); |
||||
genType const B(1); |
||||
genType const C(2); |
||||
int Error = 0; |
||||
|
||||
T const A = glm::nextPowerOfTwo(static_cast<T>(7)); |
||||
Error += A == static_cast<T>(8) ? 0 : 1; |
||||
|
||||
T const B = glm::nextPowerOfTwo(static_cast<T>(15)); |
||||
Error += B == static_cast<T>(16) ? 0 : 1; |
||||
|
||||
genType const D = B << B; |
||||
Error += D == genType(2) ? 0 : 1; |
||||
genType const E = C >> B; |
||||
Error += E == genType(1) ? 0 : 1; |
||||
T const C = glm::nextPowerOfTwo(static_cast<T>(31)); |
||||
Error += C == static_cast<T>(32) ? 0 : 1; |
||||
|
||||
T const D = glm::nextPowerOfTwo(static_cast<T>(32)); |
||||
Error += D == static_cast<T>(32) ? 0 : 1; |
||||
|
||||
return Error; |
||||
} |
||||
|
||||
return Error; |
||||
} |
||||
int test() |
||||
{ |
||||
int Error = 0; |
||||
|
||||
Error += run<glm::int8>(); |
||||
Error += run<glm::int16>(); |
||||
Error += run<glm::int32>(); |
||||
Error += run<glm::int64>(); |
||||
|
||||
Error += run<glm::uint8>(); |
||||
Error += run<glm::uint16>(); |
||||
Error += run<glm::uint32>(); |
||||
Error += run<glm::uint64>(); |
||||
|
||||
return Error; |
||||
} |
||||
}//namespace nextPowerOfTwo
|
||||
|
||||
template <typename genType> |
||||
static int test_ctor() |
||||
namespace prevMultiple |
||||
{ |
||||
typedef typename genType::value_type T; |
||||
|
||||
int Error = 0; |
||||
template<typename genIUType> |
||||
struct type |
||||
{ |
||||
genIUType Source; |
||||
genIUType Multiple; |
||||
genIUType Return; |
||||
}; |
||||
|
||||
genType const A = genType(1); |
||||
template <typename T> |
||||
int run() |
||||
{ |
||||
type<T> const Data[] = |
||||
{ |
||||
{ 8, 3, 6 }, |
||||
{ 7, 7, 7 } |
||||
}; |
||||
|
||||
genType const E(genType(1)); |
||||
Error += A == E ? 0 : 1; |
||||
int Error = 0; |
||||
|
||||
genType const F(E); |
||||
Error += A == F ? 0 : 1; |
||||
for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<T>); i < n; ++i) |
||||
{ |
||||
glm::vec<4, T> const Result = glm::prevMultiple(glm::vec<4, T>(Data[i].Source), Data[i].Multiple); |
||||
Error += glm::vec<4, T>(Data[i].Return) == Result ? 0 : 1; |
||||
} |
||||
|
||||
genType const B = genType(1); |
||||
genType const G(glm::vec<2, T>(1)); |
||||
Error += B == G ? 0 : 1; |
||||
return Error; |
||||
} |
||||
|
||||
genType const H(glm::vec<3, T>(1)); |
||||
Error += B == H ? 0 : 1; |
||||
int test() |
||||
{ |
||||
int Error = 0; |
||||
|
||||
genType const I(glm::vec<4, T>(1)); |
||||
Error += B == I ? 0 : 1; |
||||
Error += run<glm::int8>(); |
||||
Error += run<glm::int16>(); |
||||
Error += run<glm::int32>(); |
||||
Error += run<glm::int64>(); |
||||
|
||||
return Error; |
||||
} |
||||
Error += run<glm::uint8>(); |
||||
Error += run<glm::uint16>(); |
||||
Error += run<glm::uint32>(); |
||||
Error += run<glm::uint64>(); |
||||
|
||||
template <typename genType> |
||||
static int test_size() |
||||
return Error; |
||||
} |
||||
}//namespace prevMultiple
|
||||
|
||||
namespace nextMultiple |
||||
{ |
||||
int Error = 0; |
||||
template<typename genIUType> |
||||
struct type |
||||
{ |
||||
genIUType Source; |
||||
genIUType Multiple; |
||||
genIUType Return; |
||||
}; |
||||
|
||||
Error += sizeof(typename genType::value_type) == sizeof(genType) ? 0 : 1; |
||||
Error += genType().length() == 1 ? 0 : 1; |
||||
Error += genType::length() == 1 ? 0 : 1; |
||||
template <typename T> |
||||
int run() |
||||
{ |
||||
type<T> const Data[] = |
||||
{ |
||||
{ 8, 3, 6 }, |
||||
{ 7, 7, 7 } |
||||
}; |
||||
|
||||
return Error; |
||||
} |
||||
int Error = 0; |
||||
|
||||
template <typename genType> |
||||
static int test_relational() |
||||
{ |
||||
int Error = 0; |
||||
for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<T>); i < n; ++i) |
||||
{ |
||||
glm::vec<4, T> const Result = glm::nextMultiple(glm::vec<4, T>(Data[i].Source), Data[i].Multiple); |
||||
Error += glm::vec<4, T>(Data[i].Return) == Result ? 0 : 1; |
||||
} |
||||
|
||||
genType const A(1); |
||||
genType const B(1); |
||||
genType const C(0); |
||||
return Error; |
||||
} |
||||
|
||||
Error += A == B ? 0 : 1; |
||||
Error += A != C ? 0 : 1; |
||||
Error += all(equal(A, B)) ? 0 : 1; |
||||
Error += any(notEqual(A, C)) ? 0 : 1; |
||||
int test() |
||||
{ |
||||
int Error = 0; |
||||
|
||||
return Error; |
||||
} |
||||
Error += run<glm::int8>(); |
||||
Error += run<glm::int16>(); |
||||
Error += run<glm::int32>(); |
||||
Error += run<glm::int64>(); |
||||
|
||||
template <typename genType> |
||||
static int test_constexpr() |
||||
{ |
||||
# if GLM_CONFIG_CONSTEXP == GLM_ENABLE |
||||
static_assert(genType::length() == 1, "GLM: Failed constexpr"); |
||||
static_assert(genType(1)[0] == 1, "GLM: Failed constexpr"); |
||||
static_assert(genType(1) == genType(1), "GLM: Failed constexpr"); |
||||
static_assert(genType(1) != genType(0), "GLM: Failed constexpr"); |
||||
# endif |
||||
|
||||
return 0; |
||||
} |
||||
Error += run<glm::uint8>(); |
||||
Error += run<glm::uint16>(); |
||||
Error += run<glm::uint32>(); |
||||
Error += run<glm::uint64>(); |
||||
|
||||
return Error; |
||||
} |
||||
}//namespace nextMultiple
|
||||
|
||||
int main() |
||||
{ |
||||
int Error = 0; |
||||
|
||||
Error += test_operators<glm::ivec1>(); |
||||
Error += test_operators<glm::lowp_ivec1>(); |
||||
Error += test_operators<glm::mediump_ivec1>(); |
||||
Error += test_operators<glm::highp_ivec1>(); |
||||
|
||||
Error += test_ctor<glm::ivec1>(); |
||||
Error += test_ctor<glm::lowp_ivec1>(); |
||||
Error += test_ctor<glm::mediump_ivec1>(); |
||||
Error += test_ctor<glm::highp_ivec1>(); |
||||
|
||||
Error += test_size<glm::ivec1>(); |
||||
Error += test_size<glm::lowp_ivec1>(); |
||||
Error += test_size<glm::mediump_ivec1>(); |
||||
Error += test_size<glm::highp_ivec1>(); |
||||
|
||||
Error += test_relational<glm::ivec1>(); |
||||
Error += test_relational<glm::lowp_ivec1>(); |
||||
Error += test_relational<glm::mediump_ivec1>(); |
||||
Error += test_relational<glm::highp_ivec1>(); |
||||
|
||||
Error += test_constexpr<glm::ivec1>(); |
||||
Error += test_constexpr<glm::lowp_ivec1>(); |
||||
Error += test_constexpr<glm::mediump_ivec1>(); |
||||
Error += test_constexpr<glm::highp_ivec1>(); |
||||
|
||||
Error += test_operators<glm::uvec1>(); |
||||
Error += test_operators<glm::lowp_uvec1>(); |
||||
Error += test_operators<glm::mediump_uvec1>(); |
||||
Error += test_operators<glm::highp_uvec1>(); |
||||
|
||||
Error += test_ctor<glm::uvec1>(); |
||||
Error += test_ctor<glm::lowp_uvec1>(); |
||||
Error += test_ctor<glm::mediump_uvec1>(); |
||||
Error += test_ctor<glm::highp_uvec1>(); |
||||
|
||||
Error += test_size<glm::uvec1>(); |
||||
Error += test_size<glm::lowp_uvec1>(); |
||||
Error += test_size<glm::mediump_uvec1>(); |
||||
Error += test_size<glm::highp_uvec1>(); |
||||
|
||||
Error += test_relational<glm::uvec1>(); |
||||
Error += test_relational<glm::lowp_uvec1>(); |
||||
Error += test_relational<glm::mediump_uvec1>(); |
||||
Error += test_relational<glm::highp_uvec1>(); |
||||
|
||||
Error += test_constexpr<glm::uvec1>(); |
||||
Error += test_constexpr<glm::lowp_uvec1>(); |
||||
Error += test_constexpr<glm::mediump_uvec1>(); |
||||
Error += test_constexpr<glm::highp_uvec1>(); |
||||
|
||||
Error += isPowerOfTwo::test(); |
||||
Error += prevPowerOfTwo::test(); |
||||
Error += nextPowerOfTwo::test(); |
||||
Error += prevMultiple::test(); |
||||
Error += nextMultiple::test(); |
||||
|
||||
return Error; |
||||
} |
||||
|
||||
Loading…
Reference in New Issue