BlackMATov/vmath.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/vmath.hpp.git synced 2025-12-16 14:11:28 +07:00
Code Issues Packages Projects Releases Wiki Activity

move common tests code

Browse Source
This commit is contained in:
BlackMATov
2020-11-25 18:33:11 +07:00
parent 545bbf6c3e
commit 2b9a6d4951
7 changed files with 128 additions and 214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
untests/vmath_fun_tests.cpp
View File

@@ -9,26 +9,15 @@
#define CATCH_CONFIG_FAST_COMPILE #define CATCH_CONFIG_FAST_COMPILE
#include <catch2/catch.hpp> #include <catch2/catch.hpp>
#include "vmath_tests.hpp"
namespace namespace
{ {
template < typename T > using namespace vmath_hpp;
class approx { using namespace vmath_tests;
public:
explicit constexpr approx(T v) : value_(v) {}
friend constexpr bool operator==(const T& l, const approx& r) {
return (r.value_ < l + epsilon)
&& (l < r.value_ + epsilon);
}
private:
T value_;
static constexpr T epsilon = std::numeric_limits<T>::epsilon() * 100;
};
} }
TEST_CASE("vmath/fun") { TEST_CASE("vmath/fun") {
using namespace vmath_hpp;
SECTION("Angle and Trigonometry Functions") { SECTION("Angle and Trigonometry Functions") {
STATIC_REQUIRE(radians(degrees(12.13f)) == approx(12.13f)); STATIC_REQUIRE(radians(degrees(12.13f)) == approx(12.13f));
STATIC_REQUIRE(degrees(radians(12.13f)) == approx(12.13f)); STATIC_REQUIRE(degrees(radians(12.13f)) == approx(12.13f));

60
untests/vmath_mat_ext_tests.cpp
View File

@@ -9,66 +9,12 @@
#define CATCH_CONFIG_FAST_COMPILE #define CATCH_CONFIG_FAST_COMPILE
#include <catch2/catch.hpp> #include <catch2/catch.hpp>
#include "vmath_tests.hpp"
namespace namespace
{ {
using namespace vmath_hpp; using namespace vmath_hpp;
using namespace vmath_tests;
template < typename T >
class approx2 {
public:
constexpr explicit approx2(T v) : value_(v) {}
constexpr explicit approx2(T x, T y) : value_(x, y) {}
friend constexpr bool operator==(const vec<T, 2>& l, const approx2& r) {
return (r.value_.x < l.x + epsilon)
&& (l.x < r.value_.x + epsilon)
&& (r.value_.y < l.y + epsilon)
&& (l.y < r.value_.y + epsilon);
}
private:
vec<T, 2> value_;
static constexpr T epsilon = std::numeric_limits<T>::epsilon() * 100;
};
template < typename T >
class approx3 {
public:
constexpr explicit approx3(T v) : value_(v) {}
constexpr explicit approx3(T x, T y, T z) : value_(x, y, z) {}
friend constexpr bool operator==(const vec<T, 3>& l, const approx3& r) {
return (r.value_.x < l.x + epsilon)
&& (l.x < r.value_.x + epsilon)
&& (r.value_.y < l.y + epsilon)
&& (l.y < r.value_.y + epsilon)
&& (r.value_.z < l.z + epsilon)
&& (l.z < r.value_.z + epsilon);
}
private:
vec<T, 3> value_;
static constexpr T epsilon = std::numeric_limits<T>::epsilon() * 100;
};
template < typename T >
class approx4 {
public:
constexpr explicit approx4(T v) : value_(v) {}
constexpr explicit approx4(T x, T y, T z, T w) : value_(x, y, z, w) {}
friend constexpr bool operator==(const vec<T, 4>& l, const approx4& r) {
return (r.value_.x < l.x + epsilon)
&& (l.x < r.value_.x + epsilon)
&& (r.value_.y < l.y + epsilon)
&& (l.y < r.value_.y + epsilon)
&& (r.value_.z < l.z + epsilon)
&& (l.z < r.value_.z + epsilon)
&& (r.value_.w < l.w + epsilon)
&& (l.w < r.value_.w + epsilon);
}
private:
vec<T, 4> value_;
static constexpr T epsilon = std::numeric_limits<T>::epsilon() * 100;
};
} }
TEST_CASE("vmath/mat_ext") { TEST_CASE("vmath/mat_ext") {

105
untests/vmath_mat_fun_tests.cpp
View File

@@ -10,9 +10,12 @@
#define CATCH_CONFIG_FAST_COMPILE #define CATCH_CONFIG_FAST_COMPILE
#include <catch2/catch.hpp> #include <catch2/catch.hpp>
#include "vmath_tests.hpp"
namespace namespace
{ {
using namespace vmath_hpp; using namespace vmath_hpp;
using namespace vmath_tests;
template < typename T, int Size > template < typename T, int Size >
constexpr mat<T, Size> generate_frank_matrix() { constexpr mat<T, Size> generate_frank_matrix() {
@@ -30,108 +33,6 @@ namespace
} }
return m; return m;
} }
template < typename T >
class approx2 {
public:
constexpr explicit approx2(T v) : value_(v) {}
constexpr explicit approx2(const vec<T, 2>& v) : value_(v) {}
constexpr explicit approx2(T x, T y) : value_(x, y) {}
friend constexpr bool operator==(const vec<T, 2>& l, const approx2& r) {
return (r.value_.x < l.x + epsilon)
&& (l.x < r.value_.x + epsilon)
&& (r.value_.y < l.y + epsilon)
&& (l.y < r.value_.y + epsilon);
}
private:
vec<T, 2> value_;
static constexpr T epsilon = std::numeric_limits<T>::epsilon() * 100;
};
template < typename T >
class approx3 {
public:
constexpr explicit approx3(T v) : value_(v) {}
constexpr explicit approx3(const vec<T, 3>& v) : value_(v) {}
constexpr explicit approx3(T x, T y, T z) : value_(x, y, z) {}
friend constexpr bool operator==(const vec<T, 3>& l, const approx3& r) {
return (r.value_.x < l.x + epsilon)
&& (l.x < r.value_.x + epsilon)
&& (r.value_.y < l.y + epsilon)
&& (l.y < r.value_.y + epsilon)
&& (r.value_.z < l.z + epsilon)
&& (l.z < r.value_.z + epsilon);
}
private:
vec<T, 3> value_;
static constexpr T epsilon = std::numeric_limits<T>::epsilon() * 100;
};
template < typename T >
class approx4 {
public:
constexpr explicit approx4(T v) : value_(v) {}
constexpr explicit approx4(const vec<T, 4>& v) : value_(v) {}
constexpr explicit approx4(T x, T y, T z, T w) : value_(x, y, z, w) {}
friend constexpr bool operator==(const vec<T, 4>& l, const approx4& r) {
return (r.value_.x < l.x + epsilon)
&& (l.x < r.value_.x + epsilon)
&& (r.value_.y < l.y + epsilon)
&& (l.y < r.value_.y + epsilon)
&& (r.value_.z < l.z + epsilon)
&& (l.z < r.value_.z + epsilon)
&& (r.value_.w < l.w + epsilon)
&& (l.w < r.value_.w + epsilon);
}
private:
vec<T, 4> value_;
static constexpr T epsilon = std::numeric_limits<T>::epsilon() * 100;
};
template < typename T >
class approx2x2 {
public:
constexpr explicit approx2x2(const mat<T, 2>& v) : value_(v) {}
friend constexpr bool operator==(const mat<T, 2>& l, const approx2x2& r) {
return l[0] == approx2(r.value_[0])
&& l[1] == approx2(r.value_[1]);
}
private:
mat<T, 2> value_;
};
template < typename T >
class approx3x3 {
public:
constexpr explicit approx3x3(const mat<T, 3>& v) : value_(v) {}
friend constexpr bool operator==(const mat<T, 3>& l, const approx3x3& r) {
return l[0] == approx3(r.value_[0])
&& l[1] == approx3(r.value_[1])
&& l[2] == approx3(r.value_[2]);
}
private:
mat<T, 3> value_;
};
template < typename T >
class approx4x4 {
public:
constexpr explicit approx4x4(const mat<T, 4>& v) : value_(v) {}
friend constexpr bool operator==(const mat<T, 4>& l, const approx4x4& r) {
return l[0] == approx4(r.value_[0])
&& l[1] == approx4(r.value_[1])
&& l[2] == approx4(r.value_[2])
&& l[3] == approx4(r.value_[3]);
}
private:
mat<T, 4> value_;
};
} }
TEST_CASE("vmath/mat_fun") { TEST_CASE("vmath/mat_fun") {

6
untests/vmath_mat_tests.cpp
View File

@@ -10,13 +10,15 @@
#define CATCH_CONFIG_FAST_COMPILE #define CATCH_CONFIG_FAST_COMPILE
#include <catch2/catch.hpp> #include <catch2/catch.hpp>
#include "vmath_tests.hpp"
namespace namespace
{ {
using namespace vmath_hpp;
using namespace vmath_tests;
} }
TEST_CASE("vmath/mat") { TEST_CASE("vmath/mat") {
using namespace vmath_hpp;
SECTION("size/sizeof") { SECTION("size/sizeof") {
STATIC_REQUIRE(mat2i{}.size == 2); STATIC_REQUIRE(mat2i{}.size == 2);
STATIC_REQUIRE(mat3i{}.size == 3); STATIC_REQUIRE(mat3i{}.size == 3);

107
untests/vmath_tests.hpp Normal file
View File

@@ -0,0 +1,107 @@
/*******************************************************************************
* This file is part of the "https://github.com/blackmatov/vmath.hpp"
* For conditions of distribution and use, see copyright notice in LICENSE.md
* Copyright (C) 2020, by Matvey Cherevko (blackmatov@gmail.com)
******************************************************************************/
#include <vmath.hpp/vmath_vec.hpp>
#include <vmath.hpp/vmath_vec_fun.hpp>
#include <limits>
namespace vmath_tests
{
using namespace vmath_hpp;
template < typename T >
inline constexpr T epsilon = std::numeric_limits<T>::epsilon() * 100;
template < typename T >
struct approx {
T value;
explicit constexpr approx(T v) : value(v) {}
friend constexpr bool operator==(const T& l, const approx& r) {
return (r.value < l + epsilon<T>)
&& (l < r.value + epsilon<T>);
}
};
template < typename T >
struct approx2 {
vec<T, 2> value;
constexpr explicit approx2(T v) : value(v) {}
constexpr explicit approx2(T x, T y) : value(x, y) {}
constexpr explicit approx2(const vec<T, 2>& v) : value(v) {}
friend constexpr bool operator==(const vec<T, 2>& l, const approx2& r) {
return l[0] == approx(r.value[0])
&& l[1] == approx(r.value[1]);
}
};
template < typename T >
struct approx3 {
vec<T, 3> value;
constexpr explicit approx3(T v) : value(v) {}
constexpr explicit approx3(T x, T y, T z) : value(x, y, z) {}
constexpr explicit approx3(const vec<T, 3>& v) : value(v) {}
friend constexpr bool operator==(const vec<T, 3>& l, const approx3& r) {
return l[0] == approx(r.value[0])
&& l[1] == approx(r.value[1])
&& l[2] == approx(r.value[2]);
}
};
template < typename T >
struct approx4 {
vec<T, 4> value;
constexpr explicit approx4(T v) : value(v) {}
constexpr explicit approx4(T x, T y, T z, T w) : value(x, y, z, w) {}
constexpr explicit approx4(const vec<T, 4>& v) : value(v) {}
friend constexpr bool operator==(const vec<T, 4>& l, const approx4& r) {
return l[0] == approx(r.value[0])
&& l[1] == approx(r.value[1])
&& l[2] == approx(r.value[2])
&& l[3] == approx(r.value[3]);
}
};
template < typename T >
struct approx2x2 {
mat<T, 2> value;
constexpr explicit approx2x2(const mat<T, 2>& v) : value(v) {}
friend constexpr bool operator==(const mat<T, 2>& l, const approx2x2& r) {
return l[0] == approx2(r.value[0])
&& l[1] == approx2(r.value[1]);
}
};
template < typename T >
struct approx3x3 {
mat<T, 3> value;
constexpr explicit approx3x3(const mat<T, 3>& v) : value(v) {}
friend constexpr bool operator==(const mat<T, 3>& l, const approx3x3& r) {
return l[0] == approx3(r.value[0])
&& l[1] == approx3(r.value[1])
&& l[2] == approx3(r.value[2]);
}
};
template < typename T >
struct approx4x4 {
mat<T, 4> value;
constexpr explicit approx4x4(const mat<T, 4>& v) : value(v) {}
friend constexpr bool operator==(const mat<T, 4>& l, const approx4x4& r) {
return l[0] == approx4(r.value[0])
&& l[1] == approx4(r.value[1])
&& l[2] == approx4(r.value[2])
&& l[3] == approx4(r.value[3]);
}
};
}

39
untests/vmath_vec_fun_tests.cpp
View File

@@ -9,45 +9,12 @@
#define CATCH_CONFIG_FAST_COMPILE #define CATCH_CONFIG_FAST_COMPILE
#include <catch2/catch.hpp> #include <catch2/catch.hpp>
#include "vmath_tests.hpp"
namespace namespace
{ {
using namespace vmath_hpp; using namespace vmath_hpp;
using namespace vmath_tests;
template < typename T >
class approx2 {
public:
constexpr explicit approx2(T v) : value_(v) {}
constexpr explicit approx2(T x, T y) : value_(x, y) {}
friend constexpr bool operator==(const vec<T, 2>& l, const approx2& r) {
return (r.value_.x < l.x + epsilon)
&& (l.x < r.value_.x + epsilon)
&& (r.value_.y < l.y + epsilon)
&& (l.y < r.value_.y + epsilon);
}
private:
vec<T, 2> value_;
static constexpr T epsilon = std::numeric_limits<T>::epsilon() * 100;
};
template < typename T >
class approx3 {
public:
constexpr explicit approx3(T v) : value_(v) {}
constexpr explicit approx3(T x, T y, T z) : value_(x, y, z) {}
friend constexpr bool operator==(const vec<T, 3>& l, const approx3& r) {
return (r.value_.x < l.x + epsilon)
&& (l.x < r.value_.x + epsilon)
&& (r.value_.y < l.y + epsilon)
&& (l.y < r.value_.y + epsilon)
&& (r.value_.z < l.z + epsilon)
&& (l.z < r.value_.z + epsilon);
}
private:
vec<T, 3> value_;
static constexpr T epsilon = std::numeric_limits<T>::epsilon() * 100;
};
} }
TEST_CASE("vmath/vec_fun") { TEST_CASE("vmath/vec_fun") {

6
untests/vmath_vec_tests.cpp
View File

@@ -10,13 +10,15 @@
#define CATCH_CONFIG_FAST_COMPILE #define CATCH_CONFIG_FAST_COMPILE
#include <catch2/catch.hpp> #include <catch2/catch.hpp>
#include "vmath_tests.hpp"
namespace namespace
{ {
using namespace vmath_hpp;
using namespace vmath_tests;
} }
TEST_CASE("vmath/vec") { TEST_CASE("vmath/vec") {
using namespace vmath_hpp;
SECTION("size/sizeof") { SECTION("size/sizeof") {
STATIC_REQUIRE(vec2i{}.size == 2); STATIC_REQUIRE(vec2i{}.size == 2);
STATIC_REQUIRE(vec3i{}.size == 3); STATIC_REQUIRE(vec3i{}.size == 3);