fennec-org/fennec
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Adjusted Formatting of tests

Browse Source 
- Finished map implementation and unit tests

 TODO: Threading
This commit is contained in:
Medusa Slockbower
2025-07-23 12:05:02 -04:00
parent 73333b4c67
commit 5ab2952e83
63 changed files with 2703 additions and 2187 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
test/CMakeLists.txt
View File

@@ -33,6 +33,7 @@ add_executable(fennec-test main.cpp
tests/lang/test_hashing.h
tests/containers/test_array.h
tests/containers/test_set.h
tests/containers/test_map.h
)
target_compile_definitions(fennec-test PUBLIC FENNEC_TEST_CWD="${CMAKE_SOURCE_DIR}/bin/${FENNEC_BUILD_NAME}"

27
test/tests/containers/test_array.h
View File

@@ -23,26 +23,21 @@
#include <fennec/containers/array.h>
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_containers_array() {
inline void fennec_test_containers_array() {
const char string[] = "Hello World!";
array<char, sizeof(string)> arr1;
array<char, sizeof(string)> arr2;
strcpy(&arr1[0], string);
strcpy(&arr2[0], string);
const char string[] = "Hello World!";
array<char, sizeof(string)> arr1;
array<char, sizeof(string)> arr2;
strcpy(&arr1[0], string);
strcpy(&arr2[0], string);
fennec_test_run(strcmp(&arr1[0], string), 0);
fennec_test_run(strcmp(&arr2[0], string), 0);
fennec_test_run(arr1 == arr2, true);
}
}
fennec_test_run(strcmp(&arr1[0], string), 0);
fennec_test_run(strcmp(&arr2[0], string), 0);
fennec_test_run(arr1 == arr2, true);
}
}

35
test/tests/containers/test_dynarray.h
View File

@@ -23,33 +23,28 @@
#include <fennec/containers/dynarray.h>
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_containers_dynarray() {
inline void fennec_test_containers_dynarray() {
dynarray<int> test1;
dynarray<int> test2;
dynarray<int> test1;
dynarray<int> test2;
int n = 10000;
test1.resize(n); test2.resize(n);
for (int i = 0; i < n; ++i) {
test1.push_back(i);
test2.push_back(n - i - 1);
}
int n = 10000;
test1.resize(n); test2.resize(n);
for (int i = 0; i < n; ++i) {
test1.push_back(i);
test2.push_back(n - i - 1);
for (int i = 0; i < n; ++i) {
assertf(test1[i] == test2[n - i - 1], "Failed dynarray::push_back");
}
std::cout << "passed" << std::endl;
}
for (int i = 0; i < n; ++i) {
assertf(test1[i] == test2[n - i - 1], "Failed dynarray::push_back");
}
std::cout << "passed" << std::endl;
}
}
}
#endif // FENNEC_TEST_CONTAINERS_DYNARRAY_H

41
test/tests/containers/test_map.h Normal file
View File

@@ -0,0 +1,41 @@
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright © 2025 Medusa Slockbower
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
#ifndef FENNEC_TEST_CONTAINERS_MAP_H
#define FENNEC_TEST_CONTAINERS_MAP_H
#include <fennec/containers/map.h>
#include <fennec/fproc/strings/string.h>
namespace fennec::test {
inline void fennec_test_containers_map() {
map<string, string> map;
map.emplace("Hello", "World");
fennec_test_run(*map["Hello"], string("World"));
map.erase("Hello");
fennec_test_run(map["Hello"], static_cast<string*>(nullptr));
}
}
#endif // FENNEC_TEST_CONTAINERS_MAP_H

189
test/tests/containers/test_optional.h
View File

@@ -23,102 +23,115 @@
#include <fennec/containers/optional.h>
namespace fennec
namespace fennec::test
{
namespace test
{
enum opt_test_ : uint8_t {
opt_test_none = 0x1 << 0,
opt_test_default_constructor = 0x1 << 1,
opt_test_destructor = 0x1 << 2,
opt_test_copy_constructor = 0x1 << 3,
opt_test_move_constructor = 0x1 << 4,
opt_test_copy_assignment = 0x1 << 5,
opt_test_move_assignment = 0x1 << 6,
};
enum opt_test_ : uint8_t {
opt_test_none = 0x1 << 0,
opt_test_default_constructor = 0x1 << 1,
opt_test_destructor = 0x1 << 2,
opt_test_copy_constructor = 0x1 << 3,
opt_test_move_constructor = 0x1 << 4,
opt_test_copy_assignment = 0x1 << 5,
opt_test_move_assignment = 0x1 << 6,
};
struct optional_helper {
struct optional_helper {
inline static uint8_t test = opt_test_none;
inline static uint8_t test = opt_test_none;
optional_helper() : i(0) {
fennec_test_run(bool(test & opt_test_default_constructor), true);
}
optional_helper() : i(0) {
fennec_test_run(bool(test & opt_test_default_constructor), true);
~optional_helper() {
fennec_test_run(bool(test & opt_test_destructor), true);
}
optional_helper(const optional_helper&) : i(0) {
fennec_test_run(bool(test & opt_test_copy_constructor), true);
}
optional_helper(optional_helper&&) noexcept : i(0) {
fennec_test_run(bool(test & opt_test_move_constructor), true);
}
optional_helper& operator=(const optional_helper&) {
fennec_test_run(bool(test & opt_test_copy_assignment), true);
return *this;
}
optional_helper& operator=(optional_helper&&) noexcept {
fennec_test_run(bool(test & opt_test_move_assignment), true);
return *this;
}
int i;
};
inline void fennec_test_containers_optional() {
static_assert(
is_default_constructible_v<optional_helper>
and is_copy_constructible_v<optional_helper>
and is_move_constructible_v<optional_helper>
and is_copy_assignable_v<optional_helper>
and is_move_assignable_v<optional_helper>
);
optional<optional_helper> opt = optional<optional_helper>();
optional_helper::test = opt_test_default_constructor;
opt.emplace();
fennec_test_spacer(1);
optional_helper::test = opt_test_destructor;
opt.reset();
fennec_test_spacer(1);
optional_helper::test = opt_test_default_constructor | opt_test_copy_constructor | opt_test_destructor;
opt = copy(optional_helper());
fennec_test_spacer(1);
optional_helper::test = opt_test_destructor;
opt.reset();
fennec_test_spacer(1);
optional_helper::test = opt_test_default_constructor | opt_test_move_constructor | opt_test_destructor;
opt = optional_helper();
fennec_test_spacer(1);
optional_helper::test = opt_test_destructor;
opt.reset();
fennec_test_spacer(1);
optional_helper::test = opt_test_default_constructor;
opt.emplace();
fennec_test_spacer(1);
optional_helper::test = opt_test_default_constructor | opt_test_copy_assignment | opt_test_destructor;
opt = copy(optional_helper());
fennec_test_spacer(1);
optional_helper::test = opt_test_default_constructor | opt_test_move_assignment | opt_test_destructor;
opt = optional_helper();
fennec_test_spacer(1);
optional_helper::test = opt_test_destructor;
opt.reset();
std::cout << opt << std::endl;
std::cout << "passed" << std::endl;
}
~optional_helper() {
fennec_test_run(bool(test & opt_test_destructor), true);
}
optional_helper(const optional_helper&) : i(0) {
fennec_test_run(bool(test & opt_test_copy_constructor), true);
}
optional_helper(optional_helper&&) noexcept : i(0) {
fennec_test_run(bool(test & opt_test_move_constructor), true);
}
optional_helper& operator=(const optional_helper&) {
fennec_test_run(bool(test & opt_test_copy_assignment), true);
return *this;
}
optional_helper& operator=(optional_helper&&) noexcept {
fennec_test_run(bool(test & opt_test_move_assignment), true);
return *this;
}
int i;
};
inline void fennec_test_containers_optional() {
static_assert(
is_default_constructible_v<optional_helper>
and is_copy_constructible_v<optional_helper>
and is_move_constructible_v<optional_helper>
and is_copy_assignable_v<optional_helper>
and is_move_assignable_v<optional_helper>
);
optional<optional_helper> opt = optional<optional_helper>();
optional_helper::test = opt_test_default_constructor;
opt.emplace();
optional_helper::test = opt_test_destructor;
opt.reset();
optional_helper::test = opt_test_default_constructor | opt_test_copy_constructor | opt_test_destructor;
opt = copy(optional_helper());
optional_helper::test = opt_test_destructor;
opt.reset();
optional_helper::test = opt_test_default_constructor | opt_test_move_constructor | opt_test_destructor;
opt = optional_helper();
optional_helper::test = opt_test_destructor;
opt.reset();
optional_helper::test = opt_test_default_constructor;
opt.emplace();
optional_helper::test = opt_test_default_constructor | opt_test_copy_assignment | opt_test_destructor;
opt = copy(optional_helper());
optional_helper::test = opt_test_default_constructor | opt_test_move_assignment | opt_test_destructor;
opt = optional_helper();
optional_helper::test = opt_test_destructor;
opt.reset();
std::cout << opt << std::endl;
std::cout << "passed" << std::endl;
}
}
}
#endif // FENNEC_TEST_CONTAINERS_OPTIONAL_H

37
test/tests/containers/test_set.h
View File

@@ -25,34 +25,29 @@
#include <unordered_set>
#include <fennec/containers/set.h>
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_containers_set() {
inline void fennec_test_containers_set() {
using type_t = decltype(rand());
std::unordered_set<type_t> ref;
set<type_t> test;
using type_t = decltype(rand());
std::unordered_set<type_t> ref;
set<type_t> test;
srand(0);
for (int i = 0; i < 10000; ++i) {
type_t v = rand();
ref.insert(v);
test.insert(v);
}
srand(0);
for (int i = 0; i < 10000; ++i) {
type_t v = rand();
ref.insert(v);
test.insert(v);
for (int i = 0; i < 10000; ++i) {
assertf(ref.contains(i) == test.contains(i), "set test failed");
}
std::cout << "passed" << std::endl;
}
for (int i = 0; i < 10000; ++i) {
assertf(ref.contains(i) == test.contains(i), "set test failed");
}
std::cout << "passed" << std::endl;
}
}
}
#endif // FENNEC_TEST_CONTAINERS_SET_H

39
test/tests/fproc/strings/test_cstring.h
View File

@@ -21,35 +21,30 @@
#include <fennec/fproc/strings/cstring.h>
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_fproc_strings_cstring()
{
static char test_string[] = "Hello World!";
static const char test_string_const[] = "Hello World!";
inline void fennec_test_fproc_strings_cstring()
{
static char test_string[] = "Hello World!";
static const char test_string_const[] = "Hello World!";
cstring str = test_string;
const cstring cstr = test_string_const;
cstring str = test_string;
const cstring cstr = test_string_const;
fennec_test_run(str, cstr);
fennec_test_run(cstr, str);
fennec_test_run(str, cstr);
fennec_test_run(cstr, str);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(str.length(), static_cast<size_t>(12));
fennec_test_run(str.compare(cstr), 0);
fennec_test_run(str.find('W'), static_cast<size_t>(6));
fennec_test_run(str.find("World"), static_cast<size_t>(6));
fennec_test_run(str.rfind('o'), static_cast<size_t>(7));
fennec_test_run(str.rfind("World"), static_cast<size_t>(6));
fennec_test_run(str.length(), static_cast<size_t>(12));
fennec_test_run(str.compare(cstr), 0);
fennec_test_run(str.find('W'), static_cast<size_t>(6));
fennec_test_run(str.find("World"), static_cast<size_t>(6));
fennec_test_run(str.rfind('o'), static_cast<size_t>(7));
fennec_test_run(str.rfind("World"), static_cast<size_t>(6));
}
}
}
}

85
test/tests/fproc/test_io.h
View File

@@ -24,73 +24,68 @@
#include <fennec/fproc/filesystem/file.h>
#include <fennec/fproc/filesystem/path.h>
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_fproc_io() {
inline void fennec_test_fproc_io() {
fennec_test_section("utilities");
fennec_test_section("utilities");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(path::current(), path(FENNEC_TEST_CWD));
fennec_test_run(path("../" FENNEC_BUILD_NAME "/./test.sh").absolute(), path(FENNEC_TEST_CWD) / "test.sh");
fennec_test_run(path("./test/../test.sh").absolute(), path(FENNEC_TEST_CWD) / "test.sh");
fennec_test_run(path::current().parent(), path("../").absolute());
fennec_test_run(path::current(), path(FENNEC_TEST_CWD));
fennec_test_run(path("../" FENNEC_BUILD_NAME "/./test.sh").absolute(), path(FENNEC_TEST_CWD) / "test.sh");
fennec_test_run(path("./test/../test.sh").absolute(), path(FENNEC_TEST_CWD) / "test.sh");
fennec_test_run(path::current().parent(), path("../").absolute());
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("file streams");
fennec_test_section("file streams");
fennec_test_spacer(1);
fennec_test_spacer(1);
file stream;
char data[] = "Hello World!";
fennec_test_run(stream.open("./test.txt", fmode_write | fmode_trunc), false);
fennec_test_run(stream.write(data), sizeof(data));
fennec_test_run(stream.close(), false);
file stream;
char data[] = "Hello World!";
fennec_test_run(stream.open("./test.txt", fmode_write | fmode_trunc), false);
fennec_test_run(stream.write(data), sizeof(data));
fennec_test_run(stream.close(), false);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(stream.open("./test.txt", fmode_read), false);
fennec_test_run(stream.read(data), sizeof(data));
fennec_test_run(cstring(data), cstring("Hello World!"));
fennec_test_run(stream.open("./test.txt", fmode_read), false);
fennec_test_run(stream.read(data), sizeof(data));
fennec_test_run(cstring(data), cstring("Hello World!"));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(stream.open("./test.txt", fmode_read), false);
fennec_test_run((stream = stream.copy("./copy.txt")).is_open(), true);
fennec_test_run(stream.open("./copy.txt", fmode_read), false);
fennec_test_run(stream.read(data), sizeof(data));
fennec_test_run(cstring(data), cstring("Hello World!"));
fennec_test_run(stream.erase(), false);
fennec_test_run(stream.open("./test.txt", fmode_read), false);
fennec_test_run((stream = stream.copy("./copy.txt")).is_open(), true);
fennec_test_run(stream.open("./copy.txt", fmode_read), false);
fennec_test_run(stream.read(data), sizeof(data));
fennec_test_run(cstring(data), cstring("Hello World!"));
fennec_test_run(stream.erase(), false);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(stream.open("./test.txt", fmode_read), false);
fennec_test_run(stream.rename("./rename.txt"), false);
fennec_test_run(stream.open("./rename.txt", fmode_read), false);
fennec_test_run(stream.read(data), sizeof(data));
fennec_test_run(cstring(data), cstring("Hello World!"));
fennec_test_run(stream.erase(), false);
fennec_test_run(stream.open("./test.txt", fmode_read), false);
fennec_test_run(stream.rename("./rename.txt"), false);
fennec_test_run(stream.open("./rename.txt", fmode_read), false);
fennec_test_run(stream.read(data), sizeof(data));
fennec_test_run(cstring(data), cstring("Hello World!"));
fennec_test_run(stream.erase(), false);
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("std streams");
fennec_test_section("std streams");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(file::cout().write("Hello World!"), sizeof("Hello World!"));
fennec_test_run(file::cerr().write("Hello World!"), sizeof("Hello World!"));
fennec_test_run(file::cout().write("Hello World!"), sizeof("Hello World!"));
fennec_test_run(file::cerr().write("Hello World!"), sizeof("Hello World!"));
}
}
}
}

23
test/tests/fproc/test_strings.h
View File

@@ -22,23 +22,18 @@
#include "../../test.h"
#include "./strings/test_cstring.h"
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_fproc_strings()
{
fennec_test_subheader("cstring");
fennec_test_spacer(2);
fennec_test_fproc_strings_cstring();
fennec_test_spacer(3);
inline void fennec_test_fproc_strings()
{
fennec_test_subheader("cstring");
fennec_test_spacer(2);
fennec_test_fproc_strings_cstring();
fennec_test_spacer(3);
// TODO
}
}
// TODO
}
}

25
test/tests/lang/test_bits.h
View File

@@ -24,25 +24,20 @@
#include "../../test.h"
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_lang_bits()
{
int a = 0x48ef13ad;
int b = 0x23e5ab9c;
inline void fennec_test_lang_bits()
{
int a = 0x48ef13ad;
int b = 0x23e5ab9c;
fennec_test_run(fennec::bit_cast<float>(0x3ee00000), 0.4375f);
fennec_test_run(fennec::bit_cast<float>(0x3ee00000), 0.4375f);
fennec_test_run(*static_cast<int*>(fennec::bit_and(&a, &b, sizeof(int))), 0x48ef13ad & 0x23e5ab9c);
fennec_test_run(*static_cast<int*>(fennec::bit_or(&a, &b, sizeof(int))), (0x48ef13ad & 0x23e5ab9c) | 0x23e5ab9c);
fennec_test_run(*static_cast<int*>(fennec::bit_xor(&a, &b, sizeof(int))), ((0x48ef13ad & 0x23e5ab9c) | 0x23e5ab9c) ^ 0x23e5ab9c);
}
}
fennec_test_run(*static_cast<int*>(fennec::bit_and(&a, &b, sizeof(int))), 0x48ef13ad & 0x23e5ab9c);
fennec_test_run(*static_cast<int*>(fennec::bit_or(&a, &b, sizeof(int))), (0x48ef13ad & 0x23e5ab9c) | 0x23e5ab9c);
fennec_test_run(*static_cast<int*>(fennec::bit_xor(&a, &b, sizeof(int))), ((0x48ef13ad & 0x23e5ab9c) | 0x23e5ab9c) ^ 0x23e5ab9c);
}
}

13
test/tests/lang/test_conditional_types.h
View File

@@ -19,18 +19,13 @@
#ifndef FENNEC_TEST_LANG_CONDITIONAL_TYPES_H
#define FENNEC_TEST_LANG_CONDITIONAL_TYPES_H
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_lang_conditional_types()
{
inline void fennec_test_lang_conditional_types()
{
}
}
}
}

41
test/tests/lang/test_hashing.h
View File

@@ -22,35 +22,30 @@
#include <fennec/lang/hashing.h>
#include "../../test.h"
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_lang_hashing() {
inline void fennec_test_lang_hashing() {
size_t num = 61;
float_t numf = bit_cast<float>((uint32_t)num);
double_t numd = bit_cast<double>(num);
size_t exp = hash<size_t>()(num);
size_t num = 61;
float_t numf = bit_cast<float>((uint32_t)num);
double_t numd = bit_cast<double>(num);
size_t exp = hash<size_t>()(num);
fennec_test_run(hash<int8_t>()(num), exp);
fennec_test_run(hash<uint8_t>()(num), exp);
fennec_test_run(hash<int16_t>()(num), exp);
fennec_test_run(hash<uint16_t>()(num), exp);
fennec_test_run(hash<int32_t>()(num), exp);
fennec_test_run(hash<uint32_t>()(num), exp);
fennec_test_run(hash<int64_t>()(num), exp);
fennec_test_run(hash<uint64_t>()(num), exp);
fennec_test_run(hash<int8_t>()(num), exp);
fennec_test_run(hash<uint8_t>()(num), exp);
fennec_test_run(hash<int16_t>()(num), exp);
fennec_test_run(hash<uint16_t>()(num), exp);
fennec_test_run(hash<int32_t>()(num), exp);
fennec_test_run(hash<uint32_t>()(num), exp);
fennec_test_run(hash<int64_t>()(num), exp);
fennec_test_run(hash<uint64_t>()(num), exp);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(hash<float_t>()(numf), exp);
fennec_test_run(hash<double_t>()(numd), exp);
}
}
fennec_test_run(hash<float_t>()(numf), exp);
fennec_test_run(hash<double_t>()(numd), exp);
}
}

21
test/tests/lang/test_sequences.h
View File

@@ -21,22 +21,17 @@
#include <fennec/lang/sequences.h>
namespace fennec
namespace fennec::test
{
namespace test
{
inline void test_sequences()
{
static_assert(fennec::is_same_v<make_index_sequence_t<2>, index_sequence<0, 1>>);
static_assert(fennec::is_same_v<make_index_sequence_t<3>, index_sequence<0, 1, 2>>);
static_assert(fennec::is_same_v<make_index_sequence_t<4>, index_sequence<0, 1, 2, 3>>);
inline void test_sequences()
{
static_assert(fennec::is_same_v<make_index_sequence_t<2>, index_sequence<0, 1>>);
static_assert(fennec::is_same_v<make_index_sequence_t<3>, index_sequence<0, 1, 2>>);
static_assert(fennec::is_same_v<make_index_sequence_t<4>, index_sequence<0, 1, 2, 3>>);
// TODO
}
}
// TODO
}
}

21
test/tests/math/ext/test_quaternion.h
View File

@@ -23,26 +23,21 @@
#include "../../../test.h"
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_math_quaternion() {
inline void fennec_test_math_quaternion() {
fennec_test_section("constructors");
fennec_test_section("constructors");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(quat(), quat(1, 0, 0, 0));
fennec_test_run(quat(), quat(1, 0, 0, 0));
fennec_test_spacer(2);
fennec_test_spacer(2);
// TODO
}
}
// TODO
}
}

239
test/tests/math/test_common.h
View File

@@ -21,196 +21,191 @@
#include "../../test.h"
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_math_common()
{
fennec_test_section("Sign Functions");
inline void fennec_test_math_common()
{
fennec_test_section("Sign Functions");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::abs( 1), 1);
fennec_test_run(fennec::abs(-1), 1);
fennec_test_run(fennec::abs( 1.0f), 1.0f);
fennec_test_run(fennec::abs(-1.0f), 1.0f);
fennec_test_run(fennec::abs( 1.0), 1.0);
fennec_test_run(fennec::abs(-1.0), 1.0);
fennec_test_run(fennec::abs( 1), 1);
fennec_test_run(fennec::abs(-1), 1);
fennec_test_run(fennec::abs( 1.0f), 1.0f);
fennec_test_run(fennec::abs(-1.0f), 1.0f);
fennec_test_run(fennec::abs( 1.0), 1.0);
fennec_test_run(fennec::abs(-1.0), 1.0);
fennec_test_run(fennec::abs(vec2(1.0f, -1.0f)), vec2(1.0f));
fennec_test_run(fennec::abs(vec2(1.0f, -1.0f)), vec2(1.0f));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::sign(vec2( 1, -2)), vec2( 1, -1));
fennec_test_run(fennec::sign(vec3(-1, 2, -3)), vec3(-1, 1, -1));
fennec_test_run(fennec::sign(vec4( 1, -2, 3, -4)), vec4( 1, -1, 1, -1));
fennec_test_run(fennec::sign(vec2( 1, -2)), vec2( 1, -1));
fennec_test_run(fennec::sign(vec3(-1, 2, -3)), vec3(-1, 1, -1));
fennec_test_run(fennec::sign(vec4( 1, -2, 3, -4)), vec4( 1, -1, 1, -1));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("Rounding Functions");
fennec_test_section("Rounding Functions");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::ceil(2.4f), 3.0f);
fennec_test_run(fennec::ceil(2.5f), 3.0f);
fennec_test_run(fennec::ceil(2.6f), 3.0f);
fennec_test_run(fennec::ceil(2.4f), 3.0f);
fennec_test_run(fennec::ceil(2.5f), 3.0f);
fennec_test_run(fennec::ceil(2.6f), 3.0f);
fennec_test_run(fennec::ceil(-2.4f), -2.0f);
fennec_test_run(fennec::ceil(-2.5f), -2.0f);
fennec_test_run(fennec::ceil(-2.6f), -2.0f);
fennec_test_run(fennec::ceil(-2.4f), -2.0f);
fennec_test_run(fennec::ceil(-2.5f), -2.0f);
fennec_test_run(fennec::ceil(-2.6f), -2.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::floor(2.4f), 2.0f);
fennec_test_run(fennec::floor(2.5f), 2.0f);
fennec_test_run(fennec::floor(2.6f), 2.0f);
fennec_test_run(fennec::floor(2.4f), 2.0f);
fennec_test_run(fennec::floor(2.5f), 2.0f);
fennec_test_run(fennec::floor(2.6f), 2.0f);
fennec_test_run(fennec::floor(-2.4f), -3.0f);
fennec_test_run(fennec::floor(-2.5f), -3.0f);
fennec_test_run(fennec::floor(-2.6f), -3.0f);
fennec_test_run(fennec::floor(-2.4f), -3.0f);
fennec_test_run(fennec::floor(-2.5f), -3.0f);
fennec_test_run(fennec::floor(-2.6f), -3.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::round(2.4f), 2.0f);
fennec_test_run(fennec::round(2.5f), 3.0f);
fennec_test_run(fennec::round(2.6f), 3.0f);
fennec_test_run(fennec::round(2.4f), 2.0f);
fennec_test_run(fennec::round(2.5f), 3.0f);
fennec_test_run(fennec::round(2.6f), 3.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::roundEven(2.4f), 2.0f);
fennec_test_run(fennec::roundEven(2.5f), 2.0f);
fennec_test_run(fennec::roundEven(2.6f), 3.0f);
fennec_test_run(fennec::roundEven(2.4f), 2.0f);
fennec_test_run(fennec::roundEven(2.5f), 2.0f);
fennec_test_run(fennec::roundEven(2.6f), 3.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::trunc(2.4f), 2.0f);
fennec_test_run(fennec::trunc(2.5f), 2.0f);
fennec_test_run(fennec::trunc(2.6f), 2.0f);
fennec_test_run(fennec::trunc(2.4f), 2.0f);
fennec_test_run(fennec::trunc(2.5f), 2.0f);
fennec_test_run(fennec::trunc(2.6f), 2.0f);
fennec_test_run(fennec::trunc(-2.4f), -2.0f);
fennec_test_run(fennec::trunc(-2.5f), -2.0f);
fennec_test_run(fennec::trunc(-2.6f), -2.0f);
fennec_test_run(fennec::trunc(-2.4f), -2.0f);
fennec_test_run(fennec::trunc(-2.5f), -2.0f);
fennec_test_run(fennec::trunc(-2.6f), -2.0f);
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("Floating Point Functions");
fennec_test_section("Floating Point Functions");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::fract(2.4f), 0.4f);
fennec_test_run(fennec::fract(2.5f), 0.5f);
fennec_test_run(fennec::fract(2.6f), 0.6f);
fennec_test_run(fennec::fract(2.4f), 0.4f);
fennec_test_run(fennec::fract(2.5f), 0.5f);
fennec_test_run(fennec::fract(2.6f), 0.6f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::mod(2.4f, 2.0f), 0.4f);
fennec_test_run(fennec::mod(2.5f, 2.0f), 0.5f);
fennec_test_run(fennec::mod(2.6f, 2.0f), 0.6f);
fennec_test_run(fennec::mod(2.4f, 2.0f), 0.4f);
fennec_test_run(fennec::mod(2.5f, 2.0f), 0.5f);
fennec_test_run(fennec::mod(2.6f, 2.0f), 0.6f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run([]() -> float { float i; return fennec::modf(2.4f, i) + i; }(), 2.4f);
fennec_test_run([]() -> float { float i; return fennec::modf(2.5f, i) + i; }(), 2.5f);
fennec_test_run([]() -> float { float i; return fennec::modf(2.6f, i) + i; }(), 2.6f);
fennec_test_run([]() -> float { float i; return fennec::modf(2.4f, i) + i; }(), 2.4f);
fennec_test_run([]() -> float { float i; return fennec::modf(2.5f, i) + i; }(), 2.5f);
fennec_test_run([]() -> float { float i; return fennec::modf(2.6f, i) + i; }(), 2.6f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::isnan(0.0f), false);
fennec_test_run(fennec::isnan(fennec::numeric_limits<float>::quiet_NaN()), true);
fennec_test_run(fennec::isnan(fennec::numeric_limits<float>::signaling_NaN()), true);
fennec_test_run(fennec::isnan(0.0f), false);
fennec_test_run(fennec::isnan(fennec::numeric_limits<float>::quiet_NaN()), true);
fennec_test_run(fennec::isnan(fennec::numeric_limits<float>::signaling_NaN()), true);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::isinf( 0.0f), false);
fennec_test_run(fennec::isinf( fennec::numeric_limits<float>::infinity()), true);
fennec_test_run(fennec::isinf(-fennec::numeric_limits<float>::infinity()), true);
fennec_test_run(fennec::isinf( 0.0f), false);
fennec_test_run(fennec::isinf( fennec::numeric_limits<float>::infinity()), true);
fennec_test_run(fennec::isinf(-fennec::numeric_limits<float>::infinity()), true);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::floatBitsToInt( 1.0f), static_cast<int>(0x3f800000u));
fennec_test_run(fennec::floatBitsToInt(-1.0f), static_cast<int>(0xbf800000u));
fennec_test_run(fennec::floatBitsToUint( 1.0f), 0x3f800000u);
fennec_test_run(fennec::floatBitsToUint(-1.0f), 0xbf800000u);
fennec_test_run(fennec::floatBitsToInt( 1.0f), static_cast<int>(0x3f800000u));
fennec_test_run(fennec::floatBitsToInt(-1.0f), static_cast<int>(0xbf800000u));
fennec_test_run(fennec::floatBitsToUint( 1.0f), 0x3f800000u);
fennec_test_run(fennec::floatBitsToUint(-1.0f), 0xbf800000u);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::intBitsToFloat(static_cast<int>(0x3f800000u)), 1.0f);
fennec_test_run(fennec::intBitsToFloat(static_cast<int>(0xbf800000u)), -1.0f);
fennec_test_run(fennec::uintBitsToFloat(0x3f800000u), 1.0f);
fennec_test_run(fennec::uintBitsToFloat(0xbf800000u), -1.0f);
fennec_test_run(fennec::intBitsToFloat(static_cast<int>(0x3f800000u)), 1.0f);
fennec_test_run(fennec::intBitsToFloat(static_cast<int>(0xbf800000u)), -1.0f);
fennec_test_run(fennec::uintBitsToFloat(0x3f800000u), 1.0f);
fennec_test_run(fennec::uintBitsToFloat(0xbf800000u), -1.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::fma( 1, 2, 3), 5);
fennec_test_run(fennec::fma(-1, 2, -3), -5);
fennec_test_run(fennec::fma( 1, -2, 3), 1);
fennec_test_run(fennec::fma( 1, 2, 3), 5);
fennec_test_run(fennec::fma(-1, 2, -3), -5);
fennec_test_run(fennec::fma( 1, -2, 3), 1);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run([]() -> float { int i; float f = fennec::frexp(2.4f, i); return fennec::ldexp(f, i); }(), 2.4f);
fennec_test_run([]() -> float { int i; float f = fennec::frexp(2.5f, i); return fennec::ldexp(f, i); }(), 2.5f);
fennec_test_run([]() -> float { int i; float f = fennec::frexp(2.6f, i); return fennec::ldexp(f, i); }(), 2.6f);
fennec_test_run([]() -> float { int i; float f = fennec::frexp(2.4f, i); return fennec::ldexp(f, i); }(), 2.4f);
fennec_test_run([]() -> float { int i; float f = fennec::frexp(2.5f, i); return fennec::ldexp(f, i); }(), 2.5f);
fennec_test_run([]() -> float { int i; float f = fennec::frexp(2.6f, i); return fennec::ldexp(f, i); }(), 2.6f);
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("Comparison Functions");
fennec_test_section("Comparison Functions");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(min(2.0f, 1.0f), 1.0f);
fennec_test_run(min(-fennec::numeric_limits<float>::infinity(), 0.0f), -fennec::numeric_limits<float>::infinity());
fennec_test_run(min(2.0f, 1.0f), 1.0f);
fennec_test_run(min(-fennec::numeric_limits<float>::infinity(), 0.0f), -fennec::numeric_limits<float>::infinity());
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(max(2.0f, 1.0f), 2.0f);
fennec_test_run(max(-fennec::numeric_limits<float>::infinity(), 0.0f), 0.0f);
fennec_test_run(max(2.0f, 1.0f), 2.0f);
fennec_test_run(max(-fennec::numeric_limits<float>::infinity(), 0.0f), 0.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(clamp(-0.5f, 0.0f, 1.0f), 0.0f);
fennec_test_run(clamp( 0.5f, 0.0f, 1.0f), 0.5f);
fennec_test_run(clamp( 1.5f, 0.0f, 1.0f), 1.0f);
fennec_test_run(clamp(-0.5f, 0.0f, 1.0f), 0.0f);
fennec_test_run(clamp( 0.5f, 0.0f, 1.0f), 0.5f);
fennec_test_run(clamp( 1.5f, 0.0f, 1.0f), 1.0f);
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("Curves");
fennec_test_section("Curves");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(step(2.5f, 2.4f), 0.0f);
fennec_test_run(step(2.5f, 2.5f), 1.0f);
fennec_test_run(step(2.5f, 2.6f), 1.0f);
fennec_test_run(step(2.5f, 2.4f), 0.0f);
fennec_test_run(step(2.5f, 2.5f), 1.0f);
fennec_test_run(step(2.5f, 2.6f), 1.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(smoothstep(0.0f, 1.0f, -0.5f), 0.0f);
fennec_test_run(smoothstep(0.0f, 1.0f, 0.5f), 0.5f);
fennec_test_run(smoothstep(0.0f, 1.0f, 1.5f), 1.0f);
fennec_test_run(smoothstep(0.0f, 1.0f, -0.5f), 0.0f);
fennec_test_run(smoothstep(0.0f, 1.0f, 0.5f), 0.5f);
fennec_test_run(smoothstep(0.0f, 1.0f, 1.5f), 1.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(mix(0.0f, 1.0f, -0.5f), -0.5f);
fennec_test_run(mix(0.0f, 1.0f, 0.5f), 0.5f);
fennec_test_run(mix(0.0f, 1.0f, 1.5f), 1.5f);
fennec_test_run(mix(0.0f, 1.0f, -0.5f), -0.5f);
fennec_test_run(mix(0.0f, 1.0f, 0.5f), 0.5f);
fennec_test_run(mix(0.0f, 1.0f, 1.5f), 1.5f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(mix(0.0f, 1.0f, false), 0.0f);
fennec_test_run(mix(0.0f, 1.0f, true), 1.0f);
}
}
fennec_test_run(mix(0.0f, 1.0f, false), 0.0f);
fennec_test_run(mix(0.0f, 1.0f, true), 1.0f);
}
}

75
test/tests/math/test_exponential.h
View File

@@ -24,60 +24,55 @@
#include <fennec/math/exponential.h>
#include <fennec/math/ext/constants.h>
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_math_exponential()
{
fennec_test_run(fennec::pow(1.0f, 2.0f), 1.0f);
fennec_test_run(fennec::pow(2.0f, 0.0f), 1.0f);
fennec_test_run(fennec::pow(2.0f, 1.0f), 2.0f);
fennec_test_run(fennec::pow(2.0f, 2.0f), 4.0f);
inline void fennec_test_math_exponential()
{
fennec_test_run(fennec::pow(1.0f, 2.0f), 1.0f);
fennec_test_run(fennec::pow(2.0f, 0.0f), 1.0f);
fennec_test_run(fennec::pow(2.0f, 1.0f), 2.0f);
fennec_test_run(fennec::pow(2.0f, 2.0f), 4.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::exp(-1.0f), fennec::one_over_e<float>());
fennec_test_run(fennec::exp( 0.0f), 1.0f);
fennec_test_run(fennec::exp( 1.0f), fennec::e<float>());
fennec_test_run(fennec::exp( 2.0f), fennec::e_sq<float>());
fennec_test_run(fennec::exp(-1.0f), fennec::one_over_e<float>());
fennec_test_run(fennec::exp( 0.0f), 1.0f);
fennec_test_run(fennec::exp( 1.0f), fennec::e<float>());
fennec_test_run(fennec::exp( 2.0f), fennec::e_sq<float>());
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::exp2(-1.0f), 0.5f);
fennec_test_run(fennec::exp2( 0.0f), 1.0f);
fennec_test_run(fennec::exp2( 1.0f), 2.0f);
fennec_test_run(fennec::exp2( 2.0f), 4.0f);
fennec_test_run(fennec::exp2(-1.0f), 0.5f);
fennec_test_run(fennec::exp2( 0.0f), 1.0f);
fennec_test_run(fennec::exp2( 1.0f), 2.0f);
fennec_test_run(fennec::exp2( 2.0f), 4.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::log(fennec::one_over_e<float>()), -1.0f);
fennec_test_run(fennec::log(1.0f), 0.0f);
fennec_test_run(fennec::log(fennec::e<float>()), 1.0f);
fennec_test_run(fennec::log(fennec::e_sq<float>()), 2.0f);
fennec_test_run(fennec::log(fennec::one_over_e<float>()), -1.0f);
fennec_test_run(fennec::log(1.0f), 0.0f);
fennec_test_run(fennec::log(fennec::e<float>()), 1.0f);
fennec_test_run(fennec::log(fennec::e_sq<float>()), 2.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::log2(1.0f), 0.0f);
fennec_test_run(fennec::log2(2.0f), 1.0f);
fennec_test_run(fennec::log2(4.0f), 2.0f);
fennec_test_run(fennec::log2(1.0f), 0.0f);
fennec_test_run(fennec::log2(2.0f), 1.0f);
fennec_test_run(fennec::log2(4.0f), 2.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::sqrt(1.0f), 1.0f);
fennec_test_run(fennec::sqrt(4.0f), 2.0f);
fennec_test_run(fennec::sqrt(9.0f), 3.0f);
fennec_test_run(fennec::sqrt(1.0f), 1.0f);
fennec_test_run(fennec::sqrt(4.0f), 2.0f);
fennec_test_run(fennec::sqrt(9.0f), 3.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::inversesqrt(1.0f), 1.0f / 1.0f);
fennec_test_run(fennec::inversesqrt(4.0f), 1.0f / 2.0f);
fennec_test_run(fennec::inversesqrt(9.0f), 1.0f / 3.0f);
}
}
fennec_test_run(fennec::inversesqrt(1.0f), 1.0f / 1.0f);
fennec_test_run(fennec::inversesqrt(4.0f), 1.0f / 2.0f);
fennec_test_run(fennec::inversesqrt(9.0f), 1.0f / 3.0f);
}
}

21
test/tests/math/test_ext.h
View File

@@ -23,23 +23,18 @@
#ifndef FENNEC_TEST_MATH_EXT_H
#define FENNEC_TEST_MATH_EXT_H
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_math_ext() {
inline void fennec_test_math_ext() {
fennec_test_subheader("quaternion tests");
fennec_test_spacer(2);
fennec_test_math_quaternion();
fennec_test_spacer(3);
fennec_test_subheader("quaternion tests");
fennec_test_spacer(2);
fennec_test_math_quaternion();
fennec_test_spacer(3);
// TODO
}
}
// TODO
}
}

71
test/tests/math/test_geometric.h
View File

@@ -25,61 +25,56 @@
#include "../../test.h"
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_math_geometric()
{
inline void fennec_test_math_geometric()
{
fennec_test_run(fennec::dot(vec2(1, 2), vec2(1, 2)), 5.0f);
fennec_test_run(fennec::dot(vec3(1, 2, 3), vec3(1, 2, 3)), 14.0f);
fennec_test_run(fennec::dot(vec4(1, 2, 3, 4), vec4(1, 2, 3, 4)), 30.0f);
fennec_test_run(fennec::dot(vec2(1, 2), vec2(1, 2)), 5.0f);
fennec_test_run(fennec::dot(vec3(1, 2, 3), vec3(1, 2, 3)), 14.0f);
fennec_test_run(fennec::dot(vec4(1, 2, 3, 4), vec4(1, 2, 3, 4)), 30.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::length2(vec2(1, 2) ), 5.0f);
fennec_test_run(fennec::length2(vec3(1, 2, 3) ), 14.0f);
fennec_test_run(fennec::length2(vec4(1, 2, 3, 4)), 30.0f);
fennec_test_run(fennec::length2(vec2(1, 2) ), 5.0f);
fennec_test_run(fennec::length2(vec3(1, 2, 3) ), 14.0f);
fennec_test_run(fennec::length2(vec4(1, 2, 3, 4)), 30.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::length(vec2(1, 2) ), sqrt(5.0f));
fennec_test_run(fennec::length(vec3(1, 2, 3) ), sqrt(14.0f));
fennec_test_run(fennec::length(vec4(1, 2, 3, 4)), sqrt(30.0f));
fennec_test_run(fennec::length(vec2(1, 2) ), sqrt(5.0f));
fennec_test_run(fennec::length(vec3(1, 2, 3) ), sqrt(14.0f));
fennec_test_run(fennec::length(vec4(1, 2, 3, 4)), sqrt(30.0f));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::distance(vec2(1, 2), vec2(2, 1)), sqrt(2.0f));
fennec_test_run(fennec::distance(vec3(1, 2, 3), vec3(3, 2, 1)), sqrt(8.0f));
fennec_test_run(fennec::distance(vec4(1, 2, 3, 4), vec4(4, 3, 2, 1)), sqrt(20.0f));
fennec_test_run(fennec::distance(vec2(1, 2), vec2(2, 1)), sqrt(2.0f));
fennec_test_run(fennec::distance(vec3(1, 2, 3), vec3(3, 2, 1)), sqrt(8.0f));
fennec_test_run(fennec::distance(vec4(1, 2, 3, 4), vec4(4, 3, 2, 1)), sqrt(20.0f));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::cross(vec3(1, 0, 0), vec3(0, 1, 0)), vec3(0, 0, 1));
fennec_test_run(fennec::cross(vec3(0, 1, 0), vec3(0, 0, 1)), vec3(1, 0, 0));
fennec_test_run(fennec::cross(vec3(0, 0, 1), vec3(1, 0, 0)), vec3(0, 1, 0));
fennec_test_run(fennec::cross(vec3(1, 0, 0), vec3(0, 1, 0)), vec3(0, 0, 1));
fennec_test_run(fennec::cross(vec3(0, 1, 0), vec3(0, 0, 1)), vec3(1, 0, 0));
fennec_test_run(fennec::cross(vec3(0, 0, 1), vec3(1, 0, 0)), vec3(0, 1, 0));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::normalize(vec2(1, 1)), vec2(sqrt(2.0f) / 2.0f, sqrt(2.0f) / 2.0f));
fennec_test_run(fennec::normalize(vec3(1, 1, 1)), vec3(sqrt(3.0f) / 3.0f, sqrt(3.0f) / 3.0f, sqrt(3.0f) / 3.0f));
fennec_test_run(fennec::normalize(vec4(1, 1, 1, 1)), vec4(0.5f, 0.5f, 0.5f, 0.5f));
fennec_test_run(fennec::normalize(vec2(1, 1)), vec2(sqrt(2.0f) / 2.0f, sqrt(2.0f) / 2.0f));
fennec_test_run(fennec::normalize(vec3(1, 1, 1)), vec3(sqrt(3.0f) / 3.0f, sqrt(3.0f) / 3.0f, sqrt(3.0f) / 3.0f));
fennec_test_run(fennec::normalize(vec4(1, 1, 1, 1)), vec4(0.5f, 0.5f, 0.5f, 0.5f));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::faceforward(vec3(1, 0, 0), vec3(-1, 0, 0), vec3(1, 0, 0)), vec3(-1, 0, 0));
fennec_test_run(fennec::faceforward(vec3(1, 0, 0), vec3(-1, 0, 0), vec3(-1, 0, 0)), vec3( 1, 0, 0));
fennec_test_run(fennec::faceforward(vec3(1, 0, 0), vec3(-1, 0, 0), vec3(1, 0, 0)), vec3(-1, 0, 0));
fennec_test_run(fennec::faceforward(vec3(1, 0, 0), vec3(-1, 0, 0), vec3(-1, 0, 0)), vec3( 1, 0, 0));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::reflect(vec2(1, -1), vec2(0, 1)), vec2(1, 1));
fennec_test_run(fennec::refract(vec2(1, -1), vec2(0, 1), 1/1.33f), vec2(0.7518797, -1));
}
}
fennec_test_run(fennec::reflect(vec2(1, -1), vec2(0, 1)), vec2(1, 1));
fennec_test_run(fennec::refract(vec2(1, -1), vec2(0, 1), 1/1.33f), vec2(0.7518797, -1));
}
}

373
test/tests/math/test_matrix.h
View File

@@ -26,303 +26,298 @@
#include <iostream>
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_math_matrix()
{
fennec_test_section("component_count");
inline void fennec_test_math_matrix()
{
fennec_test_section("component_count");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run((component_count_v<mat2x2> == 4), true);
fennec_test_run((component_count_v<mat2x3> == 6), true);
fennec_test_run((component_count_v<mat3x2> == 6), true);
fennec_test_run((component_count_v<mat3x3> == 9), true);
fennec_test_run((component_count_v<mat3x4> == 12), true);
fennec_test_run((component_count_v<mat4x3> == 12), true);
fennec_test_run((component_count_v<mat4x4> == 16), true);
fennec_test_run((component_count_v<mat2x2> == 4), true);
fennec_test_run((component_count_v<mat2x3> == 6), true);
fennec_test_run((component_count_v<mat3x2> == 6), true);
fennec_test_run((component_count_v<mat3x3> == 9), true);
fennec_test_run((component_count_v<mat3x4> == 12), true);
fennec_test_run((component_count_v<mat4x3> == 12), true);
fennec_test_run((component_count_v<mat4x4> == 16), true);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run((component_count_v<mat2x2&> == 4), true);
fennec_test_run((component_count_v<mat2x3&> == 6), true);
fennec_test_run((component_count_v<mat3x2&> == 6), true);
fennec_test_run((component_count_v<mat3x3&> == 9), true);
fennec_test_run((component_count_v<mat3x4&> == 12), true);
fennec_test_run((component_count_v<mat4x3&> == 12), true);
fennec_test_run((component_count_v<mat4x4&> == 16), true);
fennec_test_run((component_count_v<mat2x2&> == 4), true);
fennec_test_run((component_count_v<mat2x3&> == 6), true);
fennec_test_run((component_count_v<mat3x2&> == 6), true);
fennec_test_run((component_count_v<mat3x3&> == 9), true);
fennec_test_run((component_count_v<mat3x4&> == 12), true);
fennec_test_run((component_count_v<mat4x3&> == 12), true);
fennec_test_run((component_count_v<mat4x4&> == 16), true);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run((component_count_v<mat2x2&&> == 4), true);
fennec_test_run((component_count_v<mat2x3&&> == 6), true);
fennec_test_run((component_count_v<mat3x2&&> == 6), true);
fennec_test_run((component_count_v<mat3x3&&> == 9), true);
fennec_test_run((component_count_v<mat3x4&&> == 12), true);
fennec_test_run((component_count_v<mat4x3&&> == 12), true);
fennec_test_run((component_count_v<mat4x4&&> == 16), true);
fennec_test_run((component_count_v<mat2x2&&> == 4), true);
fennec_test_run((component_count_v<mat2x3&&> == 6), true);
fennec_test_run((component_count_v<mat3x2&&> == 6), true);
fennec_test_run((component_count_v<mat3x3&&> == 9), true);
fennec_test_run((component_count_v<mat3x4&&> == 12), true);
fennec_test_run((component_count_v<mat4x3&&> == 12), true);
fennec_test_run((component_count_v<mat4x4&&> == 16), true);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run((component_count_v<const mat2x2&> == 4), true);
fennec_test_run((component_count_v<const mat2x3&> == 6), true);
fennec_test_run((component_count_v<const mat3x2&> == 6), true);
fennec_test_run((component_count_v<const mat3x3&> == 9), true);
fennec_test_run((component_count_v<const mat3x4&> == 12), true);
fennec_test_run((component_count_v<const mat4x3&> == 12), true);
fennec_test_run((component_count_v<const mat4x4&> == 16), true);
fennec_test_run((component_count_v<const mat2x2&> == 4), true);
fennec_test_run((component_count_v<const mat2x3&> == 6), true);
fennec_test_run((component_count_v<const mat3x2&> == 6), true);
fennec_test_run((component_count_v<const mat3x3&> == 9), true);
fennec_test_run((component_count_v<const mat3x4&> == 12), true);
fennec_test_run((component_count_v<const mat4x3&> == 12), true);
fennec_test_run((component_count_v<const mat4x4&> == 16), true);
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_run((component_count_v<dmat2x2> == 4), true);
fennec_test_run((component_count_v<dmat2x3> == 6), true);
fennec_test_run((component_count_v<dmat3x2> == 6), true);
fennec_test_run((component_count_v<dmat3x3> == 9), true);
fennec_test_run((component_count_v<dmat3x4> == 12), true);
fennec_test_run((component_count_v<dmat4x3> == 12), true);
fennec_test_run((component_count_v<dmat4x4> == 16), true);
fennec_test_run((component_count_v<dmat2x2> == 4), true);
fennec_test_run((component_count_v<dmat2x3> == 6), true);
fennec_test_run((component_count_v<dmat3x2> == 6), true);
fennec_test_run((component_count_v<dmat3x3> == 9), true);
fennec_test_run((component_count_v<dmat3x4> == 12), true);
fennec_test_run((component_count_v<dmat4x3> == 12), true);
fennec_test_run((component_count_v<dmat4x4> == 16), true);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run((component_count_v<dmat2x2&> == 4), true);
fennec_test_run((component_count_v<dmat2x3&> == 6), true);
fennec_test_run((component_count_v<dmat3x2&> == 6), true);
fennec_test_run((component_count_v<dmat3x3&> == 9), true);
fennec_test_run((component_count_v<dmat3x4&> == 12), true);
fennec_test_run((component_count_v<dmat4x3&> == 12), true);
fennec_test_run((component_count_v<dmat4x4&> == 16), true);
fennec_test_run((component_count_v<dmat2x2&> == 4), true);
fennec_test_run((component_count_v<dmat2x3&> == 6), true);
fennec_test_run((component_count_v<dmat3x2&> == 6), true);
fennec_test_run((component_count_v<dmat3x3&> == 9), true);
fennec_test_run((component_count_v<dmat3x4&> == 12), true);
fennec_test_run((component_count_v<dmat4x3&> == 12), true);
fennec_test_run((component_count_v<dmat4x4&> == 16), true);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run((component_count_v<dmat2x2&&> == 4), true);
fennec_test_run((component_count_v<dmat2x3&&> == 6), true);
fennec_test_run((component_count_v<dmat3x2&&> == 6), true);
fennec_test_run((component_count_v<dmat3x3&&> == 9), true);
fennec_test_run((component_count_v<dmat3x4&&> == 12), true);
fennec_test_run((component_count_v<dmat4x3&&> == 12), true);
fennec_test_run((component_count_v<dmat4x4&&> == 16), true);
fennec_test_run((component_count_v<dmat2x2&&> == 4), true);
fennec_test_run((component_count_v<dmat2x3&&> == 6), true);
fennec_test_run((component_count_v<dmat3x2&&> == 6), true);
fennec_test_run((component_count_v<dmat3x3&&> == 9), true);
fennec_test_run((component_count_v<dmat3x4&&> == 12), true);
fennec_test_run((component_count_v<dmat4x3&&> == 12), true);
fennec_test_run((component_count_v<dmat4x4&&> == 16), true);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run((component_count_v<const dmat2x2&> == 4), true);
fennec_test_run((component_count_v<const dmat2x3&> == 6), true);
fennec_test_run((component_count_v<const dmat3x2&> == 6), true);
fennec_test_run((component_count_v<const dmat3x3&> == 9), true);
fennec_test_run((component_count_v<const dmat3x4&> == 12), true);
fennec_test_run((component_count_v<const dmat4x3&> == 12), true);
fennec_test_run((component_count_v<const dmat4x4&> == 16), true);
fennec_test_run((component_count_v<const dmat2x2&> == 4), true);
fennec_test_run((component_count_v<const dmat2x3&> == 6), true);
fennec_test_run((component_count_v<const dmat3x2&> == 6), true);
fennec_test_run((component_count_v<const dmat3x3&> == 9), true);
fennec_test_run((component_count_v<const dmat3x4&> == 12), true);
fennec_test_run((component_count_v<const dmat4x3&> == 12), true);
fennec_test_run((component_count_v<const dmat4x4&> == 16), true);
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("matrix equality operators");
fennec_test_section("matrix equality operators");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(mat2() == mat2(), true);
fennec_test_run(mat3() == mat3(), true);
fennec_test_run(mat4() == mat4(), true);
fennec_test_run(mat2() == mat2(), true);
fennec_test_run(mat3() == mat3(), true);
fennec_test_run(mat4() == mat4(), true);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(mat2() != mat2(), false);
fennec_test_run(mat3() != mat3(), false);
fennec_test_run(mat4() != mat4(), false);
fennec_test_run(mat2() != mat2(), false);
fennec_test_run(mat3() != mat3(), false);
fennec_test_run(mat4() != mat4(), false);
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("matrix constructors");
fennec_test_section("matrix constructors");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(mat2(), mat2(0));
fennec_test_run(mat3(), mat3(0));
fennec_test_run(mat4(), mat4(0));
fennec_test_run(mat2(), mat2(0));
fennec_test_run(mat3(), mat3(0));
fennec_test_run(mat4(), mat4(0));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(mat2(1), mat2(1, 0, 0, 1));
fennec_test_run(mat3(1), mat3(1, 0, 0, 0, 1, 0, 0, 0, 1));
fennec_test_run(mat4(1), mat4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1));
fennec_test_run(mat2(1), mat2(1, 0, 0, 1));
fennec_test_run(mat3(1), mat3(1, 0, 0, 0, 1, 0, 0, 0, 1));
fennec_test_run(mat4(1), mat4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("matrix-scalar operators");
fennec_test_section("matrix-scalar operators");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(mat2x2(1, 2, 3, 4) * 2, mat2x2(2, 4, 6, 8));
fennec_test_run(mat2x3(1, 2, 3, 4, 5, 6) * 2, mat2x3(2, 4, 6, 8, 10, 12));
fennec_test_run(mat3x2(1, 2, 3, 4, 5, 6) * 2, mat3x2(2, 4, 6, 8, 10, 12));
fennec_test_run(mat3x3(1, 2, 3, 4, 5, 6, 7, 8, 9) * 2, mat3x3(2, 4, 6, 8, 10, 12, 14, 16, 18));
fennec_test_run(mat2x2(1, 2, 3, 4) * 2, mat2x2(2, 4, 6, 8));
fennec_test_run(mat2x3(1, 2, 3, 4, 5, 6) * 2, mat2x3(2, 4, 6, 8, 10, 12));
fennec_test_run(mat3x2(1, 2, 3, 4, 5, 6) * 2, mat3x2(2, 4, 6, 8, 10, 12));
fennec_test_run(mat3x3(1, 2, 3, 4, 5, 6, 7, 8, 9) * 2, mat3x3(2, 4, 6, 8, 10, 12, 14, 16, 18));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("matrix-vector operators");
fennec_test_section("matrix-vector operators");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(vec2(1, 2) * mat2x2(1, 2, 3, 4), vec2(5, 11));
fennec_test_run(vec2(1, 2) * mat3x2(1, 2, 3, 4, 5, 6), vec3(5, 11, 17));
fennec_test_run(vec2(1, 2) * mat4x2(1, 2, 3, 4, 5, 6, 7, 8), vec4(5, 11, 17, 23));
fennec_test_run(vec2(1, 2) * mat2x2(1, 2, 3, 4), vec2(5, 11));
fennec_test_run(vec2(1, 2) * mat3x2(1, 2, 3, 4, 5, 6), vec3(5, 11, 17));
fennec_test_run(vec2(1, 2) * mat4x2(1, 2, 3, 4, 5, 6, 7, 8), vec4(5, 11, 17, 23));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(vec3(1, 2, 3) * mat2x3(1, 2, 3, 4, 5, 6), vec2(14, 32));
fennec_test_run(vec3(1, 2, 3) * mat3x3(1, 2, 3, 4, 5, 6, 7, 8, 9), vec3(14, 32, 50));
fennec_test_run(vec3(1, 2, 3) * mat4x3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), vec4(14, 32, 50, 68));
fennec_test_run(vec3(1, 2, 3) * mat2x3(1, 2, 3, 4, 5, 6), vec2(14, 32));
fennec_test_run(vec3(1, 2, 3) * mat3x3(1, 2, 3, 4, 5, 6, 7, 8, 9), vec3(14, 32, 50));
fennec_test_run(vec3(1, 2, 3) * mat4x3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), vec4(14, 32, 50, 68));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("matrix-matrix operators");
fennec_test_section("matrix-matrix operators");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(mat2x2(1, 2, 3, 4) * mat2x2(1, 2, 3, 4), mat2x2(7, 10, 15, 22));
fennec_test_run(mat2x2(1, 2, 3, 4) * mat3x2(1, 2, 3, 4, 5, 6), mat3x2(7, 10, 15, 22, 23, 34));
fennec_test_run(mat2x2(1, 2, 3, 4) * mat4x2(1, 2, 3, 4, 5, 6, 7, 8), mat4x2(7, 10, 15, 22, 23, 34, 31, 46));
fennec_test_run(mat2x2(1, 2, 3, 4) * mat2x2(1, 2, 3, 4), mat2x2(7, 10, 15, 22));
fennec_test_run(mat2x2(1, 2, 3, 4) * mat3x2(1, 2, 3, 4, 5, 6), mat3x2(7, 10, 15, 22, 23, 34));
fennec_test_run(mat2x2(1, 2, 3, 4) * mat4x2(1, 2, 3, 4, 5, 6, 7, 8), mat4x2(7, 10, 15, 22, 23, 34, 31, 46));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(mat2x3(1, 2, 3, 4, 5, 6) * mat2x2(1, 2, 3, 4), mat2x3(9, 12, 15, 19, 26, 33));
fennec_test_run(mat2x3(1, 2, 3, 4, 5, 6) * mat3x2(1, 2, 3, 4, 5, 6), mat3x3(9, 12, 15, 19, 26, 33, 29, 40, 51));
fennec_test_run(mat2x3(1, 2, 3, 4, 5, 6) * mat4x2(1, 2, 3, 4, 5, 6, 7, 8), mat4x3(9, 12, 15, 19, 26, 33, 29, 40, 51, 39, 54, 69));
fennec_test_run(mat2x3(1, 2, 3, 4, 5, 6) * mat2x2(1, 2, 3, 4), mat2x3(9, 12, 15, 19, 26, 33));
fennec_test_run(mat2x3(1, 2, 3, 4, 5, 6) * mat3x2(1, 2, 3, 4, 5, 6), mat3x3(9, 12, 15, 19, 26, 33, 29, 40, 51));
fennec_test_run(mat2x3(1, 2, 3, 4, 5, 6) * mat4x2(1, 2, 3, 4, 5, 6, 7, 8), mat4x3(9, 12, 15, 19, 26, 33, 29, 40, 51, 39, 54, 69));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(mat3x2(1, 2, 3, 4, 5, 6) * mat2x3(1, 2, 3, 4, 5, 6), mat2x2(22, 28, 49, 64));
fennec_test_run(mat3x2(1, 2, 3, 4, 5, 6) * mat3x3(1, 2, 3, 4, 5, 6, 7, 8, 9), mat3x2(22, 28, 49, 64, 76, 100));
fennec_test_run(mat3x2(1, 2, 3, 4, 5, 6) * mat4x3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), mat4x2(22, 28, 49, 64, 76, 100, 103, 136));
fennec_test_run(mat3x2(1, 2, 3, 4, 5, 6) * mat2x3(1, 2, 3, 4, 5, 6), mat2x2(22, 28, 49, 64));
fennec_test_run(mat3x2(1, 2, 3, 4, 5, 6) * mat3x3(1, 2, 3, 4, 5, 6, 7, 8, 9), mat3x2(22, 28, 49, 64, 76, 100));
fennec_test_run(mat3x2(1, 2, 3, 4, 5, 6) * mat4x3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), mat4x2(22, 28, 49, 64, 76, 100, 103, 136));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(mat3x3(1, 2, 3, 4, 5, 6, 7, 8, 9) * mat2x3(1, 2, 3, 4, 5, 6), mat2x3(30, 36, 42, 66, 81, 96));
fennec_test_run(mat3x3(1, 2, 3, 4, 5, 6, 7, 8, 9) * mat3x3(1, 2, 3, 4, 5, 6, 7, 8, 9), mat3x3(30, 36, 42, 66, 81, 96, 102, 126, 150));
fennec_test_run(mat3x3(1, 2, 3, 4, 5, 6, 7, 8, 9) * mat4x3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), mat4x3(30, 36, 42, 66, 81, 96, 102, 126, 150, 138, 171, 204));
fennec_test_run(mat3x3(1, 2, 3, 4, 5, 6, 7, 8, 9) * mat2x3(1, 2, 3, 4, 5, 6), mat2x3(30, 36, 42, 66, 81, 96));
fennec_test_run(mat3x3(1, 2, 3, 4, 5, 6, 7, 8, 9) * mat3x3(1, 2, 3, 4, 5, 6, 7, 8, 9), mat3x3(30, 36, 42, 66, 81, 96, 102, 126, 150));
fennec_test_run(mat3x3(1, 2, 3, 4, 5, 6, 7, 8, 9) * mat4x3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), mat4x3(30, 36, 42, 66, 81, 96, 102, 126, 150, 138, 171, 204));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(mat3x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) * mat2x3(1, 2, 3, 4, 5, 6), mat2x4(38, 44, 50, 56, 83, 98, 113, 128));
fennec_test_run(mat3x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) * mat3x3(1, 2, 3, 4, 5, 6, 7, 8, 9), mat3x4(38, 44, 50, 56, 83, 98, 113, 128, 128, 152, 176, 200));
fennec_test_run(mat3x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) * mat4x3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), mat4x4(38, 44, 50, 56, 83, 98, 113, 128, 128, 152, 176, 200, 173, 206, 239, 272));
fennec_test_run(mat3x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) * mat2x3(1, 2, 3, 4, 5, 6), mat2x4(38, 44, 50, 56, 83, 98, 113, 128));
fennec_test_run(mat3x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) * mat3x3(1, 2, 3, 4, 5, 6, 7, 8, 9), mat3x4(38, 44, 50, 56, 83, 98, 113, 128, 128, 152, 176, 200));
fennec_test_run(mat3x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) * mat4x3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), mat4x4(38, 44, 50, 56, 83, 98, 113, 128, 128, 152, 176, 200, 173, 206, 239, 272));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(mat4x3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) * mat2x4(1, 2, 3, 4, 5, 6, 7, 8), mat2x3(70, 80, 90, 158, 184, 210));
fennec_test_run(mat4x3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) * mat3x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), mat3x3(70, 80, 90, 158, 184, 210, 246, 288, 330));
fennec_test_run(mat4x3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) * mat4x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), mat4x3(70, 80, 90, 158, 184, 210, 246, 288, 330, 334, 392, 450));
fennec_test_run(mat4x3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) * mat2x4(1, 2, 3, 4, 5, 6, 7, 8), mat2x3(70, 80, 90, 158, 184, 210));
fennec_test_run(mat4x3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) * mat3x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), mat3x3(70, 80, 90, 158, 184, 210, 246, 288, 330));
fennec_test_run(mat4x3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) * mat4x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), mat4x3(70, 80, 90, 158, 184, 210, 246, 288, 330, 334, 392, 450));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(mat4x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16) * mat2x4(1, 2, 3, 4, 5, 6, 7, 8), mat2x4(90, 100, 110, 120, 202, 228, 254, 280));
fennec_test_run(mat4x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16) * mat3x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), mat3x4(90, 100, 110, 120, 202, 228, 254, 280, 314,356,398,440));
fennec_test_run(mat4x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16) * mat4x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), mat4x4(90, 100, 110, 120, 202, 228, 254, 280, 314, 356, 398, 440, 426, 484, 542, 600));
fennec_test_run(mat4x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16) * mat2x4(1, 2, 3, 4, 5, 6, 7, 8), mat2x4(90, 100, 110, 120, 202, 228, 254, 280));
fennec_test_run(mat4x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16) * mat3x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), mat3x4(90, 100, 110, 120, 202, 228, 254, 280, 314,356,398,440));
fennec_test_run(mat4x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16) * mat4x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), mat4x4(90, 100, 110, 120, 202, 228, 254, 280, 314, 356, 398, 440, 426, 484, 542, 600));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("matrixCompMult");
fennec_test_section("matrixCompMult");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::matrixCompMult(mat2(1, 2, 3, 4), mat2(1)), mat2(1, 0, 0, 4));
fennec_test_run(fennec::matrixCompMult(mat3(1, 4, 8, 6, 2, 5, 9, 7, 3), mat3(1)), mat3(1, 0, 0, 0, 2, 0, 0, 0, 3));
fennec_test_run(fennec::matrixCompMult(mat4(2, 1, -3, 4, -1, 0, 2, 5, 3, 2, 1, 0, 4, -2, 3, 1), mat4(1)), mat4(2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1));
fennec_test_run(fennec::matrixCompMult(mat2(1, 2, 3, 4), mat2(1)), mat2(1, 0, 0, 4));
fennec_test_run(fennec::matrixCompMult(mat3(1, 4, 8, 6, 2, 5, 9, 7, 3), mat3(1)), mat3(1, 0, 0, 0, 2, 0, 0, 0, 3));
fennec_test_run(fennec::matrixCompMult(mat4(2, 1, -3, 4, -1, 0, 2, 5, 3, 2, 1, 0, 4, -2, 3, 1), mat4(1)), mat4(2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("outerProduct");
fennec_test_section("outerProduct");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::outerProduct(vec2(1, 2), vec2(3, 4)), mat2(3, 6, 4, 8));
fennec_test_run(fennec::outerProduct(vec3(1, 2, 3), vec3(4, 5, 6)), mat3(4, 8, 12, 5, 10, 15, 6, 12, 18));
fennec_test_run(fennec::outerProduct(vec4(1, 2, 3, 4), vec4(5, 6, 7, 8)), mat4(5, 10, 15, 20, 6, 12, 18, 24, 7, 14, 21, 28, 8, 16, 24, 32));
fennec_test_run(fennec::outerProduct(vec2(1, 2), vec2(3, 4)), mat2(3, 6, 4, 8));
fennec_test_run(fennec::outerProduct(vec3(1, 2, 3), vec3(4, 5, 6)), mat3(4, 8, 12, 5, 10, 15, 6, 12, 18));
fennec_test_run(fennec::outerProduct(vec4(1, 2, 3, 4), vec4(5, 6, 7, 8)), mat4(5, 10, 15, 20, 6, 12, 18, 24, 7, 14, 21, 28, 8, 16, 24, 32));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::outerProduct(vec3(1, 2, 3), vec2(4, 5)), mat2x3(4, 8, 12, 5, 10, 15));
fennec_test_run(fennec::outerProduct(vec2(1, 2), vec3(3, 4, 5)), mat3x2(3, 6, 4, 8, 5, 10));
fennec_test_run(fennec::outerProduct(vec3(1, 2, 3), vec2(4, 5)), mat2x3(4, 8, 12, 5, 10, 15));
fennec_test_run(fennec::outerProduct(vec2(1, 2), vec3(3, 4, 5)), mat3x2(3, 6, 4, 8, 5, 10));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::outerProduct(vec4(1, 2, 3, 4), vec2(5, 6)), mat2x4(5, 10, 15, 20, 6, 12, 18, 24));
fennec_test_run(fennec::outerProduct(vec2(1, 2), vec4(3, 4, 5, 6)), mat4x2(3, 6, 4, 8, 5, 10, 6, 12));
fennec_test_run(fennec::outerProduct(vec4(1, 2, 3, 4), vec2(5, 6)), mat2x4(5, 10, 15, 20, 6, 12, 18, 24));
fennec_test_run(fennec::outerProduct(vec2(1, 2), vec4(3, 4, 5, 6)), mat4x2(3, 6, 4, 8, 5, 10, 6, 12));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::outerProduct(vec4(1, 2, 3, 4), vec3(5, 6, 7)), mat3x4(5, 10, 15, 20, 6, 12, 18, 24, 7, 14, 21, 28));
fennec_test_run(fennec::outerProduct(vec3(1, 2, 3), vec4(4, 5, 6, 7)), mat4x3(4, 8, 12, 5, 10, 15, 6, 12, 18, 7, 14, 21));
fennec_test_run(fennec::outerProduct(vec4(1, 2, 3, 4), vec3(5, 6, 7)), mat3x4(5, 10, 15, 20, 6, 12, 18, 24, 7, 14, 21, 28));
fennec_test_run(fennec::outerProduct(vec3(1, 2, 3), vec4(4, 5, 6, 7)), mat4x3(4, 8, 12, 5, 10, 15, 6, 12, 18, 7, 14, 21));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("transpose");
fennec_test_section("transpose");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::transpose(mat2(1, 2, 3, 4)), mat2(1, 3, 2, 4));
fennec_test_run(fennec::transpose(mat3(1, 2, 3, 4, 5, 6, 7, 8, 9)), mat3(1, 4, 7, 2, 5, 8, 3, 6, 9));
fennec_test_run(fennec::transpose(mat4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)), mat4(1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, 4, 8, 12, 16));
fennec_test_run(fennec::transpose(mat2(1, 2, 3, 4)), mat2(1, 3, 2, 4));
fennec_test_run(fennec::transpose(mat3(1, 2, 3, 4, 5, 6, 7, 8, 9)), mat3(1, 4, 7, 2, 5, 8, 3, 6, 9));
fennec_test_run(fennec::transpose(mat4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)), mat4(1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, 4, 8, 12, 16));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::transpose(mat3x2(1, 2, 3, 4, 5, 6)), mat2x3(1, 3, 5, 2, 4, 6));
fennec_test_run(fennec::transpose(mat2x3(1, 2, 3, 4, 5, 6)), mat3x2(1, 4, 2, 5, 3, 6));
fennec_test_run(fennec::transpose(mat3x2(1, 2, 3, 4, 5, 6)), mat2x3(1, 3, 5, 2, 4, 6));
fennec_test_run(fennec::transpose(mat2x3(1, 2, 3, 4, 5, 6)), mat3x2(1, 4, 2, 5, 3, 6));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::transpose(mat4x2(1, 2, 3, 4, 5, 6, 7, 8)), mat2x4(1, 3, 5, 7, 2, 4, 6, 8));
fennec_test_run(fennec::transpose(mat2x4(1, 2, 3, 4, 5, 6, 7, 8)), mat4x2(1, 5, 2, 6, 3, 7, 4, 8));
fennec_test_run(fennec::transpose(mat4x2(1, 2, 3, 4, 5, 6, 7, 8)), mat2x4(1, 3, 5, 7, 2, 4, 6, 8));
fennec_test_run(fennec::transpose(mat2x4(1, 2, 3, 4, 5, 6, 7, 8)), mat4x2(1, 5, 2, 6, 3, 7, 4, 8));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::transpose(mat4x3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)), mat3x4(1, 4, 7, 10, 2, 5, 8, 11, 3, 6, 9, 12));
fennec_test_run(fennec::transpose(mat3x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)), mat4x3(1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12));
fennec_test_run(fennec::transpose(mat4x3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)), mat3x4(1, 4, 7, 10, 2, 5, 8, 11, 3, 6, 9, 12));
fennec_test_run(fennec::transpose(mat3x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)), mat4x3(1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("determinant");
fennec_test_section("determinant");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::determinant(mat2(1, 2, 3, 4)), -2.0f);
fennec_test_run(fennec::determinant(mat3(1, 4, 8, 6, 2, 5, 9, 7, 3)), 271.0f);
fennec_test_run(fennec::determinant(mat4(2, 1, -3, 4, -1, 0, 2, 5, 3, 2, 1, 0, 4, -2, 3, 1)), 414.0f);
fennec_test_run(fennec::determinant(mat2(1, 2, 3, 4)), -2.0f);
fennec_test_run(fennec::determinant(mat3(1, 4, 8, 6, 2, 5, 9, 7, 3)), 271.0f);
fennec_test_run(fennec::determinant(mat4(2, 1, -3, 4, -1, 0, 2, 5, 3, 2, 1, 0, 4, -2, 3, 1)), 414.0f);
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("inverse");
fennec_test_section("inverse");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::inverse(mat2(1, 2, 3, 4)), mat2(-2, 1, 1.5, -0.5));
fennec_test_run(fennec::inverse(mat3(1, 2, 3, 0, 1, 4, 5, 6, 0)), mat3(-24, 18, 5, 20, -15, -4, -5, 4, 1));
fennec_test_run(fennec::inverse(mat4(2, 1, -3, 4, -1, 0, 2, 5, 3, 2, 1, 0, 4, -2, 3, 1)), (1.0f / 414.0f) * mat4(36, -39, 33, 51, -18, 31, 133, -83, -72, 55, 49, 13, 36, 53, -13, 5));
}
}
fennec_test_run(fennec::inverse(mat2(1, 2, 3, 4)), mat2(-2, 1, 1.5, -0.5));
fennec_test_run(fennec::inverse(mat3(1, 2, 3, 0, 1, 4, 5, 6, 0)), mat3(-24, 18, 5, 20, -15, -4, -5, 4, 1));
fennec_test_run(fennec::inverse(mat4(2, 1, -3, 4, -1, 0, 2, 5, 3, 2, 1, 0, 4, -2, 3, 1)), (1.0f / 414.0f) * mat4(36, -39, 33, 51, -18, 31, 133, -83, -72, 55, 49, 13, 36, 53, -13, 5));
}
}

35
test/tests/math/test_relational.h
View File

@@ -20,34 +20,29 @@
#define FENNEC_TEST_MATH_RELATIONAL_H
#include "../../test.h"
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_math_relational()
{
fennec_test_run(fennec::lessThan(vec3(3, 2, 1), vec3(1, 2, 3)), bvec3(false, false, true));
fennec_test_run(fennec::lessThanEqual(vec3(3, 2, 1), vec3(1, 2, 3)), bvec3(false, true, true));
inline void fennec_test_math_relational()
{
fennec_test_run(fennec::lessThan(vec3(3, 2, 1), vec3(1, 2, 3)), bvec3(false, false, true));
fennec_test_run(fennec::lessThanEqual(vec3(3, 2, 1), vec3(1, 2, 3)), bvec3(false, true, true));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::greaterThan(vec3(3, 2, 1), vec3(1, 2, 3)), bvec3(true, false, false));
fennec_test_run(fennec::greaterThanEqual(vec3(3, 2, 1), vec3(1, 2, 3)), bvec3(true, true, false));
fennec_test_run(fennec::greaterThan(vec3(3, 2, 1), vec3(1, 2, 3)), bvec3(true, false, false));
fennec_test_run(fennec::greaterThanEqual(vec3(3, 2, 1), vec3(1, 2, 3)), bvec3(true, true, false));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::equal(vec3(3, 2, 1), vec3(1, 2, 3)), bvec3(false, true, false));
fennec_test_run(fennec::notEqual(vec3(3, 2, 1), vec3(1, 2, 3)), bvec3(true, false, true));
fennec_test_run(fennec::equal(vec3(3, 2, 1), vec3(1, 2, 3)), bvec3(false, true, false));
fennec_test_run(fennec::notEqual(vec3(3, 2, 1), vec3(1, 2, 3)), bvec3(true, false, true));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(not(bvec3(true, false, true)), bvec3(false, true, false));
fennec_test_run(fennec::all(bvec3(true, true, true)), true);
}
}
fennec_test_run(not(bvec3(true, false, true)), bvec3(false, true, false));
fennec_test_run(fennec::all(bvec3(true, true, true)), true);
}
}

63
test/tests/math/test_scalar.h
View File

@@ -24,50 +24,45 @@
#include "../../test.h"
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_math_scalar()
{
fennec_test_section("component_count");
inline void fennec_test_math_scalar()
{
fennec_test_section("component_count");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run((component_count_v<bool_t> == 1), true);
fennec_test_run((component_count_v<int_t> == 1), true);
fennec_test_run((component_count_v<uint_t> == 1), true);
fennec_test_run((component_count_v<float_t> == 1), true);
fennec_test_run((component_count_v<double_t> == 1), true);
fennec_test_run((component_count_v<bool_t> == 1), true);
fennec_test_run((component_count_v<int_t> == 1), true);
fennec_test_run((component_count_v<uint_t> == 1), true);
fennec_test_run((component_count_v<float_t> == 1), true);
fennec_test_run((component_count_v<double_t> == 1), true);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run((component_count_v<const bool_t> == 1), true);
fennec_test_run((component_count_v<const int_t> == 1), true);
fennec_test_run((component_count_v<const uint_t> == 1), true);
fennec_test_run((component_count_v<const float_t> == 1), true);
fennec_test_run((component_count_v<const double_t> == 1), true);
fennec_test_run((component_count_v<const bool_t> == 1), true);
fennec_test_run((component_count_v<const int_t> == 1), true);
fennec_test_run((component_count_v<const uint_t> == 1), true);
fennec_test_run((component_count_v<const float_t> == 1), true);
fennec_test_run((component_count_v<const double_t> == 1), true);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run((component_count_v<volatile bool_t> == 1), true);
fennec_test_run((component_count_v<volatile int_t> == 1), true);
fennec_test_run((component_count_v<volatile uint_t> == 1), true);
fennec_test_run((component_count_v<volatile float_t> == 1), true);
fennec_test_run((component_count_v<volatile double_t> == 1), true);
fennec_test_run((component_count_v<volatile bool_t> == 1), true);
fennec_test_run((component_count_v<volatile int_t> == 1), true);
fennec_test_run((component_count_v<volatile uint_t> == 1), true);
fennec_test_run((component_count_v<volatile float_t> == 1), true);
fennec_test_run((component_count_v<volatile double_t> == 1), true);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run((component_count_v<const volatile bool_t> == 1), true);
fennec_test_run((component_count_v<const volatile int_t> == 1), true);
fennec_test_run((component_count_v<const volatile uint_t> == 1), true);
fennec_test_run((component_count_v<const volatile float_t> == 1), true);
fennec_test_run((component_count_v<const volatile double_t> == 1), true);
}
}
fennec_test_run((component_count_v<const volatile bool_t> == 1), true);
fennec_test_run((component_count_v<const volatile int_t> == 1), true);
fennec_test_run((component_count_v<const volatile uint_t> == 1), true);
fennec_test_run((component_count_v<const volatile float_t> == 1), true);
fennec_test_run((component_count_v<const volatile double_t> == 1), true);
}
}

111
test/tests/math/test_trigonometric.h
View File

@@ -23,98 +23,93 @@
#include "../../test.h"
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_math_trigonometric()
{
fennec_test_section("angle conversions");
inline void fennec_test_math_trigonometric()
{
fennec_test_section("angle conversions");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::radians( 45.0f), fennec::quarter_pi<float>());
fennec_test_run(fennec::radians( 90.0f), fennec::half_pi<float>());
fennec_test_run(fennec::radians(180.0f), fennec::pi<float>());
fennec_test_run(fennec::radians(270.0f), fennec::three_halves_pi<float>());
fennec_test_run(fennec::radians(360.0f), fennec::two_pi<float>());
fennec_test_run(fennec::radians( 45.0f), fennec::quarter_pi<float>());
fennec_test_run(fennec::radians( 90.0f), fennec::half_pi<float>());
fennec_test_run(fennec::radians(180.0f), fennec::pi<float>());
fennec_test_run(fennec::radians(270.0f), fennec::three_halves_pi<float>());
fennec_test_run(fennec::radians(360.0f), fennec::two_pi<float>());
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::degrees(fennec::quarter_pi<float>()), 45.0f);
fennec_test_run(fennec::degrees(fennec::half_pi<float>()), 90.0f);
fennec_test_run(fennec::degrees(fennec::pi<float>()), 180.0f);
fennec_test_run(fennec::degrees(fennec::three_halves_pi<float>()), 270.0f);
fennec_test_run(fennec::degrees(fennec::two_pi<float>()), 360.0f);
fennec_test_run(fennec::degrees(fennec::quarter_pi<float>()), 45.0f);
fennec_test_run(fennec::degrees(fennec::half_pi<float>()), 90.0f);
fennec_test_run(fennec::degrees(fennec::pi<float>()), 180.0f);
fennec_test_run(fennec::degrees(fennec::three_halves_pi<float>()), 270.0f);
fennec_test_run(fennec::degrees(fennec::two_pi<float>()), 360.0f);
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("trig functions");
fennec_test_section("trig functions");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::sin(fennec::sixth_pi<float>()), one_half<float>());
fennec_test_run(fennec::cos(fennec::sixth_pi<float>()), sqrt_three<float>() / 2.0f);
fennec_test_run(fennec::tan(fennec::sixth_pi<float>()), sqrt_three<float>() / 3.0f);
fennec_test_run(fennec::sin(fennec::sixth_pi<float>()), one_half<float>());
fennec_test_run(fennec::cos(fennec::sixth_pi<float>()), sqrt_three<float>() / 2.0f);
fennec_test_run(fennec::tan(fennec::sixth_pi<float>()), sqrt_three<float>() / 3.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::asin(one_half<float>()), fennec::sixth_pi<float>());
fennec_test_run(fennec::acos(sqrt_three<float>() / 2.0f), fennec::sixth_pi<float>());
fennec_test_run(fennec::atan(sqrt_three<float>() / 3.0f), fennec::sixth_pi<float>());
fennec_test_run(fennec::asin(one_half<float>()), fennec::sixth_pi<float>());
fennec_test_run(fennec::acos(sqrt_three<float>() / 2.0f), fennec::sixth_pi<float>());
fennec_test_run(fennec::atan(sqrt_three<float>() / 3.0f), fennec::sixth_pi<float>());
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_run(fennec::sin(fennec::quarter_pi<float>()), sqrt_two<float>() / 2.0f);
fennec_test_run(fennec::cos(fennec::quarter_pi<float>()), sqrt_two<float>() / 2.0f);
fennec_test_run(fennec::tan(fennec::quarter_pi<float>()), 1.0f);
fennec_test_run(fennec::sin(fennec::quarter_pi<float>()), sqrt_two<float>() / 2.0f);
fennec_test_run(fennec::cos(fennec::quarter_pi<float>()), sqrt_two<float>() / 2.0f);
fennec_test_run(fennec::tan(fennec::quarter_pi<float>()), 1.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::asin(sqrt_two<float>() / 2.0f), fennec::quarter_pi<float>());
fennec_test_run(fennec::acos(sqrt_two<float>() / 2.0f), fennec::quarter_pi<float>());
fennec_test_run(fennec::atan(1.0f), fennec::quarter_pi<float>());
fennec_test_run(fennec::asin(sqrt_two<float>() / 2.0f), fennec::quarter_pi<float>());
fennec_test_run(fennec::acos(sqrt_two<float>() / 2.0f), fennec::quarter_pi<float>());
fennec_test_run(fennec::atan(1.0f), fennec::quarter_pi<float>());
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("hyperbolic functions");
fennec_test_section("hyperbolic functions");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::sinh(0.0f), 0.0f);
fennec_test_run(fennec::cosh(0.0f), 1.0f);
fennec_test_run(fennec::tanh(0.0f), 0.0f);
fennec_test_run(fennec::sinh(0.0f), 0.0f);
fennec_test_run(fennec::cosh(0.0f), 1.0f);
fennec_test_run(fennec::tanh(0.0f), 0.0f);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::asinh(0.0f), 0.0f);
fennec_test_run(fennec::acosh(1.0f), 0.0f);
fennec_test_run(fennec::atanh(0.0f), 0.0f);
fennec_test_run(fennec::asinh(0.0f), 0.0f);
fennec_test_run(fennec::acosh(1.0f), 0.0f);
fennec_test_run(fennec::atanh(0.0f), 0.0f);
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_run(fennec::sinh(1.0f), (fennec::e<float>() - fennec::one_over_e<float>()) / 2.0f);
fennec_test_run(fennec::cosh(1.0f), (fennec::e<float>() + fennec::one_over_e<float>()) / 2.0f);
fennec_test_run(fennec::tanh(1.0f), ((fennec::e_raised_two<float>() - 1) / (fennec::e_raised_two<float>() + 1)));
fennec_test_run(fennec::sinh(1.0f), (fennec::e<float>() - fennec::one_over_e<float>()) / 2.0f);
fennec_test_run(fennec::cosh(1.0f), (fennec::e<float>() + fennec::one_over_e<float>()) / 2.0f);
fennec_test_run(fennec::tanh(1.0f), ((fennec::e_raised_two<float>() - 1) / (fennec::e_raised_two<float>() + 1)));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(fennec::asinh((fennec::e<float>() - fennec::one_over_e<float>()) / 2.0f), 1.0f);
fennec_test_run(fennec::acosh((fennec::e<float>() + fennec::one_over_e<float>()) / 2.0f), 1.0f);
fennec_test_run(fennec::atanh(((fennec::e_raised_two<float>() - 1) / (fennec::e_raised_two<float>() + 1))), 1.0f);
}
}
fennec_test_run(fennec::asinh((fennec::e<float>() - fennec::one_over_e<float>()) / 2.0f), 1.0f);
fennec_test_run(fennec::acosh((fennec::e<float>() + fennec::one_over_e<float>()) / 2.0f), 1.0f);
fennec_test_run(fennec::atanh(((fennec::e_raised_two<float>() - 1) / (fennec::e_raised_two<float>() + 1))), 1.0f);
}
}

751
test/tests/math/test_vector.h
View File

@@ -26,577 +26,572 @@
#include "../../test.h"
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_math_vector()
{
fennec_test_section("component_count");
fennec_test_spacer(1);
fennec_test_run((component_count_v<bvec2> == 2), true);
fennec_test_run((component_count_v<bvec3> == 3), true);
fennec_test_run((component_count_v<bvec4> == 4), true);
fennec_test_run((component_count_v<bvec2&> == 2), true);
fennec_test_run((component_count_v<bvec3&> == 3), true);
fennec_test_run((component_count_v<bvec4&> == 4), true);
fennec_test_run((component_count_v<bvec2&&> == 2), true);
fennec_test_run((component_count_v<bvec3&&> == 3), true);
fennec_test_run((component_count_v<bvec4&&> == 4), true);
fennec_test_run((component_count_v<const bvec2&> == 2), true);
fennec_test_run((component_count_v<const bvec3&> == 3), true);
fennec_test_run((component_count_v<const bvec4&> == 4), true);
fennec_test_spacer(1);
fennec_test_run((component_count_v<ivec2> == 2), true);
fennec_test_run((component_count_v<ivec3> == 3), true);
fennec_test_run((component_count_v<ivec4> == 4), true);
fennec_test_run((component_count_v<ivec2&> == 2), true);
fennec_test_run((component_count_v<ivec3&> == 3), true);
fennec_test_run((component_count_v<ivec4&> == 4), true);
fennec_test_run((component_count_v<ivec2&&> == 2), true);
fennec_test_run((component_count_v<ivec3&&> == 3), true);
fennec_test_run((component_count_v<ivec4&&> == 4), true);
fennec_test_run((component_count_v<const ivec2&> == 2), true);
fennec_test_run((component_count_v<const ivec3&> == 3), true);
fennec_test_run((component_count_v<const ivec4&> == 4), true);
inline void fennec_test_math_vector()
{
fennec_test_section("component_count");
fennec_test_spacer(1);
fennec_test_run((component_count_v<bvec2> == 2), true);
fennec_test_run((component_count_v<bvec3> == 3), true);
fennec_test_run((component_count_v<bvec4> == 4), true);
fennec_test_run((component_count_v<bvec2&> == 2), true);
fennec_test_run((component_count_v<bvec3&> == 3), true);
fennec_test_run((component_count_v<bvec4&> == 4), true);
fennec_test_run((component_count_v<bvec2&&> == 2), true);
fennec_test_run((component_count_v<bvec3&&> == 3), true);
fennec_test_run((component_count_v<bvec4&&> == 4), true);
fennec_test_run((component_count_v<const bvec2&> == 2), true);
fennec_test_run((component_count_v<const bvec3&> == 3), true);
fennec_test_run((component_count_v<const bvec4&> == 4), true);
fennec_test_spacer(1);
fennec_test_run((component_count_v<ivec2> == 2), true);
fennec_test_run((component_count_v<ivec3> == 3), true);
fennec_test_run((component_count_v<ivec4> == 4), true);
fennec_test_run((component_count_v<ivec2&> == 2), true);
fennec_test_run((component_count_v<ivec3&> == 3), true);
fennec_test_run((component_count_v<ivec4&> == 4), true);
fennec_test_run((component_count_v<ivec2&&> == 2), true);
fennec_test_run((component_count_v<ivec3&&> == 3), true);
fennec_test_run((component_count_v<ivec4&&> == 4), true);
fennec_test_run((component_count_v<const ivec2&> == 2), true);
fennec_test_run((component_count_v<const ivec3&> == 3), true);
fennec_test_run((component_count_v<const ivec4&> == 4), true);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run((component_count_v<uvec2> == 2), true);
fennec_test_run((component_count_v<uvec3> == 3), true);
fennec_test_run((component_count_v<uvec4> == 4), true);
fennec_test_run((component_count_v<uvec2&> == 2), true);
fennec_test_run((component_count_v<uvec3&> == 3), true);
fennec_test_run((component_count_v<uvec4&> == 4), true);
fennec_test_run((component_count_v<uvec2&&> == 2), true);
fennec_test_run((component_count_v<uvec3&&> == 3), true);
fennec_test_run((component_count_v<uvec4&&> == 4), true);
fennec_test_run((component_count_v<const uvec2&> == 2), true);
fennec_test_run((component_count_v<const uvec3&> == 3), true);
fennec_test_run((component_count_v<const uvec4&> == 4), true);
fennec_test_run((component_count_v<uvec2> == 2), true);
fennec_test_run((component_count_v<uvec3> == 3), true);
fennec_test_run((component_count_v<uvec4> == 4), true);
fennec_test_run((component_count_v<uvec2&> == 2), true);
fennec_test_run((component_count_v<uvec3&> == 3), true);
fennec_test_run((component_count_v<uvec4&> == 4), true);
fennec_test_run((component_count_v<uvec2&&> == 2), true);
fennec_test_run((component_count_v<uvec3&&> == 3), true);
fennec_test_run((component_count_v<uvec4&&> == 4), true);
fennec_test_run((component_count_v<const uvec2&> == 2), true);
fennec_test_run((component_count_v<const uvec3&> == 3), true);
fennec_test_run((component_count_v<const uvec4&> == 4), true);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run((component_count_v<vec2> == 2), true);
fennec_test_run((component_count_v<vec3> == 3), true);
fennec_test_run((component_count_v<vec4> == 4), true);
fennec_test_run((component_count_v<vec2&> == 2), true);
fennec_test_run((component_count_v<vec3&> == 3), true);
fennec_test_run((component_count_v<vec4&> == 4), true);
fennec_test_run((component_count_v<vec2&&> == 2), true);
fennec_test_run((component_count_v<vec3&&> == 3), true);
fennec_test_run((component_count_v<vec4&&> == 4), true);
fennec_test_run((component_count_v<const vec2&> == 2), true);
fennec_test_run((component_count_v<const vec3&> == 3), true);
fennec_test_run((component_count_v<const vec4&> == 4), true);
fennec_test_run((component_count_v<vec2> == 2), true);
fennec_test_run((component_count_v<vec3> == 3), true);
fennec_test_run((component_count_v<vec4> == 4), true);
fennec_test_run((component_count_v<vec2&> == 2), true);
fennec_test_run((component_count_v<vec3&> == 3), true);
fennec_test_run((component_count_v<vec4&> == 4), true);
fennec_test_run((component_count_v<vec2&&> == 2), true);
fennec_test_run((component_count_v<vec3&&> == 3), true);
fennec_test_run((component_count_v<vec4&&> == 4), true);
fennec_test_run((component_count_v<const vec2&> == 2), true);
fennec_test_run((component_count_v<const vec3&> == 3), true);
fennec_test_run((component_count_v<const vec4&> == 4), true);
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run((component_count_v<dvec2> == 2), true);
fennec_test_run((component_count_v<dvec3> == 3), true);
fennec_test_run((component_count_v<dvec4> == 4), true);
fennec_test_run((component_count_v<dvec2&> == 2), true);
fennec_test_run((component_count_v<dvec3&> == 3), true);
fennec_test_run((component_count_v<dvec4&> == 4), true);
fennec_test_run((component_count_v<dvec2&&> == 2), true);
fennec_test_run((component_count_v<dvec3&&> == 3), true);
fennec_test_run((component_count_v<dvec4&&> == 4), true);
fennec_test_run((component_count_v<const dvec2&> == 2), true);
fennec_test_run((component_count_v<const dvec3&> == 3), true);
fennec_test_run((component_count_v<const dvec4&> == 4), true);
fennec_test_run((component_count_v<dvec2> == 2), true);
fennec_test_run((component_count_v<dvec3> == 3), true);
fennec_test_run((component_count_v<dvec4> == 4), true);
fennec_test_run((component_count_v<dvec2&> == 2), true);
fennec_test_run((component_count_v<dvec3&> == 3), true);
fennec_test_run((component_count_v<dvec4&> == 4), true);
fennec_test_run((component_count_v<dvec2&&> == 2), true);
fennec_test_run((component_count_v<dvec3&&> == 3), true);
fennec_test_run((component_count_v<dvec4&&> == 4), true);
fennec_test_run((component_count_v<const dvec2&> == 2), true);
fennec_test_run((component_count_v<const dvec3&> == 3), true);
fennec_test_run((component_count_v<const dvec4&> == 4), true);
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("vec2 equivalency operator");
fennec_test_section("vec2 equivalency operator");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run((vec2() == vec2()), true);
fennec_test_run((vec2() != vec2()), false);
fennec_test_run((vec2() == vec2()), true);
fennec_test_run((vec2() != vec2()), false);
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("vec2 constructors");
fennec_test_section("vec2 constructors");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(vec2(), vec2(0.0f, 0.0f));
fennec_test_run(vec2(1.0f), vec2(1.0f, 1.0f));
fennec_test_run(vec2(), vec2(0.0, 0.0));
fennec_test_run(vec2(1.0), vec2(1.0, 1.0));
fennec_test_run(vec2(), vec2(0, 0));
fennec_test_run(vec2(1), vec2(1, 1));
fennec_test_run(vec2(fennec::copy(vec2(1.0f))), vec2(1.0f));
fennec_test_run(vec2(fennec::move(vec2(1.0f))), vec2(1.0f));
fennec_test_run(vec2(), vec2(0.0f, 0.0f));
fennec_test_run(vec2(1.0f), vec2(1.0f, 1.0f));
fennec_test_run(vec2(), vec2(0.0, 0.0));
fennec_test_run(vec2(1.0), vec2(1.0, 1.0));
fennec_test_run(vec2(), vec2(0, 0));
fennec_test_run(vec2(1), vec2(1, 1));
fennec_test_run(vec2(fennec::copy(vec2(1.0f))), vec2(1.0f));
fennec_test_run(vec2(fennec::move(vec2(1.0f))), vec2(1.0f));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("vec2 swizzles");
fennec_test_section("vec2 swizzles");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(vec2(vec2(0, 1).xx), vec2(0, 0));
fennec_test_run(vec2(vec2(0, 1).xy), vec2(0, 1));
fennec_test_run(vec2(vec2(0, 1).yx), vec2(1, 0));
fennec_test_run(vec2(vec2(0, 1).yy), vec2(1, 1));
fennec_test_run(vec2(vec2(0, 1).xx), vec2(0, 0));
fennec_test_run(vec2(vec2(0, 1).xy), vec2(0, 1));
fennec_test_run(vec2(vec2(0, 1).yx), vec2(1, 0));
fennec_test_run(vec2(vec2(0, 1).yy), vec2(1, 1));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("vec3 constructors");
fennec_test_section("vec3 constructors");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(vec3(), vec3(0.0f, 0.0f, 0.0f));
fennec_test_run(vec3(1.0f), vec3(1.0f, 1.0f, 1.0f));
fennec_test_run(vec3(), vec3(0.0, 0.0, 0.0));
fennec_test_run(vec3(1.0), vec3(1.0, 1.0, 1.0));
fennec_test_run(vec3(), vec3(0, 0, 0));
fennec_test_run(vec3(1), vec3(1, 1, 1));
fennec_test_run(vec3(fennec::copy(vec3(1))), vec3(1));
fennec_test_run(vec3(fennec::move(vec3(1))), vec3(1));
fennec_test_run(vec3(), vec3(0.0f, 0.0f, 0.0f));
fennec_test_run(vec3(1.0f), vec3(1.0f, 1.0f, 1.0f));
fennec_test_run(vec3(), vec3(0.0, 0.0, 0.0));
fennec_test_run(vec3(1.0), vec3(1.0, 1.0, 1.0));
fennec_test_run(vec3(), vec3(0, 0, 0));
fennec_test_run(vec3(1), vec3(1, 1, 1));
fennec_test_run(vec3(fennec::copy(vec3(1))), vec3(1));
fennec_test_run(vec3(fennec::move(vec3(1))), vec3(1));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("vec3 swizzles");
fennec_test_section("vec3 swizzles");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(vec3(vec3(0, 1, 2).xxx), vec3(0, 0, 0));
fennec_test_run(vec3(vec3(0, 1, 2).xxy), vec3(0, 0, 1));
fennec_test_run(vec3(vec3(0, 1, 2).xxz), vec3(0, 0, 2));
fennec_test_run(vec3(vec3(0, 1, 2).xxx), vec3(0, 0, 0));
fennec_test_run(vec3(vec3(0, 1, 2).xxy), vec3(0, 0, 1));
fennec_test_run(vec3(vec3(0, 1, 2).xxz), vec3(0, 0, 2));
fennec_test_run(vec3(vec3(0, 1, 2).xyx), vec3(0, 1, 0));
fennec_test_run(vec3(vec3(0, 1, 2).xyy), vec3(0, 1, 1));
fennec_test_run(vec3(vec3(0, 1, 2).xyz), vec3(0, 1, 2));
fennec_test_run(vec3(vec3(0, 1, 2).xyx), vec3(0, 1, 0));
fennec_test_run(vec3(vec3(0, 1, 2).xyy), vec3(0, 1, 1));
fennec_test_run(vec3(vec3(0, 1, 2).xyz), vec3(0, 1, 2));
fennec_test_run(vec3(vec3(0, 1, 2).xzx), vec3(0, 2, 0));
fennec_test_run(vec3(vec3(0, 1, 2).xzy), vec3(0, 2, 1));
fennec_test_run(vec3(vec3(0, 1, 2).xzz), vec3(0, 2, 2));
fennec_test_run(vec3(vec3(0, 1, 2).xzx), vec3(0, 2, 0));
fennec_test_run(vec3(vec3(0, 1, 2).xzy), vec3(0, 2, 1));
fennec_test_run(vec3(vec3(0, 1, 2).xzz), vec3(0, 2, 2));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(vec3(vec3(0, 1, 2).yxx), vec3(1, 0, 0));
fennec_test_run(vec3(vec3(0, 1, 2).yxy), vec3(1, 0, 1));
fennec_test_run(vec3(vec3(0, 1, 2).yxz), vec3(1, 0, 2));
fennec_test_run(vec3(vec3(0, 1, 2).yxx), vec3(1, 0, 0));
fennec_test_run(vec3(vec3(0, 1, 2).yxy), vec3(1, 0, 1));
fennec_test_run(vec3(vec3(0, 1, 2).yxz), vec3(1, 0, 2));
fennec_test_run(vec3(vec3(0, 1, 2).yyx), vec3(1, 1, 0));
fennec_test_run(vec3(vec3(0, 1, 2).yyy), vec3(1, 1, 1));
fennec_test_run(vec3(vec3(0, 1, 2).yyz), vec3(1, 1, 2));
fennec_test_run(vec3(vec3(0, 1, 2).yyx), vec3(1, 1, 0));
fennec_test_run(vec3(vec3(0, 1, 2).yyy), vec3(1, 1, 1));
fennec_test_run(vec3(vec3(0, 1, 2).yyz), vec3(1, 1, 2));
fennec_test_run(vec3(vec3(0, 1, 2).yzx), vec3(1, 2, 0));
fennec_test_run(vec3(vec3(0, 1, 2).yzy), vec3(1, 2, 1));
fennec_test_run(vec3(vec3(0, 1, 2).yzz), vec3(1, 2, 2));
fennec_test_run(vec3(vec3(0, 1, 2).yzx), vec3(1, 2, 0));
fennec_test_run(vec3(vec3(0, 1, 2).yzy), vec3(1, 2, 1));
fennec_test_run(vec3(vec3(0, 1, 2).yzz), vec3(1, 2, 2));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(vec3(vec3(0, 1, 2).zxx), vec3(2, 0, 0));
fennec_test_run(vec3(vec3(0, 1, 2).zxy), vec3(2, 0, 1));
fennec_test_run(vec3(vec3(0, 1, 2).zxz), vec3(2, 0, 2));
fennec_test_run(vec3(vec3(0, 1, 2).zxx), vec3(2, 0, 0));
fennec_test_run(vec3(vec3(0, 1, 2).zxy), vec3(2, 0, 1));
fennec_test_run(vec3(vec3(0, 1, 2).zxz), vec3(2, 0, 2));
fennec_test_run(vec3(vec3(0, 1, 2).zyx), vec3(2, 1, 0));
fennec_test_run(vec3(vec3(0, 1, 2).zyy), vec3(2, 1, 1));
fennec_test_run(vec3(vec3(0, 1, 2).zyz), vec3(2, 1, 2));
fennec_test_run(vec3(vec3(0, 1, 2).zyx), vec3(2, 1, 0));
fennec_test_run(vec3(vec3(0, 1, 2).zyy), vec3(2, 1, 1));
fennec_test_run(vec3(vec3(0, 1, 2).zyz), vec3(2, 1, 2));
fennec_test_run(vec3(vec3(0, 1, 2).zzx), vec3(2, 2, 0));
fennec_test_run(vec3(vec3(0, 1, 2).zzy), vec3(2, 2, 1));
fennec_test_run(vec3(vec3(0, 1, 2).zzz), vec3(2, 2, 2));
fennec_test_run(vec3(vec3(0, 1, 2).zzx), vec3(2, 2, 0));
fennec_test_run(vec3(vec3(0, 1, 2).zzy), vec3(2, 2, 1));
fennec_test_run(vec3(vec3(0, 1, 2).zzz), vec3(2, 2, 2));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("scalar-vector arithmetic operations");
fennec_test_section("scalar-vector arithmetic operations");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(2.0 + vec2(1, 2), vec2(3, 4));
fennec_test_run(2.0 + vec3(1, 2, 3), vec3(3, 4, 5));
fennec_test_run(2.0 + vec4(1, 2, 3, 4), vec4(3, 4, 5, 6));
fennec_test_run(2.0 + vec2(1, 2), vec2(3, 4));
fennec_test_run(2.0 + vec3(1, 2, 3), vec3(3, 4, 5));
fennec_test_run(2.0 + vec4(1, 2, 3, 4), vec4(3, 4, 5, 6));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_run(2.0 - vec2(1, 2), vec2(1, 0));
fennec_test_run(2.0 - vec3(1, 2, 3), vec3(1, 0, -1));
fennec_test_run(2.0 - vec4(1, 2, 3, 4), vec4(1, 0, -1, -2));
fennec_test_run(2.0 - vec2(1, 2), vec2(1, 0));
fennec_test_run(2.0 - vec3(1, 2, 3), vec3(1, 0, -1));
fennec_test_run(2.0 - vec4(1, 2, 3, 4), vec4(1, 0, -1, -2));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_run(2.0 * vec2(1, 2), vec2(2, 4));
fennec_test_run(2.0 * vec3(1, 2, 3), vec3(2, 4, 6));
fennec_test_run(2.0 * vec4(1, 2, 3, 4), vec4(2, 4, 6, 8));
fennec_test_run(2.0 * vec2(1, 2), vec2(2, 4));
fennec_test_run(2.0 * vec3(1, 2, 3), vec3(2, 4, 6));
fennec_test_run(2.0 * vec4(1, 2, 3, 4), vec4(2, 4, 6, 8));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_run(2.0 / vec2(1, 2), vec2(2.0, 1.0));
fennec_test_run(2.0 / vec3(1, 2, 4), vec3(2.0, 1.0, 0.5));
fennec_test_run(2.0 / vec4(1, 2, 4, 8), vec4(2.0, 1.0, 0.5, 0.25));
fennec_test_run(2.0 / vec2(1, 2), vec2(2.0, 1.0));
fennec_test_run(2.0 / vec3(1, 2, 4), vec3(2.0, 1.0, 0.5));
fennec_test_run(2.0 / vec4(1, 2, 4, 8), vec4(2.0, 1.0, 0.5, 0.25));
fennec_test_run(2 % ivec2(1, 2), ivec2(0, 0));
fennec_test_run(2 % ivec3(1, 2, 3), ivec3(0, 0, 2));
fennec_test_run(2 % ivec4(1, 2, 3, 4), ivec4(0, 0, 2, 2));
fennec_test_run(2 % ivec2(1, 2), ivec2(0, 0));
fennec_test_run(2 % ivec3(1, 2, 3), ivec3(0, 0, 2));
fennec_test_run(2 % ivec4(1, 2, 3, 4), ivec4(0, 0, 2, 2));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("vector-scalar arithmetic operations");
fennec_test_section("vector-scalar arithmetic operations");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(vec2(1, 2) + 2.0, vec2(3, 4));
fennec_test_run(vec3(1, 2, 3) + 2.0, vec3(3, 4, 5));
fennec_test_run(vec4(1, 2, 3, 4) + 2.0, vec4(3, 4, 5, 6));
fennec_test_run(vec2(1, 2) + 2.0, vec2(3, 4));
fennec_test_run(vec3(1, 2, 3) + 2.0, vec3(3, 4, 5));
fennec_test_run(vec4(1, 2, 3, 4) + 2.0, vec4(3, 4, 5, 6));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_run(vec2(1, 2) - 2.0, vec2(-1, 0));
fennec_test_run(vec3(1, 2, 3) - 2.0, vec3(-1, 0, 1));
fennec_test_run(vec4(1, 2, 3, 4) - 2.0, vec4(-1, 0, 1, 2));
fennec_test_run(vec2(1, 2) - 2.0, vec2(-1, 0));
fennec_test_run(vec3(1, 2, 3) - 2.0, vec3(-1, 0, 1));
fennec_test_run(vec4(1, 2, 3, 4) - 2.0, vec4(-1, 0, 1, 2));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_run(vec2(1, 2) * 2.0, vec2(2, 4));
fennec_test_run(vec3(1, 2, 3) * 2.0, vec3(2, 4, 6));
fennec_test_run(vec4(1, 2, 3, 4) * 2.0, vec4(2, 4, 6, 8));
fennec_test_run(vec2(1, 2) * 2.0, vec2(2, 4));
fennec_test_run(vec3(1, 2, 3) * 2.0, vec3(2, 4, 6));
fennec_test_run(vec4(1, 2, 3, 4) * 2.0, vec4(2, 4, 6, 8));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_run(vec2(1, 2) / 2.0, vec2(0.5, 1.0));
fennec_test_run(vec3(1, 2, 4) / 2.0, vec3(0.5, 1.0, 2.0));
fennec_test_run(vec4(1, 2, 4, 8) / 2.0, vec4(0.5, 1.0, 2.0, 4.0));
fennec_test_run(vec2(1, 2) / 2.0, vec2(0.5, 1.0));
fennec_test_run(vec3(1, 2, 4) / 2.0, vec3(0.5, 1.0, 2.0));
fennec_test_run(vec4(1, 2, 4, 8) / 2.0, vec4(0.5, 1.0, 2.0, 4.0));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_run(ivec2(1, 2) % 2, ivec2(1, 0));
fennec_test_run(ivec3(1, 2, 3) % 2, ivec3(1, 0, 1));
fennec_test_run(ivec4(1, 2, 3, 4) % 2, ivec4(1, 0, 1, 0));
fennec_test_run(ivec2(1, 2) % 2, ivec2(1, 0));
fennec_test_run(ivec3(1, 2, 3) % 2, ivec3(1, 0, 1));
fennec_test_run(ivec4(1, 2, 3, 4) % 2, ivec4(1, 0, 1, 0));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("vector-scalar arithmetic assignment operations");
fennec_test_section("vector-scalar arithmetic assignment operations");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(([]() -> vec2 { vec2 v{ 1, 2 }; return v += 2.0; }()), vec2(3, 4));
fennec_test_run(([]() -> vec3 { vec3 v{ 1, 2, 3 }; return v += 2.0; }()), vec3(3, 4, 5));
fennec_test_run(([]() -> vec4 { vec4 v{ 1, 2, 3, 4 }; return v += 2.0; }()), vec4(3, 4, 5, 6));
fennec_test_run(([]() -> vec2 { vec2 v{ 1, 2 }; return v += 2.0; }()), vec2(3, 4));
fennec_test_run(([]() -> vec3 { vec3 v{ 1, 2, 3 }; return v += 2.0; }()), vec3(3, 4, 5));
fennec_test_run(([]() -> vec4 { vec4 v{ 1, 2, 3, 4 }; return v += 2.0; }()), vec4(3, 4, 5, 6));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_run(([]() -> vec2 { vec2 v{ 1, 2 }; return v -= 2.0; }()), vec2(-1, 0));
fennec_test_run(([]() -> vec3 { vec3 v{ 1, 2, 3 }; return v -= 2.0; }()), vec3(-1, 0, 1));
fennec_test_run(([]() -> vec4 { vec4 v{ 1, 2, 3, 4 }; return v -= 2.0; }()), vec4(-1, 0, 1, 2));
fennec_test_run(([]() -> vec2 { vec2 v{ 1, 2 }; return v -= 2.0; }()), vec2(-1, 0));
fennec_test_run(([]() -> vec3 { vec3 v{ 1, 2, 3 }; return v -= 2.0; }()), vec3(-1, 0, 1));
fennec_test_run(([]() -> vec4 { vec4 v{ 1, 2, 3, 4 }; return v -= 2.0; }()), vec4(-1, 0, 1, 2));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_run(([]() -> vec2 { vec2 v{ 1, 2 }; return v *= 2.0; }()), vec2(2, 4));
fennec_test_run(([]() -> vec3 { vec3 v{ 1, 2, 3 }; return v *= 2.0; }()), vec3(2, 4, 6));
fennec_test_run(([]() -> vec4 { vec4 v{ 1, 2, 3, 4 }; return v *= 2.0; }()), vec4(2, 4, 6, 8));
fennec_test_run(([]() -> vec2 { vec2 v{ 1, 2 }; return v *= 2.0; }()), vec2(2, 4));
fennec_test_run(([]() -> vec3 { vec3 v{ 1, 2, 3 }; return v *= 2.0; }()), vec3(2, 4, 6));
fennec_test_run(([]() -> vec4 { vec4 v{ 1, 2, 3, 4 }; return v *= 2.0; }()), vec4(2, 4, 6, 8));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_run(([]() -> vec2 { vec2 v{ 1, 2 }; return v /= 2.0; }()), vec2(0.5, 1.0));
fennec_test_run(([]() -> vec3 { vec3 v{ 1, 2, 3 }; return v /= 2.0; }()), vec3(0.5, 1.0, 1.5));
fennec_test_run(([]() -> vec4 { vec4 v{ 1, 2, 3, 4 }; return v /= 2.0; }()), vec4(0.5, 1.0, 1.5, 2.0));
fennec_test_run(([]() -> vec2 { vec2 v{ 1, 2 }; return v /= 2.0; }()), vec2(0.5, 1.0));
fennec_test_run(([]() -> vec3 { vec3 v{ 1, 2, 3 }; return v /= 2.0; }()), vec3(0.5, 1.0, 1.5));
fennec_test_run(([]() -> vec4 { vec4 v{ 1, 2, 3, 4 }; return v /= 2.0; }()), vec4(0.5, 1.0, 1.5, 2.0));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_run(([]() -> ivec2 { ivec2 v{ 1, 2 }; return v %= 2; }()), ivec2(1, 0));
fennec_test_run(([]() -> ivec3 { ivec3 v{ 1, 2, 3 }; return v %= 2; }()), ivec3(1, 0, 1));
fennec_test_run(([]() -> ivec4 { ivec4 v{ 1, 2, 3, 4 }; return v %= 2; }()), ivec4(1, 0, 1, 0));
fennec_test_run(([]() -> ivec2 { ivec2 v{ 1, 2 }; return v %= 2; }()), ivec2(1, 0));
fennec_test_run(([]() -> ivec3 { ivec3 v{ 1, 2, 3 }; return v %= 2; }()), ivec3(1, 0, 1));
fennec_test_run(([]() -> ivec4 { ivec4 v{ 1, 2, 3, 4 }; return v %= 2; }()), ivec4(1, 0, 1, 0));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("vector-vector arithmetic operations");
fennec_test_section("vector-vector arithmetic operations");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(vec2(1, 2) + vec2(1, 2), vec2(2, 4));
fennec_test_run(vec3(1, 2, 3) + vec3(1, 2, 3), vec3(2, 4, 6));
fennec_test_run(vec4(1, 2, 3, 4) + vec4(1, 2, 3, 4), vec4(2, 4, 6, 8));
fennec_test_run(vec2(1, 2) + vec2(1, 2), vec2(2, 4));
fennec_test_run(vec3(1, 2, 3) + vec3(1, 2, 3), vec3(2, 4, 6));
fennec_test_run(vec4(1, 2, 3, 4) + vec4(1, 2, 3, 4), vec4(2, 4, 6, 8));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(vec2(1, 2) - vec2(1, 2), vec2(0, 0));
fennec_test_run(vec3(1, 2, 3) - vec3(1, 2, 3), vec3(0, 0, 0));
fennec_test_run(vec4(1, 2, 3, 4) - vec4(1, 2, 3, 4), vec4(0, 0, 0, 0));
fennec_test_run(vec2(1, 2) - vec2(1, 2), vec2(0, 0));
fennec_test_run(vec3(1, 2, 3) - vec3(1, 2, 3), vec3(0, 0, 0));
fennec_test_run(vec4(1, 2, 3, 4) - vec4(1, 2, 3, 4), vec4(0, 0, 0, 0));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(vec2(1, 2) * vec2(1, 2), vec2(1, 4));
fennec_test_run(vec3(1, 2, 3) * vec3(1, 2, 3), vec3(1, 4, 9));
fennec_test_run(vec4(1, 2, 3, 4) * vec4(1, 2, 3, 4), vec4(1, 4, 9, 16));
fennec_test_run(vec2(1, 2) * vec2(1, 2), vec2(1, 4));
fennec_test_run(vec3(1, 2, 3) * vec3(1, 2, 3), vec3(1, 4, 9));
fennec_test_run(vec4(1, 2, 3, 4) * vec4(1, 2, 3, 4), vec4(1, 4, 9, 16));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(vec2(1, 2) / vec2(1, 2), vec2(1, 1));
fennec_test_run(vec3(1, 2, 4) / vec3(1, 2, 4), vec3(1, 1, 1));
fennec_test_run(vec4(1, 2, 4, 8) / vec4(1, 2, 4, 8), vec4(1, 1, 1, 1));
fennec_test_run(vec2(1, 2) / vec2(1, 2), vec2(1, 1));
fennec_test_run(vec3(1, 2, 4) / vec3(1, 2, 4), vec3(1, 1, 1));
fennec_test_run(vec4(1, 2, 4, 8) / vec4(1, 2, 4, 8), vec4(1, 1, 1, 1));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(ivec2(1, 2) % ivec2(1, 2), ivec2(0, 0));
fennec_test_run(ivec3(1, 2, 4) % ivec3(1, 2, 4), ivec3(0, 0, 0));
fennec_test_run(ivec4(1, 2, 4, 8) % ivec4(1, 2, 4, 8), ivec4(0, 0, 0, 0));
fennec_test_run(ivec2(1, 2) % ivec2(1, 2), ivec2(0, 0));
fennec_test_run(ivec3(1, 2, 4) % ivec3(1, 2, 4), ivec3(0, 0, 0));
fennec_test_run(ivec4(1, 2, 4, 8) % ivec4(1, 2, 4, 8), ivec4(0, 0, 0, 0));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("vector-vector arithmetic assignment operations");
fennec_test_section("vector-vector arithmetic assignment operations");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(([]() -> vec2 { vec2 v(1, 2); return v += vec2(1, 2); }()), vec2(2, 4));
fennec_test_run(([]() -> vec3 { vec3 v(1, 2, 3); return v += vec3(1, 2, 3); }()), vec3(2, 4, 6));
fennec_test_run(([]() -> vec4 { vec4 v(1, 2, 3, 4); return v += vec4(1, 2, 3, 4); }()), vec4(2, 4, 6, 8));
fennec_test_run(([]() -> vec2 { vec2 v(1, 2); return v += vec2(1, 2); }()), vec2(2, 4));
fennec_test_run(([]() -> vec3 { vec3 v(1, 2, 3); return v += vec3(1, 2, 3); }()), vec3(2, 4, 6));
fennec_test_run(([]() -> vec4 { vec4 v(1, 2, 3, 4); return v += vec4(1, 2, 3, 4); }()), vec4(2, 4, 6, 8));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(([]() -> vec2 { vec2 v(1, 2); return v -= vec2(1, 2); }()), vec2(0, 0));
fennec_test_run(([]() -> vec3 { vec3 v(1, 2, 3); return v -= vec3(1, 2, 3); }()), vec3(0, 0, 0));
fennec_test_run(([]() -> vec4 { vec4 v(1, 2, 3, 4); return v -= vec4(1, 2, 3, 4); }()), vec4(0, 0, 0, 0));
fennec_test_run(([]() -> vec2 { vec2 v(1, 2); return v -= vec2(1, 2); }()), vec2(0, 0));
fennec_test_run(([]() -> vec3 { vec3 v(1, 2, 3); return v -= vec3(1, 2, 3); }()), vec3(0, 0, 0));
fennec_test_run(([]() -> vec4 { vec4 v(1, 2, 3, 4); return v -= vec4(1, 2, 3, 4); }()), vec4(0, 0, 0, 0));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(([]() -> vec2 { vec2 v(1, 2); return v *= vec2(1, 2); }()), vec2(1, 4));
fennec_test_run(([]() -> vec3 { vec3 v(1, 2, 3); return v *= vec3(1, 2, 3); }()), vec3(1, 4, 9));
fennec_test_run(([]() -> vec4 { vec4 v(1, 2, 3, 4); return v *= vec4(1, 2, 3, 4); }()), vec4(1, 4, 9, 16));
fennec_test_run(([]() -> vec2 { vec2 v(1, 2); return v *= vec2(1, 2); }()), vec2(1, 4));
fennec_test_run(([]() -> vec3 { vec3 v(1, 2, 3); return v *= vec3(1, 2, 3); }()), vec3(1, 4, 9));
fennec_test_run(([]() -> vec4 { vec4 v(1, 2, 3, 4); return v *= vec4(1, 2, 3, 4); }()), vec4(1, 4, 9, 16));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(([]() -> vec2 { vec2 v(1, 2); return v /= vec2(1, 2); }()), vec2(1, 1));
fennec_test_run(([]() -> vec3 { vec3 v(1, 2, 4); return v /= vec3(1, 2, 4); }()), vec3(1, 1, 1));
fennec_test_run(([]() -> vec4 { vec4 v(1, 2, 4, 8); return v /= vec4(1, 2, 4, 8); }()), vec4(1, 1, 1, 1));
fennec_test_run(([]() -> vec2 { vec2 v(1, 2); return v /= vec2(1, 2); }()), vec2(1, 1));
fennec_test_run(([]() -> vec3 { vec3 v(1, 2, 4); return v /= vec3(1, 2, 4); }()), vec3(1, 1, 1));
fennec_test_run(([]() -> vec4 { vec4 v(1, 2, 4, 8); return v /= vec4(1, 2, 4, 8); }()), vec4(1, 1, 1, 1));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(([]() -> ivec2 { ivec2 v(1, 2); return v %= ivec2(1, 2); }()), ivec2(0, 0));
fennec_test_run(([]() -> ivec3 { ivec3 v(1, 2, 4); return v %= ivec3(1, 2, 4); }()), ivec3(0, 0, 0));
fennec_test_run(([]() -> ivec4 { ivec4 v(1, 2, 4, 8); return v %= ivec4(1, 2, 4, 8); }()), ivec4(0, 0, 0, 0));
fennec_test_run(([]() -> ivec2 { ivec2 v(1, 2); return v %= ivec2(1, 2); }()), ivec2(0, 0));
fennec_test_run(([]() -> ivec3 { ivec3 v(1, 2, 4); return v %= ivec3(1, 2, 4); }()), ivec3(0, 0, 0));
fennec_test_run(([]() -> ivec4 { ivec4 v(1, 2, 4, 8); return v %= ivec4(1, 2, 4, 8); }()), ivec4(0, 0, 0, 0));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("boolean operations");
fennec_test_section("boolean operations");
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(not bvec2(false, false), bvec2(true, true));
fennec_test_run(not bvec3(false, false, true), bvec3(true, true, false));
fennec_test_run(not bvec4(false, false, true, true), bvec4(true, true, false, false));
fennec_test_run(not bvec2(false, false), bvec2(true, true));
fennec_test_run(not bvec3(false, false, true), bvec3(true, true, false));
fennec_test_run(not bvec4(false, false, true, true), bvec4(true, true, false, false));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(bvec2(false, false) && true, bvec2(false, false));
fennec_test_run(bvec3(false, false, true) && true, bvec3(false, false, true));
fennec_test_run(bvec4(false, false, true, true) && true, bvec4(false, false, true, true));
fennec_test_run(bvec2(false, false) && true, bvec2(false, false));
fennec_test_run(bvec3(false, false, true) && true, bvec3(false, false, true));
fennec_test_run(bvec4(false, false, true, true) && true, bvec4(false, false, true, true));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(bvec2(false, false) && bvec2(false, true), bvec2(false, false));
fennec_test_run(bvec3(false, false, true) && bvec3(false, true, false), bvec3(false, false, false));
fennec_test_run(bvec4(false, false, true, true) && bvec4(false, true, false, true), bvec4(false, false, false, true));
fennec_test_run(bvec2(false, false) && bvec2(false, true), bvec2(false, false));
fennec_test_run(bvec3(false, false, true) && bvec3(false, true, false), bvec3(false, false, false));
fennec_test_run(bvec4(false, false, true, true) && bvec4(false, true, false, true), bvec4(false, false, false, true));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_run(bvec2(false, false) || true, bvec2(true, true));
fennec_test_run(bvec3(false, false, true) || true, bvec3(true, true, true));
fennec_test_run(bvec4(false, false, true, true) || true, bvec4(true, true, true, true));
fennec_test_run(bvec2(false, false) || true, bvec2(true, true));
fennec_test_run(bvec3(false, false, true) || true, bvec3(true, true, true));
fennec_test_run(bvec4(false, false, true, true) || true, bvec4(true, true, true, true));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(bvec2(false, false) || bvec2(false, true), bvec2(false, true));
fennec_test_run(bvec3(false, false, true) || bvec3(false, true, false), bvec3(false, true, true));
fennec_test_run(bvec4(false, false, true, true) || bvec4(false, true, false, true), bvec4(false, true, true, true));
fennec_test_run(bvec2(false, false) || bvec2(false, true), bvec2(false, true));
fennec_test_run(bvec3(false, false, true) || bvec3(false, true, false), bvec3(false, true, true));
fennec_test_run(bvec4(false, false, true, true) || bvec4(false, true, false, true), bvec4(false, true, true, true));
fennec_test_spacer(2);
fennec_test_spacer(2);
fennec_test_section("bitwise operations");
fennec_test_section("bitwise operations");
fennec_test_spacer(1); // bitwise and ==============================================================================
fennec_test_spacer(1); // bitwise and ==============================================================================
fennec_test_run(0b0101 & ivec2(0b0001, 0b0010), ivec2(0b0001, 0b0000));
fennec_test_run(0b0101 & ivec3(0b0001, 0b0010, 0b0011), ivec3(0b0001, 0b0000, 0b0001));
fennec_test_run(0b0101 & ivec4(0b0001, 0b0010, 0b0011, 0b0100), ivec4(0b0001, 0b0000, 0b0001, 0b0100));
fennec_test_run(0b0101 & ivec2(0b0001, 0b0010), ivec2(0b0001, 0b0000));
fennec_test_run(0b0101 & ivec3(0b0001, 0b0010, 0b0011), ivec3(0b0001, 0b0000, 0b0001));
fennec_test_run(0b0101 & ivec4(0b0001, 0b0010, 0b0011, 0b0100), ivec4(0b0001, 0b0000, 0b0001, 0b0100));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(ivec2(0b0001, 0b0010) & 0b0101, ivec2(0b0001, 0b0000));
fennec_test_run(ivec3(0b0001, 0b0010, 0b0011) & 0b0101, ivec3(0b0001, 0b0000, 0b0001));
fennec_test_run(ivec4(0b0001, 0b0010, 0b0011, 0b0100) & 0b0101, ivec4(0b0001, 0b0000, 0b0001, 0b0100));
fennec_test_run(ivec2(0b0001, 0b0010) & 0b0101, ivec2(0b0001, 0b0000));
fennec_test_run(ivec3(0b0001, 0b0010, 0b0011) & 0b0101, ivec3(0b0001, 0b0000, 0b0001));
fennec_test_run(ivec4(0b0001, 0b0010, 0b0011, 0b0100) & 0b0101, ivec4(0b0001, 0b0000, 0b0001, 0b0100));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(([]() -> ivec2 { ivec2 v(0b0001, 0b0010); return v &= 0b0101; }()), ivec2(0b0001, 0b0000));
fennec_test_run(([]() -> ivec3 { ivec3 v(0b0001, 0b0010, 0b0011); return v &= 0b0101; }()), ivec3(0b0001, 0b0000, 0b0001));
fennec_test_run(([]() -> ivec4 { ivec4 v(0b0001, 0b0010, 0b0011, 0b0100); return v &= 0b0101; }()), ivec4(0b0001, 0b0000, 0b0001, 0b0100));
fennec_test_run(([]() -> ivec2 { ivec2 v(0b0001, 0b0010); return v &= 0b0101; }()), ivec2(0b0001, 0b0000));
fennec_test_run(([]() -> ivec3 { ivec3 v(0b0001, 0b0010, 0b0011); return v &= 0b0101; }()), ivec3(0b0001, 0b0000, 0b0001));
fennec_test_run(([]() -> ivec4 { ivec4 v(0b0001, 0b0010, 0b0011, 0b0100); return v &= 0b0101; }()), ivec4(0b0001, 0b0000, 0b0001, 0b0100));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(ivec2(0b0001, 0b0010) & ivec2(0b1000, 0b0100), ivec2(0b0000));
fennec_test_run(ivec3(0b0001, 0b0010, 0b0011) & ivec3(0b1000, 0b0100, 0b1100), ivec3(0b0000));
fennec_test_run(ivec4(0b0001, 0b0010, 0b0011, 0b0100) & ivec4(0b1000, 0b0100, 0b1100, 0b0010), ivec4(0b0000));
fennec_test_run(ivec2(0b0001, 0b0010) & ivec2(0b1000, 0b0100), ivec2(0b0000));
fennec_test_run(ivec3(0b0001, 0b0010, 0b0011) & ivec3(0b1000, 0b0100, 0b1100), ivec3(0b0000));
fennec_test_run(ivec4(0b0001, 0b0010, 0b0011, 0b0100) & ivec4(0b1000, 0b0100, 0b1100, 0b0010), ivec4(0b0000));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(([]() -> ivec2 { ivec2 v(0b0001, 0b0010); return v &= ivec2(0b1000, 0b0100); }()), ivec2(0b0000));
fennec_test_run(([]() -> ivec3 { ivec3 v(0b0001, 0b0010, 0b0011); return v &= ivec3(0b1000, 0b0100, 0b1100); }()), ivec3(0b0000));
fennec_test_run(([]() -> ivec4 { ivec4 v(0b0001, 0b0010, 0b0011, 0b0100); return v &= ivec4(0b1000, 0b0100, 0b1100, 0b0010); }()), ivec4(0b0000));
fennec_test_run(([]() -> ivec2 { ivec2 v(0b0001, 0b0010); return v &= ivec2(0b1000, 0b0100); }()), ivec2(0b0000));
fennec_test_run(([]() -> ivec3 { ivec3 v(0b0001, 0b0010, 0b0011); return v &= ivec3(0b1000, 0b0100, 0b1100); }()), ivec3(0b0000));
fennec_test_run(([]() -> ivec4 { ivec4 v(0b0001, 0b0010, 0b0011, 0b0100); return v &= ivec4(0b1000, 0b0100, 0b1100, 0b0010); }()), ivec4(0b0000));
fennec_test_spacer(2); // bitwise or ===============================================================================
fennec_test_spacer(2); // bitwise or ===============================================================================
fennec_test_run(0b0101 | ivec2(0b0001, 0b0010), ivec2(0b0101, 0b0111));
fennec_test_run(0b0101 | ivec3(0b0001, 0b0010, 0b0011), ivec3(0b0101, 0b0111, 0b0111));
fennec_test_run(0b0101 | ivec4(0b0001, 0b0010, 0b0011, 0b0100), ivec4(0b0101, 0b0111, 0b0111, 0b0101));
fennec_test_run(0b0101 | ivec2(0b0001, 0b0010), ivec2(0b0101, 0b0111));
fennec_test_run(0b0101 | ivec3(0b0001, 0b0010, 0b0011), ivec3(0b0101, 0b0111, 0b0111));
fennec_test_run(0b0101 | ivec4(0b0001, 0b0010, 0b0011, 0b0100), ivec4(0b0101, 0b0111, 0b0111, 0b0101));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(ivec2(0b0001, 0b0010) | 0b0101, ivec2(0b0101, 0b0111));
fennec_test_run(ivec3(0b0001, 0b0010, 0b0011) | 0b0101, ivec3(0b0101, 0b0111, 0b0111));
fennec_test_run(ivec4(0b0001, 0b0010, 0b0011, 0b0100) | 0b0101, ivec4(0b0101, 0b0111, 0b0111, 0b0101));
fennec_test_run(ivec2(0b0001, 0b0010) | 0b0101, ivec2(0b0101, 0b0111));
fennec_test_run(ivec3(0b0001, 0b0010, 0b0011) | 0b0101, ivec3(0b0101, 0b0111, 0b0111));
fennec_test_run(ivec4(0b0001, 0b0010, 0b0011, 0b0100) | 0b0101, ivec4(0b0101, 0b0111, 0b0111, 0b0101));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(([]() -> ivec2 { ivec2 v(0b0001, 0b0010); return v |= 0b0101; }()), ivec2(0b0101, 0b0111));
fennec_test_run(([]() -> ivec3 { ivec3 v(0b0001, 0b0010, 0b0011); return v |= 0b0101; }()), ivec3(0b0101, 0b0111, 0b0111));
fennec_test_run(([]() -> ivec4 { ivec4 v(0b0001, 0b0010, 0b0011, 0b0100); return v |= 0b0101; }()), ivec4(0b0101, 0b0111, 0b0111, 0b0101));
fennec_test_run(([]() -> ivec2 { ivec2 v(0b0001, 0b0010); return v |= 0b0101; }()), ivec2(0b0101, 0b0111));
fennec_test_run(([]() -> ivec3 { ivec3 v(0b0001, 0b0010, 0b0011); return v |= 0b0101; }()), ivec3(0b0101, 0b0111, 0b0111));
fennec_test_run(([]() -> ivec4 { ivec4 v(0b0001, 0b0010, 0b0011, 0b0100); return v |= 0b0101; }()), ivec4(0b0101, 0b0111, 0b0111, 0b0101));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(ivec2(0b0001, 0b0010) | ivec2(0b1000, 0b0100), ivec2(0b1001, 0b0110));
fennec_test_run(ivec3(0b0001, 0b0010, 0b0011) | ivec3(0b1000, 0b0100, 0b1100), ivec3(0b1001, 0b0110, 0b1111));
fennec_test_run(ivec4(0b0001, 0b0010, 0b0011, 0b0100) | ivec4(0b1000, 0b0100, 0b1100, 0b0010), ivec4(0b1001, 0b0110, 0b1111, 0b0110));
fennec_test_run(ivec2(0b0001, 0b0010) | ivec2(0b1000, 0b0100), ivec2(0b1001, 0b0110));
fennec_test_run(ivec3(0b0001, 0b0010, 0b0011) | ivec3(0b1000, 0b0100, 0b1100), ivec3(0b1001, 0b0110, 0b1111));
fennec_test_run(ivec4(0b0001, 0b0010, 0b0011, 0b0100) | ivec4(0b1000, 0b0100, 0b1100, 0b0010), ivec4(0b1001, 0b0110, 0b1111, 0b0110));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(([]() -> ivec2 { ivec2 v(0b0001, 0b0010); return v |= ivec2(0b1000, 0b0100); }()), ivec2(0b1001, 0b0110));
fennec_test_run(([]() -> ivec3 { ivec3 v(0b0001, 0b0010, 0b0011); return v |= ivec3(0b1000, 0b0100, 0b1100); }()), ivec3(0b1001, 0b0110, 0b1111));
fennec_test_run(([]() -> ivec4 { ivec4 v(0b0001, 0b0010, 0b0011, 0b0100); return v |= ivec4(0b1000, 0b0100, 0b1100, 0b0010); }()), ivec4(0b1001, 0b0110, 0b1111, 0b0110));
fennec_test_run(([]() -> ivec2 { ivec2 v(0b0001, 0b0010); return v |= ivec2(0b1000, 0b0100); }()), ivec2(0b1001, 0b0110));
fennec_test_run(([]() -> ivec3 { ivec3 v(0b0001, 0b0010, 0b0011); return v |= ivec3(0b1000, 0b0100, 0b1100); }()), ivec3(0b1001, 0b0110, 0b1111));
fennec_test_run(([]() -> ivec4 { ivec4 v(0b0001, 0b0010, 0b0011, 0b0100); return v |= ivec4(0b1000, 0b0100, 0b1100, 0b0010); }()), ivec4(0b1001, 0b0110, 0b1111, 0b0110));
fennec_test_spacer(2); // bitwise xor ==============================================================================
fennec_test_spacer(2); // bitwise xor ==============================================================================
fennec_test_run(0b0101 ^ ivec2(0b0001, 0b0010), ivec2(0b0100, 0b0111));
fennec_test_run(0b0101 ^ ivec3(0b0001, 0b0010, 0b0011), ivec3(0b0100, 0b0111, 0b0110));
fennec_test_run(0b0101 ^ ivec4(0b0001, 0b0010, 0b0011, 0b0100), ivec4(0b0100, 0b0111, 0b0110, 0b0001));
fennec_test_run(0b0101 ^ ivec2(0b0001, 0b0010), ivec2(0b0100, 0b0111));
fennec_test_run(0b0101 ^ ivec3(0b0001, 0b0010, 0b0011), ivec3(0b0100, 0b0111, 0b0110));
fennec_test_run(0b0101 ^ ivec4(0b0001, 0b0010, 0b0011, 0b0100), ivec4(0b0100, 0b0111, 0b0110, 0b0001));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(ivec2(0b0001, 0b0010) ^ 0b0101, ivec2(0b0100, 0b0111));
fennec_test_run(ivec3(0b0001, 0b0010, 0b0011) ^ 0b0101, ivec3(0b0100, 0b0111, 0b0110));
fennec_test_run(ivec4(0b0001, 0b0010, 0b0011, 0b0100) ^ 0b0101, ivec4(0b0100, 0b0111, 0b0110, 0b0001));
fennec_test_run(ivec2(0b0001, 0b0010) ^ 0b0101, ivec2(0b0100, 0b0111));
fennec_test_run(ivec3(0b0001, 0b0010, 0b0011) ^ 0b0101, ivec3(0b0100, 0b0111, 0b0110));
fennec_test_run(ivec4(0b0001, 0b0010, 0b0011, 0b0100) ^ 0b0101, ivec4(0b0100, 0b0111, 0b0110, 0b0001));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(([]() -> ivec2 { ivec2 v(0b0001, 0b0010); return v ^= 0b0101; }()), ivec2(0b0100, 0b0111));
fennec_test_run(([]() -> ivec3 { ivec3 v(0b0001, 0b0010, 0b0011); return v ^= 0b0101; }()), ivec3(0b0100, 0b0111, 0b0110));
fennec_test_run(([]() -> ivec4 { ivec4 v(0b0001, 0b0010, 0b0011, 0b0100); return v ^= 0b0101; }()), ivec4(0b0100, 0b0111, 0b0110, 0b0001));
fennec_test_run(([]() -> ivec2 { ivec2 v(0b0001, 0b0010); return v ^= 0b0101; }()), ivec2(0b0100, 0b0111));
fennec_test_run(([]() -> ivec3 { ivec3 v(0b0001, 0b0010, 0b0011); return v ^= 0b0101; }()), ivec3(0b0100, 0b0111, 0b0110));
fennec_test_run(([]() -> ivec4 { ivec4 v(0b0001, 0b0010, 0b0011, 0b0100); return v ^= 0b0101; }()), ivec4(0b0100, 0b0111, 0b0110, 0b0001));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(ivec2(0b0001, 0b0010) ^ ivec2(0b1000, 0b0100), ivec2(0b1001, 0b0110));
fennec_test_run(ivec3(0b0001, 0b0010, 0b0011) ^ ivec3(0b1000, 0b0100, 0b1100), ivec3(0b1001, 0b0110, 0b1111));
fennec_test_run(ivec4(0b0001, 0b0010, 0b0011, 0b0100) ^ ivec4(0b1000, 0b0100, 0b1100, 0b0010), ivec4(0b1001, 0b0110, 0b1111, 0b0110));
fennec_test_run(ivec2(0b0001, 0b0010) ^ ivec2(0b1000, 0b0100), ivec2(0b1001, 0b0110));
fennec_test_run(ivec3(0b0001, 0b0010, 0b0011) ^ ivec3(0b1000, 0b0100, 0b1100), ivec3(0b1001, 0b0110, 0b1111));
fennec_test_run(ivec4(0b0001, 0b0010, 0b0011, 0b0100) ^ ivec4(0b1000, 0b0100, 0b1100, 0b0010), ivec4(0b1001, 0b0110, 0b1111, 0b0110));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(([]() -> ivec2 { ivec2 v(0b0001, 0b0010); return v ^= ivec2(0b1000, 0b0100); }()), ivec2(0b1001, 0b0110));
fennec_test_run(([]() -> ivec3 { ivec3 v(0b0001, 0b0010, 0b0011); return v ^= ivec3(0b1000, 0b0100, 0b1100); }()), ivec3(0b1001, 0b0110, 0b1111));
fennec_test_run(([]() -> ivec4 { ivec4 v(0b0001, 0b0010, 0b0011, 0b0100); return v ^= ivec4(0b1000, 0b0100, 0b1100, 0b0010); }()), ivec4(0b1001, 0b0110, 0b1111, 0b0110));
fennec_test_run(([]() -> ivec2 { ivec2 v(0b0001, 0b0010); return v ^= ivec2(0b1000, 0b0100); }()), ivec2(0b1001, 0b0110));
fennec_test_run(([]() -> ivec3 { ivec3 v(0b0001, 0b0010, 0b0011); return v ^= ivec3(0b1000, 0b0100, 0b1100); }()), ivec3(0b1001, 0b0110, 0b1111));
fennec_test_run(([]() -> ivec4 { ivec4 v(0b0001, 0b0010, 0b0011, 0b0100); return v ^= ivec4(0b1000, 0b0100, 0b1100, 0b0010); }()), ivec4(0b1001, 0b0110, 0b1111, 0b0110));
fennec_test_spacer(2); // Left Shift ===============================================================================
fennec_test_spacer(2); // Left Shift ===============================================================================
fennec_test_run(0x6D40A3C3 << ivec2(4, 8), ivec2(0xD40A3C30, 0x40A3C300));
fennec_test_run(0x6D40A3C3 << ivec3(4, 8, 12), ivec3(0xD40A3C30, 0x40A3C300, 0x0A3C3000));
fennec_test_run(0x6D40A3C3 << ivec4(4, 8, 12, 16), ivec4(0xD40A3C30, 0x40A3C300, 0x0A3C3000, 0xA3C30000));
fennec_test_run(0x6D40A3C3 << ivec2(4, 8), ivec2(0xD40A3C30, 0x40A3C300));
fennec_test_run(0x6D40A3C3 << ivec3(4, 8, 12), ivec3(0xD40A3C30, 0x40A3C300, 0x0A3C3000));
fennec_test_run(0x6D40A3C3 << ivec4(4, 8, 12, 16), ivec4(0xD40A3C30, 0x40A3C300, 0x0A3C3000, 0xA3C30000));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(ivec2(0x1E, 0xF3) << 4, ivec2(0x1E0, 0xF30));
fennec_test_run(ivec3(0x1E, 0xF3, 0x27) << 4, ivec3(0x1E0, 0xF30, 0x270));
fennec_test_run(ivec4(0x1E, 0xF3, 0x27, 0x7C) << 4, ivec4(0x1E0, 0xF30, 0x270, 0x7C0));
fennec_test_run(ivec2(0x1E, 0xF3) << 4, ivec2(0x1E0, 0xF30));
fennec_test_run(ivec3(0x1E, 0xF3, 0x27) << 4, ivec3(0x1E0, 0xF30, 0x270));
fennec_test_run(ivec4(0x1E, 0xF3, 0x27, 0x7C) << 4, ivec4(0x1E0, 0xF30, 0x270, 0x7C0));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(([]() -> ivec2 { ivec2 v(0x1E, 0xF3); return v <<= 4; }()), ivec2(0x1E0, 0xF30));
fennec_test_run(([]() -> ivec3 { ivec3 v(0x1E, 0xF3, 0x27); return v <<= 4; }()), ivec3(0x1E0, 0xF30, 0x270));
fennec_test_run(([]() -> ivec4 { ivec4 v(0x1E, 0xF3, 0x27, 0x7C); return v <<= 4; }()), ivec4(0x1E0, 0xF30, 0x270, 0x7C0));
fennec_test_run(([]() -> ivec2 { ivec2 v(0x1E, 0xF3); return v <<= 4; }()), ivec2(0x1E0, 0xF30));
fennec_test_run(([]() -> ivec3 { ivec3 v(0x1E, 0xF3, 0x27); return v <<= 4; }()), ivec3(0x1E0, 0xF30, 0x270));
fennec_test_run(([]() -> ivec4 { ivec4 v(0x1E, 0xF3, 0x27, 0x7C); return v <<= 4; }()), ivec4(0x1E0, 0xF30, 0x270, 0x7C0));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(ivec2(0x1E, 0xF3) << ivec2(4, 8), ivec2(0x1E0, 0xF300));
fennec_test_run(ivec3(0x1E, 0xF3, 0x27) << ivec3(4, 8, 12), ivec3(0x1E0, 0xF300, 0x27000));
fennec_test_run(ivec4(0x1E, 0xF3, 0x27, 0x7C) << ivec4(4, 8, 12, 16), ivec4(0x1E0, 0xF300, 0x27000, 0x7C0000));
fennec_test_run(ivec2(0x1E, 0xF3) << ivec2(4, 8), ivec2(0x1E0, 0xF300));
fennec_test_run(ivec3(0x1E, 0xF3, 0x27) << ivec3(4, 8, 12), ivec3(0x1E0, 0xF300, 0x27000));
fennec_test_run(ivec4(0x1E, 0xF3, 0x27, 0x7C) << ivec4(4, 8, 12, 16), ivec4(0x1E0, 0xF300, 0x27000, 0x7C0000));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(([]() -> ivec2 { ivec2 v(0x1E, 0xF3); return v <<= ivec2(4, 8); }()), ivec2(0x1E0, 0xF300));
fennec_test_run(([]() -> ivec3 { ivec3 v(0x1E, 0xF3, 0x27); return v <<= ivec3(4, 8, 12); }()), ivec3(0x1E0, 0xF300, 0x27000));
fennec_test_run(([]() -> ivec4 { ivec4 v(0x1E, 0xF3, 0x27, 0x7C); return v <<= ivec4(4, 8, 12, 16); }()), ivec4(0x1E0, 0xF300, 0x27000, 0x7C0000));
fennec_test_run(([]() -> ivec2 { ivec2 v(0x1E, 0xF3); return v <<= ivec2(4, 8); }()), ivec2(0x1E0, 0xF300));
fennec_test_run(([]() -> ivec3 { ivec3 v(0x1E, 0xF3, 0x27); return v <<= ivec3(4, 8, 12); }()), ivec3(0x1E0, 0xF300, 0x27000));
fennec_test_run(([]() -> ivec4 { ivec4 v(0x1E, 0xF3, 0x27, 0x7C); return v <<= ivec4(4, 8, 12, 16); }()), ivec4(0x1E0, 0xF300, 0x27000, 0x7C0000));
fennec_test_spacer(2); // Right Shift ===============================================================================
fennec_test_spacer(2); // Right Shift ===============================================================================
fennec_test_run(0x6D40A3C3 >> ivec2(4, 8), ivec2(0x06D40A3C, 0x006D40A3));
fennec_test_run(0x6D40A3C3 >> ivec3(4, 8, 12), ivec3(0x06D40A3C, 0x006D40A3, 0x0006D40A));
fennec_test_run(0x6D40A3C3 >> ivec4(4, 8, 12, 16), ivec4(0x06D40A3C, 0x006D40A3, 0x0006D40A, 0x00006D40));
fennec_test_run(0x6D40A3C3 >> ivec2(4, 8), ivec2(0x06D40A3C, 0x006D40A3));
fennec_test_run(0x6D40A3C3 >> ivec3(4, 8, 12), ivec3(0x06D40A3C, 0x006D40A3, 0x0006D40A));
fennec_test_run(0x6D40A3C3 >> ivec4(4, 8, 12, 16), ivec4(0x06D40A3C, 0x006D40A3, 0x0006D40A, 0x00006D40));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(ivec2(0x1E, 0xF3) >> 4, ivec2(0x1, 0xF));
fennec_test_run(ivec3(0x1E, 0xF3, 0x27) >> 4, ivec3(0x1, 0xF, 0x2));
fennec_test_run(ivec4(0x1E, 0xF3, 0x27, 0x7C) >> 4, ivec4(0x1, 0xF, 0x2, 0x7));
fennec_test_run(ivec2(0x1E, 0xF3) >> 4, ivec2(0x1, 0xF));
fennec_test_run(ivec3(0x1E, 0xF3, 0x27) >> 4, ivec3(0x1, 0xF, 0x2));
fennec_test_run(ivec4(0x1E, 0xF3, 0x27, 0x7C) >> 4, ivec4(0x1, 0xF, 0x2, 0x7));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(([]() -> ivec2 { ivec2 v(0x1E, 0xF3); return v >>= 4; }()), ivec2(0x1, 0xF));
fennec_test_run(([]() -> ivec3 { ivec3 v(0x1E, 0xF3, 0x27); return v >>= 4; }()), ivec3(0x1, 0xF, 0x2));
fennec_test_run(([]() -> ivec4 { ivec4 v(0x1E, 0xF3, 0x27, 0x7C); return v >>= 4; }()), ivec4(0x1, 0xF, 0x2, 0x7));
fennec_test_run(([]() -> ivec2 { ivec2 v(0x1E, 0xF3); return v >>= 4; }()), ivec2(0x1, 0xF));
fennec_test_run(([]() -> ivec3 { ivec3 v(0x1E, 0xF3, 0x27); return v >>= 4; }()), ivec3(0x1, 0xF, 0x2));
fennec_test_run(([]() -> ivec4 { ivec4 v(0x1E, 0xF3, 0x27, 0x7C); return v >>= 4; }()), ivec4(0x1, 0xF, 0x2, 0x7));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(ivec2(0x2A1E, 0x7BF3) >> ivec2(4, 8), ivec2(0x2A1, 0x7B));
fennec_test_run(ivec3(0x2A1E, 0x7BF3, 0x3927) >> ivec3(4, 8, 12), ivec3(0x2A1, 0x7B, 0x3));
fennec_test_run(ivec4(0x2A1E, 0x7BF3, 0x3927, 0x237C) >> ivec4(4, 8, 12, 16), ivec4(0x2A1, 0x7B, 0x3, 0x0));
fennec_test_run(ivec2(0x2A1E, 0x7BF3) >> ivec2(4, 8), ivec2(0x2A1, 0x7B));
fennec_test_run(ivec3(0x2A1E, 0x7BF3, 0x3927) >> ivec3(4, 8, 12), ivec3(0x2A1, 0x7B, 0x3));
fennec_test_run(ivec4(0x2A1E, 0x7BF3, 0x3927, 0x237C) >> ivec4(4, 8, 12, 16), ivec4(0x2A1, 0x7B, 0x3, 0x0));
fennec_test_spacer(1);
fennec_test_spacer(1);
fennec_test_run(([]() -> ivec2 { ivec2 v(0x2A1E, 0x7BF3); return v >>= ivec2(4, 8); }()), ivec2(0x2A1, 0x7B));
fennec_test_run(([]() -> ivec3 { ivec3 v(0x2A1E, 0x7BF3, 0x3927); return v >>= ivec3(4, 8, 12); }()), ivec3(0x2A1, 0x7B, 0x3));
fennec_test_run(([]() -> ivec4 { ivec4 v(0x2A1E, 0x7BF3, 0x3927, 0x237C); return v >>= ivec4(4, 8, 12, 16); }()), ivec4(0x2A1, 0x7B, 0x3, 0x0));
}
}
fennec_test_run(([]() -> ivec2 { ivec2 v(0x2A1E, 0x7BF3); return v >>= ivec2(4, 8); }()), ivec2(0x2A1, 0x7B));
fennec_test_run(([]() -> ivec3 { ivec3 v(0x2A1E, 0x7BF3, 0x3927); return v >>= ivec3(4, 8, 12); }()), ivec3(0x2A1, 0x7B, 0x3));
fennec_test_run(([]() -> ivec4 { ivec4 v(0x2A1E, 0x7BF3, 0x3927, 0x237C); return v >>= ivec4(4, 8, 12, 16); }()), ivec4(0x2A1, 0x7B, 0x3, 0x0));
}
}

17
test/tests/platform/linux/test_wayland.h
View File

@@ -22,21 +22,16 @@
#include "../../../test.h"
#include <fennec/platform/linux/wayland/display.h>
namespace fennec
namespace fennec::test
{
namespace test
{
using namespace wayland;
using namespace wayland;
inline void fennec_test_platform_linux_wayland(linux_platform& platform) {
inline void fennec_test_platform_linux_wayland(linux_platform& platform) {
wayland_display* display = static_cast<wayland_display*>(platform.get_display());
fennec_test_run(display != nullptr, true);
}
}
wayland_display* display = static_cast<wayland_display*>(platform.get_display());
fennec_test_run(display != nullptr, true);
}
}

23
test/tests/platform/test_linux.h
View File

@@ -24,27 +24,22 @@
#include "linux/test_wayland.h"
#endif
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_platform_linux() {
inline void fennec_test_platform_linux() {
linux_platform platform(platform::user::client);
linux_platform platform(platform::user::client);
#ifdef FENNEC_LIB_WAYLAND
fennec_test_section("wayland tests");
fennec_test_spacer(2);
fennec_test_platform_linux_wayland(platform);
fennec_test_spacer(3);
fennec_test_section("wayland tests");
fennec_test_spacer(2);
fennec_test_platform_linux_wayland(platform);
fennec_test_spacer(3);
#endif
// TODO
}
}
// TODO
}
}

49
test/tests/test_containers.h
View File

@@ -21,40 +21,41 @@
#include "containers/test_array.h"
#include "containers/test_dynarray.h"
#include "containers/test_map.h"
#include "containers/test_optional.h"
#include "containers/test_set.h"
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_containers()
{
fennec_test_subheader("optional tests");
fennec_test_spacer(2);
fennec_test_containers_optional();
fennec_test_spacer(3);
inline void fennec_test_containers()
{
fennec_test_subheader("optional tests");
fennec_test_spacer(2);
fennec_test_containers_optional();
fennec_test_spacer(3);
fennec_test_subheader("array tests");
fennec_test_spacer(2);
fennec_test_containers_array();
fennec_test_spacer(3);
fennec_test_subheader("array tests");
fennec_test_spacer(2);
fennec_test_containers_array();
fennec_test_spacer(3);
fennec_test_subheader("dynarray tests");
fennec_test_spacer(2);
fennec_test_containers_dynarray();
fennec_test_spacer(3);
fennec_test_subheader("dynarray tests");
fennec_test_spacer(2);
fennec_test_containers_dynarray();
fennec_test_spacer(3);
fennec_test_subheader("set tests");
fennec_test_spacer(2);
fennec_test_containers_set();
fennec_test_spacer(3);
fennec_test_subheader("set tests");
fennec_test_spacer(2);
fennec_test_containers_set();
fennec_test_subheader("map tests");
fennec_test_spacer(2);
fennec_test_containers_map();
// TODO
}
}
// TODO
}
}

29
test/tests/test_fproc.h
View File

@@ -24,27 +24,22 @@
#include "./fproc/test_strings.h"
#include "./fproc/test_io.h"
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_fproc() {
fennec_test_header("strings");
fennec_test_spacer(2);
fennec_test_fproc_strings();
fennec_test_spacer(3);
inline void fennec_test_fproc() {
fennec_test_header("strings");
fennec_test_spacer(2);
fennec_test_fproc_strings();
fennec_test_spacer(3);
fennec_test_header("io");
fennec_test_spacer(2);
fennec_test_fproc_io();
fennec_test_spacer(3);
fennec_test_header("io");
fennec_test_spacer(2);
fennec_test_fproc_io();
fennec_test_spacer(3);
// TODO
}
}
// TODO
}
}

29
test/tests/test_lang.h
View File

@@ -23,27 +23,22 @@
#include "lang/test_conditional_types.h"
#include "lang/test_hashing.h"
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_lang()
{
fennec_test_subheader("bit tests");
fennec_test_spacer(2);
fennec_test_lang_bits();
fennec_test_spacer(3);
inline void fennec_test_lang()
{
fennec_test_subheader("bit tests");
fennec_test_spacer(2);
fennec_test_lang_bits();
fennec_test_spacer(3);
fennec_test_subheader("hashing tests");
fennec_test_spacer(2);
fennec_test_lang_hashing();
fennec_test_subheader("hashing tests");
fennec_test_spacer(2);
fennec_test_lang_hashing();
// TODO
}
}
// TODO
}
}

87
test/tests/test_math.h
View File

@@ -31,63 +31,58 @@
#include "math/test_ext.h"
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_math()
{
fennec_test_subheader("scalar tests");
fennec_test_spacer(2);
fennec_test_math_scalar();
fennec_test_spacer(3);
inline void fennec_test_math()
{
fennec_test_subheader("scalar tests");
fennec_test_spacer(2);
fennec_test_math_scalar();
fennec_test_spacer(3);
fennec_test_subheader("vector tests");
fennec_test_spacer(2);
fennec_test_math_vector();
fennec_test_spacer(3);
fennec_test_subheader("vector tests");
fennec_test_spacer(2);
fennec_test_math_vector();
fennec_test_spacer(3);
fennec_test_subheader("matrix tests");
fennec_test_spacer(2);
fennec_test_math_matrix();
fennec_test_spacer(3);
fennec_test_subheader("matrix tests");
fennec_test_spacer(2);
fennec_test_math_matrix();
fennec_test_spacer(3);
fennec_test_subheader("common tests");
fennec_test_spacer(2);
fennec_test_math_common();
fennec_test_spacer(3);
fennec_test_subheader("common tests");
fennec_test_spacer(2);
fennec_test_math_common();
fennec_test_spacer(3);
fennec_test_subheader("exponential tests");
fennec_test_spacer(2);
fennec_test_math_exponential();
fennec_test_spacer(3);
fennec_test_subheader("exponential tests");
fennec_test_spacer(2);
fennec_test_math_exponential();
fennec_test_spacer(3);
fennec_test_subheader("geometric tests");
fennec_test_spacer(2);
fennec_test_math_geometric();
fennec_test_spacer(3);
fennec_test_subheader("geometric tests");
fennec_test_spacer(2);
fennec_test_math_geometric();
fennec_test_spacer(3);
fennec_test_subheader("relational tests");
fennec_test_spacer(2);
fennec_test_math_relational();
fennec_test_spacer(3);
fennec_test_subheader("relational tests");
fennec_test_spacer(2);
fennec_test_math_relational();
fennec_test_spacer(3);
fennec_test_subheader("trigonometric tests");
fennec_test_spacer(2);
fennec_test_math_trigonometric();
fennec_test_spacer(3);
fennec_test_subheader("trigonometric tests");
fennec_test_spacer(2);
fennec_test_math_trigonometric();
fennec_test_spacer(3);
fennec_test_header("math extension tests");
fennec_test_spacer(2);
fennec_test_math_ext();
fennec_test_spacer(3);
fennec_test_header("math extension tests");
fennec_test_spacer(2);
fennec_test_math_ext();
fennec_test_spacer(3);
// TODO
}
}
// TODO
}
}

19
test/tests/test_platform.h
View File

@@ -24,22 +24,17 @@
#include "./platform/test_linux.h"
#endif
namespace fennec
namespace fennec::test
{
namespace test
{
inline void fennec_test_platform() {
inline void fennec_test_platform() {
#if FENNEC_PLATFORM_LINUX
fennec_test_subheader("linux");
fennec_test_spacer(2);
fennec_test_platform_linux();
fennec_test_spacer(3);
fennec_test_subheader("linux");
fennec_test_spacer(2);
fennec_test_platform_linux();
fennec_test_spacer(3);
#endif
}
}
}
}