From f5f86200567035aebb22c404fd755af6e6084f53 Mon Sep 17 00:00:00 2001 From: Christophe Riccio Date: Sun, 25 Sep 2016 10:29:08 +0200 Subject: [PATCH 1/2] Added pure test --- test/bug/CMakeLists.txt | 1 + test/bug/ms_vec2.cpp | 14 ++ test/core/CMakeLists.txt | 1 + test/core/core_force_pure.cpp | 421 ++++++++++++++++++++++++++++++++++ 4 files changed, 437 insertions(+) create mode 100644 test/bug/ms_vec2.cpp create mode 100644 test/core/core_force_pure.cpp diff --git a/test/bug/CMakeLists.txt b/test/bug/CMakeLists.txt index e69de29b..1e72aaf9 100644 --- a/test/bug/CMakeLists.txt +++ b/test/bug/CMakeLists.txt @@ -0,0 +1 @@ +glmCreateTestGTC(ms_vec2) \ No newline at end of file diff --git a/test/bug/ms_vec2.cpp b/test/bug/ms_vec2.cpp new file mode 100644 index 00000000..2c520fa4 --- /dev/null +++ b/test/bug/ms_vec2.cpp @@ -0,0 +1,14 @@ +#define GLM_FORCE_SWIZZLE +#include + +struct Foo +{ + static glm::vec2 Bar; +}; + +glm::vec2 Foo::Bar = glm::vec2(1.f, 1.f); + +int main() +{ + return 1; +} diff --git a/test/core/CMakeLists.txt b/test/core/CMakeLists.txt index c2349c49..71ab6e26 100644 --- a/test/core/CMakeLists.txt +++ b/test/core/CMakeLists.txt @@ -1,3 +1,4 @@ +glmCreateTestGTC(core_force_pure) glmCreateTestGTC(core_type_aligned) glmCreateTestGTC(core_type_cast) glmCreateTestGTC(core_type_ctor) diff --git a/test/core/core_force_pure.cpp b/test/core/core_force_pure.cpp new file mode 100644 index 00000000..68f82119 --- /dev/null +++ b/test/core/core_force_pure.cpp @@ -0,0 +1,421 @@ +#define GLM_FORCE_PURE +#define GLM_FORCE_ALIGNED +#define GLM_FORCE_SWIZZLE +#include +#include +#include +#include +#include +#include +#include + +int test_vec4_ctor() +{ + int Error = 0; + + { + glm::ivec4 A(1, 2, 3, 4); + glm::ivec4 B(A); + Error += glm::all(glm::equal(A, B)) ? 0 : 1; + } + +# if GLM_HAS_TRIVIAL_QUERIES + // Error += std::is_trivially_default_constructible::value ? 0 : 1; + // Error += std::is_trivially_copy_assignable::value ? 0 : 1; + Error += std::is_trivially_copyable::value ? 0 : 1; + Error += std::is_trivially_copyable::value ? 0 : 1; + Error += std::is_trivially_copyable::value ? 0 : 1; + Error += std::is_trivially_copyable::value ? 0 : 1; + + Error += std::is_copy_constructible::value ? 0 : 1; +# endif + +#if GLM_HAS_INITIALIZER_LISTS + { + glm::vec4 a{ 0, 1, 2, 3 }; + std::vector v = { + {0, 1, 2, 3}, + {4, 5, 6, 7}, + {8, 9, 0, 1}}; + } + + { + glm::dvec4 a{ 0, 1, 2, 3 }; + std::vector v = { + {0, 1, 2, 3}, + {4, 5, 6, 7}, + {8, 9, 0, 1}}; + } +#endif + +#if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE) + { + glm::vec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f); + glm::vec4 B = A.xyzw; + glm::vec4 C(A.xyzw); + glm::vec4 D(A.xyzw()); + glm::vec4 E(A.x, A.yzw); + glm::vec4 F(A.x, A.yzw()); + glm::vec4 G(A.xyz, A.w); + glm::vec4 H(A.xyz(), A.w); + glm::vec4 I(A.xy, A.zw); + glm::vec4 J(A.xy(), A.zw()); + glm::vec4 K(A.x, A.y, A.zw); + glm::vec4 L(A.x, A.yz, A.w); + glm::vec4 M(A.xy, A.z, A.w); + + Error += glm::all(glm::equal(A, B)) ? 0 : 1; + Error += glm::all(glm::equal(A, C)) ? 0 : 1; + Error += glm::all(glm::equal(A, D)) ? 0 : 1; + Error += glm::all(glm::equal(A, E)) ? 0 : 1; + Error += glm::all(glm::equal(A, F)) ? 0 : 1; + Error += glm::all(glm::equal(A, G)) ? 0 : 1; + Error += glm::all(glm::equal(A, H)) ? 0 : 1; + Error += glm::all(glm::equal(A, I)) ? 0 : 1; + Error += glm::all(glm::equal(A, J)) ? 0 : 1; + Error += glm::all(glm::equal(A, K)) ? 0 : 1; + Error += glm::all(glm::equal(A, L)) ? 0 : 1; + Error += glm::all(glm::equal(A, M)) ? 0 : 1; + } +#endif// GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE) + + { + glm::vec4 A(1); + glm::vec4 B(1, 1, 1, 1); + + Error += A == B ? 0 : 1; + } + + { + std::vector Tests; + Tests.push_back(glm::vec4(glm::vec2(1, 2), 3, 4)); + Tests.push_back(glm::vec4(1, glm::vec2(2, 3), 4)); + Tests.push_back(glm::vec4(1, 2, glm::vec2(3, 4))); + Tests.push_back(glm::vec4(glm::vec3(1, 2, 3), 4)); + Tests.push_back(glm::vec4(1, glm::vec3(2, 3, 4))); + Tests.push_back(glm::vec4(glm::vec2(1, 2), glm::vec2(3, 4))); + Tests.push_back(glm::vec4(1, 2, 3, 4)); + Tests.push_back(glm::vec4(glm::vec4(1, 2, 3, 4))); + + for(std::size_t i = 0; i < Tests.size(); ++i) + Error += Tests[i] == glm::vec4(1, 2, 3, 4) ? 0 : 1; + } + + return Error; +} + +int test_bvec4_ctor() +{ + int Error = 0; + + glm::bvec4 const A(true); + glm::bvec4 const B(true); + glm::bvec4 const C(false); + glm::bvec4 const D = A && B; + glm::bvec4 const E = A && C; + glm::bvec4 const F = A || C; + bool const G = A == C; + bool const H = A != C; + + Error += D == glm::bvec4(true) ? 0 : 1; + Error += E == glm::bvec4(false) ? 0 : 1; + Error += F == glm::bvec4(true) ? 0 : 1; + + return Error; +} + +int test_vec4_operators() +{ + int Error = 0; + + { + glm::vec4 A(1.0f); + glm::vec4 B(1.0f); + bool R = A != B; + bool S = A == B; + + Error += (S && !R) ? 0 : 1; + } + + { + glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); + glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f); + + glm::vec4 C = A + B; + Error += C == glm::vec4(5, 7, 9, 11) ? 0 : 1; + + glm::vec4 D = B - A; + Error += D == glm::vec4(3, 3, 3, 3) ? 0 : 1; + + glm::vec4 E = A * B; + Error += E == glm::vec4(4, 10, 18, 28) ? 0 : 1; + + glm::vec4 F = B / A; + Error += F == glm::vec4(4, 2.5, 2, 7.0f / 4.0f) ? 0 : 1; + + glm::vec4 G = A + 1.0f; + Error += G == glm::vec4(2, 3, 4, 5) ? 0 : 1; + + glm::vec4 H = B - 1.0f; + Error += H == glm::vec4(3, 4, 5, 6) ? 0 : 1; + + glm::vec4 I = A * 2.0f; + Error += I == glm::vec4(2, 4, 6, 8) ? 0 : 1; + + glm::vec4 J = B / 2.0f; + Error += J == glm::vec4(2, 2.5, 3, 3.5) ? 0 : 1; + + glm::vec4 K = 1.0f + A; + Error += K == glm::vec4(2, 3, 4, 5) ? 0 : 1; + + glm::vec4 L = 1.0f - B; + Error += L == glm::vec4(-3, -4, -5, -6) ? 0 : 1; + + glm::vec4 M = 2.0f * A; + Error += M == glm::vec4(2, 4, 6, 8) ? 0 : 1; + + glm::vec4 N = 2.0f / B; + Error += N == glm::vec4(0.5, 2.0 / 5.0, 2.0 / 6.0, 2.0 / 7.0) ? 0 : 1; + } + + { + glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); + glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f); + + A += B; + Error += A == glm::vec4(5, 7, 9, 11) ? 0 : 1; + + A += 1.0f; + Error += A == glm::vec4(6, 8, 10, 12) ? 0 : 1; + } + { + glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); + glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f); + + B -= A; + Error += B == glm::vec4(3, 3, 3, 3) ? 0 : 1; + + B -= 1.0f; + Error += B == glm::vec4(2, 2, 2, 2) ? 0 : 1; + } + { + glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); + glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f); + + A *= B; + Error += A == glm::vec4(4, 10, 18, 28) ? 0 : 1; + + A *= 2.0f; + Error += A == glm::vec4(8, 20, 36, 56) ? 0 : 1; + } + { + glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); + glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f); + + B /= A; + Error += B == glm::vec4(4, 2.5, 2, 7.0f / 4.0f) ? 0 : 1; + + B /= 2.0f; + Error += B == glm::vec4(2, 1.25, 1, 7.0f / 4.0f / 2.0f) ? 0 : 1; + } + { + glm::vec4 B(2.0f); + + B /= B.y; + Error += B == glm::vec4(1.0f) ? 0 : 1; + } + + { + glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); + glm::vec4 B = -A; + Error += B == glm::vec4(-1.0f, -2.0f, -3.0f, -4.0f) ? 0 : 1; + } + + { + glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); + glm::vec4 B = --A; + Error += B == glm::vec4(0.0f, 1.0f, 2.0f, 3.0f) ? 0 : 1; + } + + { + glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); + glm::vec4 B = A--; + Error += B == glm::vec4(1.0f, 2.0f, 3.0f, 4.0f) ? 0 : 1; + Error += A == glm::vec4(0.0f, 1.0f, 2.0f, 3.0f) ? 0 : 1; + } + + { + glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); + glm::vec4 B = ++A; + Error += B == glm::vec4(2.0f, 3.0f, 4.0f, 5.0f) ? 0 : 1; + } + + { + glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f); + glm::vec4 B = A++; + Error += B == glm::vec4(1.0f, 2.0f, 3.0f, 4.0f) ? 0 : 1; + Error += A == glm::vec4(2.0f, 3.0f, 4.0f, 5.0f) ? 0 : 1; + } + + return Error; +} + +int test_vec4_equal() +{ + int Error = 0; + + { + glm::vec4 const A(1, 2, 3, 4); + glm::vec4 const B(1, 2, 3, 4); + Error += A == B ? 0 : 1; + Error += A != B ? 1 : 0; + } + + { + glm::ivec4 const A(1, 2, 3, 4); + glm::ivec4 const B(1, 2, 3, 4); + Error += A == B ? 0 : 1; + Error += A != B ? 1 : 0; + } + + return Error; +} + +int test_vec4_size() +{ + int Error = 0; + + Error += sizeof(glm::vec4) == sizeof(glm::lowp_vec4) ? 0 : 1; + Error += sizeof(glm::vec4) == sizeof(glm::mediump_vec4) ? 0 : 1; + Error += sizeof(glm::vec4) == sizeof(glm::highp_vec4) ? 0 : 1; + Error += 16 == sizeof(glm::mediump_vec4) ? 0 : 1; + Error += sizeof(glm::dvec4) == sizeof(glm::lowp_dvec4) ? 0 : 1; + Error += sizeof(glm::dvec4) == sizeof(glm::mediump_dvec4) ? 0 : 1; + Error += sizeof(glm::dvec4) == sizeof(glm::highp_dvec4) ? 0 : 1; + Error += 32 == sizeof(glm::highp_dvec4) ? 0 : 1; + Error += glm::vec4().length() == 4 ? 0 : 1; + Error += glm::dvec4().length() == 4 ? 0 : 1; + + return Error; +} + +int test_vec4_swizzle_partial() +{ + int Error = 0; + + glm::vec4 A(1, 2, 3, 4); + +# if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE_RELAX) + { + glm::vec4 B(A.xy, A.zw); + Error += A == B ? 0 : 1; + } + { + glm::vec4 B(A.xy, 3.0f, 4.0f); + Error += A == B ? 0 : 1; + } + { + glm::vec4 B(1.0f, A.yz, 4.0f); + Error += A == B ? 0 : 1; + } + { + glm::vec4 B(1.0f, 2.0f, A.zw); + Error += A == B ? 0 : 1; + } + + { + glm::vec4 B(A.xyz, 4.0f); + Error += A == B ? 0 : 1; + } + { + glm::vec4 B(1.0f, A.yzw); + Error += A == B ? 0 : 1; + } +# endif + + return Error; +} + +int test_operator_increment() +{ + int Error(0); + + glm::ivec4 v0(1); + glm::ivec4 v1(v0); + glm::ivec4 v2(v0); + glm::ivec4 v3 = ++v1; + glm::ivec4 v4 = v2++; + + Error += glm::all(glm::equal(v0, v4)) ? 0 : 1; + Error += glm::all(glm::equal(v1, v2)) ? 0 : 1; + Error += glm::all(glm::equal(v1, v3)) ? 0 : 1; + + int i0(1); + int i1(i0); + int i2(i0); + int i3 = ++i1; + int i4 = i2++; + + Error += i0 == i4 ? 0 : 1; + Error += i1 == i2 ? 0 : 1; + Error += i1 == i3 ? 0 : 1; + + return Error; +} + +namespace heap +{ + class A + { + float f; + }; + + class B : public A + { + float g; + glm::vec4 v; + }; + + int test() + { + int Error(0); + + A* p = new B; + delete p; + + return Error; + } +}//namespace heap + +int test_vec4_simd() +{ + int Error = 0; + + glm::vec4 const a(std::clock(), std::clock(), std::clock(), std::clock()); + glm::vec4 const b(std::clock(), std::clock(), std::clock(), std::clock()); + + glm::vec4 const c(b * a); + glm::vec4 const d(a + c); + + Error += glm::all(glm::greaterThanEqual(d, glm::vec4(0))) ? 0 : 1; + + return Error; +} + +int main() +{ + int Error(0); + + Error += test_vec4_ctor(); + Error += test_bvec4_ctor(); + Error += test_vec4_size(); + Error += test_vec4_operators(); + Error += test_vec4_equal(); + Error += test_vec4_swizzle_partial(); + Error += test_vec4_simd(); + Error += test_operator_increment(); + Error += heap::test(); + + return Error; +} + From b7a286b186ea972406f6a3431719d0095891f924 Mon Sep 17 00:00:00 2001 From: Christophe Riccio Date: Sun, 25 Sep 2016 10:35:30 +0200 Subject: [PATCH 2/2] Renamed test --- readme.md | 2 +- test/bug/CMakeLists.txt | 2 +- test/bug/{ms_vec2.cpp => bug_ms_vec_static.cpp} | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) rename test/bug/{ms_vec2.cpp => bug_ms_vec_static.cpp} (93%) diff --git a/readme.md b/readme.md index efe14e2a..48a5730c 100644 --- a/readme.md +++ b/readme.md @@ -51,7 +51,7 @@ glm::mat4 camera(float Translate, glm::vec2 const & Rotate) ## Release notes -#### [GLM 0.9.8.1](https://github.com/g-truc/glm/tree/0.9.8) - 2016-XX-XX +#### [GLM 0.9.8.1](https://github.com/g-truc/glm/tree/0.9.8) - 2016-09-25 ##### Improvements: - Optimized quaternion log function #554 diff --git a/test/bug/CMakeLists.txt b/test/bug/CMakeLists.txt index 1e72aaf9..26e85694 100644 --- a/test/bug/CMakeLists.txt +++ b/test/bug/CMakeLists.txt @@ -1 +1 @@ -glmCreateTestGTC(ms_vec2) \ No newline at end of file +glmCreateTestGTC(bug_ms_vec_static) diff --git a/test/bug/ms_vec2.cpp b/test/bug/bug_ms_vec_static.cpp similarity index 93% rename from test/bug/ms_vec2.cpp rename to test/bug/bug_ms_vec_static.cpp index 2c520fa4..812d97b3 100644 --- a/test/bug/ms_vec2.cpp +++ b/test/bug/bug_ms_vec_static.cpp @@ -10,5 +10,5 @@ glm::vec2 Foo::Bar = glm::vec2(1.f, 1.f); int main() { - return 1; + return 0; }