anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Added more tests

Browse Source
master
Christophe Riccio ago%!(EXTRA string=7 years)
parent 02c4d8b15e
commit 2a20695ce5
2 changed files with 205 additions and 21 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 89
      test/ext/ext_matrix_relational.cpp
  2. 137
      test/ext/ext_vector_relational.cpp

89
test/ext/ext_matrix_relational.cpp
Unescape View File

@ -1,23 +1,59 @@
#include <glm/ext/matrix_relational.hpp> #include <glm/ext/matrix_relational.hpp>
#include <glm/ext/matrix_double2x2.hpp>
#include <glm/ext/matrix_double2x3.hpp>
#include <glm/ext/matrix_double2x4.hpp>
#include <glm/ext/matrix_double3x2.hpp>
#include <glm/ext/matrix_double3x3.hpp>
#include <glm/ext/matrix_double3x4.hpp>
#include <glm/ext/matrix_double4x2.hpp>
#include <glm/ext/matrix_double4x3.hpp>
#include <glm/ext/matrix_double4x4.hpp>
#include <glm/ext/vector_double2.hpp>
#include <glm/ext/vector_double3.hpp>
#include <glm/ext/vector_double4.hpp>
#include <glm/ext/matrix_float2x2.hpp>
#include <glm/ext/matrix_float2x3.hpp>
#include <glm/ext/matrix_float2x4.hpp>
#include <glm/ext/matrix_float3x2.hpp>
#include <glm/ext/matrix_float3x3.hpp>
#include <glm/ext/matrix_float3x4.hpp>
#include <glm/ext/matrix_float4x2.hpp>
#include <glm/ext/matrix_float4x3.hpp> #include <glm/ext/matrix_float4x3.hpp>
#include <glm/ext/matrix_float4x4.hpp>
#include <glm/ext/vector_float2.hpp>
#include <glm/ext/vector_float3.hpp>
#include <glm/ext/vector_float4.hpp> #include <glm/ext/vector_float4.hpp>
int test_equal() template <typename matType, typename vecType>
static int test_equal()
{ {
typedef typename matType::value_type valType;
valType const Epsilon(0.001f);
valType const One(1);
valType const Two(2);
int Error = 0; int Error = 0;
Error += glm::all(glm::equal(glm::mat4x3(1), glm::mat4x3(1), 0.001f)) ? 0 : 1; Error += glm::all(glm::equal(matType(One), matType(One), Epsilon)) ? 0 : 1;
Error += glm::all(glm::equal(glm::mat4x3(1), glm::mat4x3(2), glm::vec4(0.001f))) ? 1 : 0; Error += glm::all(glm::equal(matType(One), matType(Two), vecType(Epsilon))) ? 1 : 0;
return Error; return Error;
} }
int test_notEqual() template <typename matType, typename vecType>
static int test_notEqual()
{ {
typedef typename matType::value_type valType;
valType const Epsilon(0.001f);
valType const One(1);
valType const Two(2);
int Error = 0; int Error = 0;
Error += !glm::any(glm::notEqual(glm::mat4x3(1), glm::mat4x3(1), 0.001f)) ? 0 : 1; Error += !glm::any(glm::notEqual(matType(One), matType(One), Epsilon)) ? 0 : 1;
Error += !glm::any(glm::notEqual(glm::mat4x3(1), glm::mat4x3(2), glm::vec4(0.001f))) ? 1 : 0; Error += !glm::any(glm::notEqual(matType(One), matType(Two), vecType(Epsilon))) ? 1 : 0;
return Error; return Error;
} }
@ -26,8 +62,45 @@ int main()
{ {
int Error = 0; int Error = 0;
Error += test_equal(); Error += test_equal<glm::mat2x2, glm::vec2>();
Error += test_notEqual(); Error += test_equal<glm::mat2x3, glm::vec2>();
Error += test_equal<glm::mat2x4, glm::vec2>();
Error += test_equal<glm::mat3x2, glm::vec3>();
Error += test_equal<glm::mat3x3, glm::vec3>();
Error += test_equal<glm::mat3x4, glm::vec3>();
Error += test_equal<glm::mat4x2, glm::vec4>();
Error += test_equal<glm::mat4x3, glm::vec4>();
Error += test_equal<glm::mat4x4, glm::vec4>();
Error += test_equal<glm::dmat2x2, glm::dvec2>();
Error += test_equal<glm::dmat2x3, glm::dvec2>();
Error += test_equal<glm::dmat2x4, glm::dvec2>();
Error += test_equal<glm::dmat3x2, glm::dvec3>();
Error += test_equal<glm::dmat3x3, glm::dvec3>();
Error += test_equal<glm::dmat3x4, glm::dvec3>();
Error += test_equal<glm::dmat4x2, glm::dvec4>();
Error += test_equal<glm::dmat4x3, glm::dvec4>();
Error += test_equal<glm::dmat4x4, glm::dvec4>();
Error += test_notEqual<glm::mat2x2, glm::vec2>();
Error += test_notEqual<glm::mat2x3, glm::vec2>();
Error += test_notEqual<glm::mat2x4, glm::vec2>();
Error += test_notEqual<glm::mat3x2, glm::vec3>();
Error += test_notEqual<glm::mat3x3, glm::vec3>();
Error += test_notEqual<glm::mat3x4, glm::vec3>();
Error += test_notEqual<glm::mat4x2, glm::vec4>();
Error += test_notEqual<glm::mat4x3, glm::vec4>();
Error += test_notEqual<glm::mat4x4, glm::vec4>();
Error += test_notEqual<glm::dmat2x2, glm::dvec2>();
Error += test_notEqual<glm::dmat2x3, glm::dvec2>();
Error += test_notEqual<glm::dmat2x4, glm::dvec2>();
Error += test_notEqual<glm::dmat3x2, glm::dvec3>();
Error += test_notEqual<glm::dmat3x3, glm::dvec3>();
Error += test_notEqual<glm::dmat3x4, glm::dvec3>();
Error += test_notEqual<glm::dmat4x2, glm::dvec4>();
Error += test_notEqual<glm::dmat4x3, glm::dvec4>();
Error += test_notEqual<glm::dmat4x4, glm::dvec4>();
return Error; return Error;
} }

137
test/ext/ext_vector_relational.cpp
Unescape View File

@ -1,38 +1,149 @@
#include <glm/ext/vector_relational.hpp> #include <glm/ext/vector_relational.hpp>
#include <glm/vec2.hpp> #include <glm/ext/vector_float1.hpp>
#include <glm/ext/vector_float1_precision.hpp>
#include <glm/ext/vector_float2.hpp>
#include <glm/ext/vector_float2_precision.hpp>
#include <glm/ext/vector_float3.hpp>
#include <glm/ext/vector_float3_precision.hpp>
#include <glm/ext/vector_float4.hpp>
#include <glm/ext/vector_float4_precision.hpp>
#include <glm/ext/vector_double1.hpp>
#include <glm/ext/vector_double1_precision.hpp>
#include <glm/ext/vector_double2.hpp>
#include <glm/ext/vector_double2_precision.hpp>
#include <glm/ext/vector_double3.hpp>
#include <glm/ext/vector_double3_precision.hpp>
#include <glm/ext/vector_double4.hpp>
#include <glm/ext/vector_double4_precision.hpp>
int test_equal() template <typename vecType>
static int test_equal()
{ {
typedef typename vecType::value_type valType;
valType const A = static_cast<valType>(1.01f);
valType const B = static_cast<valType>(1.02f);
valType const Epsilon1(0.1f);
valType const Epsilon2(0.001f);
int Error = 0; int Error = 0;
Error += glm::all(glm::equal(glm::vec2(1.01f), glm::vec2(1.02f), 0.1f)) ? 0 : 1; Error += glm::all(glm::equal(vecType(A), vecType(B), Epsilon1)) ? 0 : 1;
Error += glm::all(glm::equal(glm::vec2(1.01f), glm::vec2(1.02f), glm::vec2(0.1f))) ? 0 : 1; Error += glm::all(glm::equal(vecType(A), vecType(B), vecType(Epsilon1))) ? 0 : 1;
Error += !glm::any(glm::equal(glm::vec2(1.01f), glm::vec2(1.02f), 0.001f)) ? 0 : 1; Error += !glm::any(glm::equal(vecType(A), vecType(B), Epsilon2)) ? 0 : 1;
Error += !glm::any(glm::equal(glm::vec2(1.01f), glm::vec2(1.02f), glm::vec2(0.001f))) ? 0 : 1; Error += !glm::any(glm::equal(vecType(A), vecType(B), vecType(Epsilon2))) ? 0 : 1;
return Error; return Error;
} }
int test_notEqual() template <typename vecType>
static int test_notEqual()
{ {
typedef typename vecType::value_type valType;
valType const A = static_cast<valType>(1.01f);
valType const B = static_cast<valType>(1.02f);
valType const Epsilon1(0.1f);
valType const Epsilon2(0.001f);
int Error = 0; int Error = 0;
Error += glm::all(glm::notEqual(glm::vec2(1.01f), glm::vec2(1.02f), 0.001f)) ? 0 : 1; Error += glm::all(glm::notEqual(vecType(1.01f), vecType(1.02f), Epsilon2)) ? 0 : 1;
Error += glm::all(glm::notEqual(glm::vec2(1.01f), glm::vec2(1.02f), glm::vec2(0.001f))) ? 0 : 1; Error += glm::all(glm::notEqual(vecType(1.01f), vecType(1.02f), vecType(Epsilon2))) ? 0 : 1;
Error += !glm::any(glm::notEqual(glm::vec2(1.01f), glm::vec2(1.02f), 0.1f)) ? 0 : 1; Error += !glm::any(glm::notEqual(vecType(1.01f), vecType(1.02f), Epsilon1)) ? 0 : 1;
Error += !glm::any(glm::notEqual(glm::vec2(1.01f), glm::vec2(1.02f), glm::vec2(0.1f))) ? 0 : 1; Error += !glm::any(glm::notEqual(vecType(1.01f), vecType(1.02f), vecType(Epsilon1))) ? 0 : 1;
return Error; return Error;
} }
template <typename genType, typename valType>
static int test_constexpr()
{
# if GLM_CONFIG_CONSTEXP == GLM_ENABLE
static_assert(glm::all(glm::equal(genType(static_cast<valType>(1.01f)), genType(static_cast<valType>(1.02f)), static_cast<valType>(0.1f))), "GLM: Failed constexpr");
# endif
return 0;
}
int main() int main()
{ {
int Error = 0; int Error = 0;
Error += test_equal(); Error += test_equal<glm::vec1>();
Error += test_notEqual(); Error += test_equal<glm::lowp_vec1>();
Error += test_equal<glm::mediump_vec1>();
Error += test_equal<glm::highp_vec1>();
Error += test_equal<glm::vec2>();
Error += test_equal<glm::lowp_vec2>();
Error += test_equal<glm::mediump_vec2>();
Error += test_equal<glm::highp_vec2>();
Error += test_equal<glm::vec3>();
Error += test_equal<glm::lowp_vec3>();
Error += test_equal<glm::mediump_vec3>();
Error += test_equal<glm::highp_vec3>();
Error += test_equal<glm::vec4>();
Error += test_equal<glm::lowp_vec4>();
Error += test_equal<glm::mediump_vec4>();
Error += test_equal<glm::highp_vec4>();
Error += test_equal<glm::dvec1>();
Error += test_equal<glm::lowp_dvec1>();
Error += test_equal<glm::mediump_dvec1>();
Error += test_equal<glm::highp_dvec1>();
Error += test_equal<glm::dvec2>();
Error += test_equal<glm::lowp_dvec2>();
Error += test_equal<glm::mediump_dvec2>();
Error += test_equal<glm::highp_dvec2>();
Error += test_equal<glm::dvec3>();
Error += test_equal<glm::lowp_dvec3>();
Error += test_equal<glm::mediump_dvec3>();
Error += test_equal<glm::highp_dvec3>();
Error += test_equal<glm::dvec4>();
Error += test_equal<glm::lowp_dvec4>();
Error += test_equal<glm::mediump_dvec4>();
Error += test_equal<glm::highp_dvec4>();
Error += test_notEqual<glm::vec1>();
Error += test_notEqual<glm::lowp_vec1>();
Error += test_notEqual<glm::mediump_vec1>();
Error += test_notEqual<glm::highp_vec1>();
Error += test_notEqual<glm::vec2>();
Error += test_notEqual<glm::lowp_vec2>();
Error += test_notEqual<glm::mediump_vec2>();
Error += test_notEqual<glm::highp_vec2>();
Error += test_notEqual<glm::vec3>();
Error += test_notEqual<glm::lowp_vec3>();
Error += test_notEqual<glm::mediump_vec3>();
Error += test_notEqual<glm::highp_vec3>();
Error += test_notEqual<glm::vec4>();
Error += test_notEqual<glm::lowp_vec4>();
Error += test_notEqual<glm::mediump_vec4>();
Error += test_notEqual<glm::highp_vec4>();
Error += test_notEqual<glm::dvec1>();
Error += test_notEqual<glm::lowp_dvec1>();
Error += test_notEqual<glm::mediump_dvec1>();
Error += test_notEqual<glm::highp_dvec1>();
Error += test_notEqual<glm::dvec2>();
Error += test_notEqual<glm::lowp_dvec2>();
Error += test_notEqual<glm::mediump_dvec2>();
Error += test_notEqual<glm::highp_dvec2>();
Error += test_notEqual<glm::dvec3>();
Error += test_notEqual<glm::lowp_dvec3>();
Error += test_notEqual<glm::mediump_dvec3>();
Error += test_notEqual<glm::highp_dvec3>();
Error += test_notEqual<glm::dvec4>();
Error += test_notEqual<glm::lowp_dvec4>();
Error += test_notEqual<glm::mediump_dvec4>();
Error += test_notEqual<glm::highp_dvec4>();
Error += test_constexpr<glm::vec1, float>();
Error += test_constexpr<glm::vec2, float>();
Error += test_constexpr<glm::vec3, float>();
Error += test_constexpr<glm::vec4, float>();
return Error; return Error;
} }

Write Preview
Loading…
Cancel
Save