Kimelas/bgc-c
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Упрощение тестов

Browse source
This commit is contained in:
Andrey Pokidov 2025-02-13 19:28:40 +07:00
parent fcf793c758
commit 7f242c4b63
71 changed files with 518 additions and 943 deletions
Download patch file Download diff file Expand all files Collapse all files

13
basic-geometry-test/helpers.c
View file

@ -1,4 +1,5 @@
#include <stdio.h>
#include <stdlib.h>
#include "helpers.h"
@ -15,11 +16,17 @@ void print_testing_name(const char * name)
void print_testing_success()
{
puts("[ Success ]\n");
puts("[ \x1b[32mSuccess\x1b[0m ]");
}
void print_testing_failed(const char* message)
void print_testing_error(const char * message)
{
printf("[ Failed: %s ]\n", message);
printf("[ \x1b[31mFailed\x1b[0m: %s ]\n", message);
exit(TEST_FAILED);
}
void print_testing_failed()
{
puts("[ \x1b[31mFailed\x1b[0m ]");
exit(TEST_FAILED);
}

42
basic-geometry-test/helpers.h
View file

@ -3,15 +3,53 @@
#include <basic-geometry.h>
#define TEST_SUCCESS 0
#define TEST_SUCCES 0
#define TEST_FAILED 1
// =================== Number =================== //
typedef struct {
float number1, number2;
} TestNumberPairFP32;
typedef struct {
double number1, number2;
} TestNumberPairFP64;
// ================== Vector2 =================== //
// ================== Vector3 =================== //
// ================= Quaternion ================= //
// =================== Versor =================== //
typedef struct {
BgcVersorFP32 first, second;
} TestVersorPairFP32;
typedef struct {
BgcVersorFP64 first, second;
} TestVersorPairFP64;
typedef struct {
BgcVersorFP32 first, second, result;
} TestVersorTripletFP32;
typedef struct {
BgcVersorFP64 first, second, result;
} TestVersorTripletFP64;
// ================= Functions ================== //
void print_testing_section(const char * name);
void print_testing_name(const char * name);
void print_testing_success();
void print_testing_failed(const char* message);
void print_testing_error(const char * message);
void print_testing_failed();
#endif

6
basic-geometry-test/main.c
View file

@ -12,10 +12,14 @@
int main()
{
test_utilities();
test_vector2();
test_vector3();
test_quaternion();
test_versor();
return TEST_SUCCESS;
return 0;
}

38
basic-geometry-test/tests/quaternion.c
View file

@ -1,36 +1,14 @@
#include "quaternion.h"
int test_quaternion()
void test_quaternion()
{
print_testing_section("BGC Quaternion");
if (test_quaternion_reset() != TEST_SUCCESS) {
return TEST_FAILED;
}
if (test_quaternion_set_to_identity() != TEST_SUCCESS) {
return TEST_FAILED;
}
if (test_quaternion_set_values() != TEST_SUCCESS) {
return TEST_FAILED;
}
if (test_quaternion_copy() != TEST_SUCCESS) {
return TEST_FAILED;
}
if (test_quaternion_swap() != TEST_SUCCESS) {
return TEST_FAILED;
}
if (test_quaternion_is_zero() != TEST_SUCCESS) {
return TEST_FAILED;
}
if (test_quaternion_is_unit() != TEST_SUCCESS) {
return TEST_FAILED;
}
return TEST_SUCCESS;
test_quaternion_reset();
test_quaternion_set_to_identity();
test_quaternion_set_values();
test_quaternion_copy();
test_quaternion_swap();
test_quaternion_is_zero();
test_quaternion_is_unit();
}

2
basic-geometry-test/tests/quaternion.h
View file

@ -10,6 +10,6 @@
#include "./quaternion/quaternion_is_zero.h"
#include "./quaternion/quaternion_is_unit.h"
int test_quaternion();
void test_quaternion();
#endif

27
basic-geometry-test/tests/quaternion/quaternion_copy.c
View file

@ -14,14 +14,14 @@ static const BgcQuaternionFP32 _TEST_FP32_QUATERNION_LIST[] = {
{ 0.001f, -100.0f, 100.0f, -0.001f }
};
int test_quaternion_copy_fp32()
void test_quaternion_copy_fp32()
{
BgcQuaternionFP32 vector;
print_testing_name("bgc_quaternion_copy_fp32");
for (int i = 0; i < _TEST_FP32_QUATERNION_AMOUNT; i++) {
bgc_quaternion_copy_fp32(&_TEST_FP32_QUATERNION_LIST[i], &vector);
if (vector.s0 != _TEST_FP32_QUATERNION_LIST[i].s0 ||
@ -29,13 +29,11 @@ int test_quaternion_copy_fp32()
vector.x2 != _TEST_FP32_QUATERNION_LIST[i].x2 ||
vector.x3 != _TEST_FP32_QUATERNION_LIST[i].x3) {
print_testing_failed();
return TEST_FAILED;
return;
}
}
print_testing_success();
return TEST_SUCCESS;
}
// ==================== FP64 ==================== //
@ -48,7 +46,7 @@ static const BgcQuaternionFP64 _TEST_FP64_QUATERNION_LIST[] = {
{ 0.001, -100.0, 100.0, -0.001 }
};
int test_quaternion_copy_fp64()
void test_quaternion_copy_fp64()
{
BgcQuaternionFP64 vector;
@ -63,24 +61,15 @@ int test_quaternion_copy_fp64()
vector.x2 != _TEST_FP64_QUATERNION_LIST[i].x2 ||
vector.x3 != _TEST_FP64_QUATERNION_LIST[i].x3) {
print_testing_failed();
return TEST_FAILED;
return;
}
}
print_testing_success();
return TEST_SUCCESS;
}
int test_quaternion_copy()
void test_quaternion_copy()
{
if (test_quaternion_copy_fp32() != TEST_SUCCESS) {
return TEST_FAILED;
}
if (test_quaternion_copy_fp64() != TEST_SUCCESS) {
return TEST_FAILED;
}
return TEST_SUCCESS;
test_quaternion_copy_fp32();
test_quaternion_copy_fp64();
}

6
basic-geometry-test/tests/quaternion/quaternion_copy.h
View file

@ -1,10 +1,10 @@
#ifndef _TEST_QUATERNION_COPY_H_
#define _TEST_QUATERNION_COPY_H_
int test_quaternion_copy_fp32();
void test_quaternion_copy_fp32();
int test_quaternion_copy_fp64();
void test_quaternion_copy_fp64();
int test_quaternion_copy();
void test_quaternion_copy();
#endif

37
basic-geometry-test/tests/quaternion/quaternion_is_unit.c
View file

@ -39,29 +39,27 @@ static const BgcQuaternionFP32 _TEST_FP32_NONUNIT_QUATERION_LIST[] = {
{ 0.5f - 1.25f * BGC_EPSYLON_FP32, 0.5f - 1.25f * BGC_EPSYLON_FP32, 0.0f, 0.5f }
};
int test_quaternion_is_unit_fp32()
void test_quaternion_is_unit_fp32()
{
print_testing_name("bgc_quaternion_is_unit_fp32");
// Testing zero values:
for (int i = 0; i < _TEST_FP32_UNIT_QUATERNION_AMOUNT; i++) {
if (!bgc_quaternion_is_unit_fp32(&_TEST_FP32_UNIT_QUATERNION_LIST[i])) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("A unit quaternion was not recognized");
return;
}
}
// Testing non-zero values:
for (int i = 0; i < _TEST_FP32_NONUNIT_QUATERNION_AMOUNT; i++) {
if (bgc_quaternion_is_unit_fp32(&_TEST_FP32_NONUNIT_QUATERION_LIST[i])) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("A non-unit quaternion was recognized a unit quaternion");
return;
}
}
print_testing_success();
return TEST_SUCCESS;
}
// ==================== FP64 ==================== //
@ -101,40 +99,31 @@ static const BgcQuaternionFP64 _TEST_FP64_NONUNIT_QUATERION_LIST[] = {
{ 0.5 - 1.25 * BGC_EPSYLON_FP64, 0.5 - 1.25 * BGC_EPSYLON_FP64, 0.0, 0.5 }
};
int test_quaternion_is_unit_fp64()
void test_quaternion_is_unit_fp64()
{
print_testing_name("bgc_quaternion_is_unit_fp64");
// Testing zero values:
for (int i = 0; i < _TEST_FP64_UNIT_QUATERNION_AMOUNT; i++) {
if (!bgc_quaternion_is_unit_fp64(&_TEST_FP64_UNIT_QUATERNION_LIST[i])) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("A unit quaternion was not recognized");
return;
}
}
// Testing non-zero values:
for (int i = 0; i < _TEST_FP64_NONUNIT_QUATERNION_AMOUNT; i++) {
if (bgc_quaternion_is_unit_fp64(&_TEST_FP64_NONUNIT_QUATERION_LIST[i])) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("A non-unit quaternion was recognized a unit quaternion");
return;
}
}
print_testing_success();
return TEST_SUCCESS;
}
int test_quaternion_is_unit()
void test_quaternion_is_unit()
{
if (test_quaternion_is_unit_fp32() != TEST_SUCCESS) {
return TEST_FAILED;
}
if (test_quaternion_is_unit_fp64() != TEST_SUCCESS) {
return TEST_FAILED;
}
return TEST_SUCCESS;
test_quaternion_is_unit_fp32();
test_quaternion_is_unit_fp64();
}

6
basic-geometry-test/tests/quaternion/quaternion_is_unit.h
View file

@ -1,10 +1,10 @@
#ifndef _TEST_QUATERNION_IS_UNIT_H_
#define _TEST_QUATERNION_IS_UNIT_H_
int test_quaternion_is_unit_fp32();
void test_quaternion_is_unit_fp32();
int test_quaternion_is_unit_fp64();
void test_quaternion_is_unit_fp64();
int test_quaternion_is_unit();
void test_quaternion_is_unit();
#endif

37
basic-geometry-test/tests/quaternion/quaternion_is_zero.c
View file

@ -33,29 +33,27 @@ static const BgcQuaternionFP32 _TEST_FP32_NONZERO_QUATERION_LIST[] = {
{ -1.25f * BGC_EPSYLON_FP32, -1.25f * BGC_EPSYLON_FP32, 0.0f, 0.0f }
};
int test_quaternion_is_zero_fp32()
void test_quaternion_is_zero_fp32()
{
print_testing_name("bgc_quaternion_is_zero_fp32");
// Testing zero values:
for (int i = 0; i < _TEST_FP32_ZERO_QUATERNION_AMOUNT; i++) {
if (!bgc_quaternion_is_zero_fp32(&_TEST_FP32_ZERO_QUATERNION_LIST[i])) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("A zero quaternion was not recognized");
return;
}
}
// Testing non-zero values:
for (int i = 0; i < _TEST_FP32_NONZERO_QUATERNION_AMOUNT; i++) {
if (bgc_quaternion_is_zero_fp32(&_TEST_FP32_NONZERO_QUATERION_LIST[i])) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("A non-zero quaternion was recognized as a zero quaternion");
return;
}
}
print_testing_success();
return TEST_SUCCESS;
}
// ==================== FP64 ==================== //
@ -89,40 +87,31 @@ static const BgcQuaternionFP64 _TEST_FP64_NONZERO_QUATERION_LIST[] = {
{ -1.25 * BGC_EPSYLON_FP64, -1.25 * BGC_EPSYLON_FP64, 0.0, 0.0 }
};
int test_quaternion_is_zero_fp64()
void test_quaternion_is_zero_fp64()
{
print_testing_name("bgc_quaternion_is_zero_fp64");
// Testing zero values:
for (int i = 0; i < _TEST_FP64_ZERO_QUATERNION_AMOUNT; i++) {
if (!bgc_quaternion_is_zero_fp64(&_TEST_FP64_ZERO_QUATERNION_LIST[i])) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("A zero quaternion was not recognized");
return;
}
}
// Testing non-zero values:
for (int i = 0; i < _TEST_FP64_NONZERO_QUATERNION_AMOUNT; i++) {
if (bgc_quaternion_is_zero_fp64(&_TEST_FP64_NONZERO_QUATERION_LIST[i])) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("A non-zero quaternion was recognized as a zero quaternion");
return;
}
}
print_testing_success();
return TEST_SUCCESS;
}
int test_quaternion_is_zero()
void test_quaternion_is_zero()
{
if (test_quaternion_is_zero_fp32() != TEST_SUCCESS) {
return TEST_FAILED;
}
if (test_quaternion_is_zero_fp64() != TEST_SUCCESS) {
return TEST_FAILED;
}
return TEST_SUCCESS;
test_quaternion_is_zero_fp32();
test_quaternion_is_zero_fp64();
}

6
basic-geometry-test/tests/quaternion/quaternion_is_zero.h
View file

@ -1,10 +1,10 @@
#ifndef _TEST_QUATERNION_IS_ZERO_H_
#define _TEST_QUATERNION_IS_ZERO_H_
int test_quaternion_is_zero_fp32();
void test_quaternion_is_zero_fp32();
int test_quaternion_is_zero_fp64();
void test_quaternion_is_zero_fp64();
int test_quaternion_is_zero();
void test_quaternion_is_zero();
#endif

25
basic-geometry-test/tests/quaternion/quaternion_reset.c
View file

@ -2,7 +2,7 @@
#include "./../../helpers.h"
int test_quaternion_reset_fp32()
void test_quaternion_reset_fp32()
{
BgcQuaternionFP32 vector;
@ -12,15 +12,13 @@ int test_quaternion_reset_fp32()
if (vector.s0 != 0.0f || vector.x1 != 0.0f || vector.x2 != 0.0f || vector.x3 != 0.0f) {
print_testing_failed();
return TEST_FAILED;
return;
}
print_testing_success();
return TEST_SUCCESS;
}
int test_quaternion_reset_fp64()
void test_quaternion_reset_fp64()
{
BgcQuaternionFP64 vector;
@ -30,23 +28,14 @@ int test_quaternion_reset_fp64()
if (vector.s0 != 0.0 || vector.x1 != 0.0 || vector.x2 != 0.0 || vector.x3 != 0.0) {
print_testing_failed();
return TEST_FAILED;
return;
}
print_testing_success();
return TEST_SUCCESS;
}
int test_quaternion_reset()
void test_quaternion_reset()
{
if (test_quaternion_reset_fp32() != TEST_SUCCESS) {
return TEST_FAILED;
}
if (test_quaternion_reset_fp64() != TEST_SUCCESS) {
return TEST_FAILED;
}
return TEST_SUCCESS;
test_quaternion_reset_fp32();
test_quaternion_reset_fp64();
}

6
basic-geometry-test/tests/quaternion/quaternion_reset.h
View file

@ -1,10 +1,10 @@
#ifndef _TEST_QUATERNION_RESET_H_
#define _TEST_QUATERNION_RESET_H_
int test_quaternion_reset_fp32();
void test_quaternion_reset_fp32();
int test_quaternion_reset_fp64();
void test_quaternion_reset_fp64();
int test_quaternion_reset();
void test_quaternion_reset();
#endif

25
basic-geometry-test/tests/quaternion/quaternion_set_to_identity.c
View file

@ -2,7 +2,7 @@
#include "./../../helpers.h"
int test_quaternion_set_to_identity_fp32()
void test_quaternion_set_to_identity_fp32()
{
BgcQuaternionFP32 vector;
@ -12,15 +12,13 @@ int test_quaternion_set_to_identity_fp32()
if (vector.s0 != 1.0f || vector.x1 != 0.0f || vector.x2 != 0.0f || vector.x3 != 0.0f) {
print_testing_failed();
return TEST_FAILED;
return;
}
print_testing_success();
return TEST_SUCCESS;
}
int test_quaternion_set_to_identity_fp64()
void test_quaternion_set_to_identity_fp64()
{
BgcQuaternionFP64 vector;
@ -30,23 +28,14 @@ int test_quaternion_set_to_identity_fp64()
if (vector.s0 != 1.0 || vector.x1 != 0.0 || vector.x2 != 0.0 || vector.x3 != 0.0) {
print_testing_failed();
return TEST_FAILED;
return;
}
print_testing_success();
return TEST_SUCCESS;
}
int test_quaternion_set_to_identity()
void test_quaternion_set_to_identity()
{
if (test_quaternion_set_to_identity_fp32() != TEST_SUCCESS) {
return TEST_FAILED;
}
if (test_quaternion_set_to_identity_fp64() != TEST_SUCCESS) {
return TEST_FAILED;
}
return TEST_SUCCESS;
test_quaternion_set_to_identity_fp32();
test_quaternion_set_to_identity_fp64();
}

6
basic-geometry-test/tests/quaternion/quaternion_set_to_identity.h
View file

@ -1,10 +1,10 @@
#ifndef _TEST_QUATERNION_SET_TO_IDENTITY_H_
#define _TEST_QUATERNION_SET_TO_IDENTITY_H_
int test_quaternion_set_to_identity_fp32();
void test_quaternion_set_to_identity_fp32();
int test_quaternion_set_to_identity_fp64();
void test_quaternion_set_to_identity_fp64();
int test_quaternion_set_to_identity();
void test_quaternion_set_to_identity();
#endif

45
basic-geometry-test/tests/quaternion/quaternion_set_values.c
View file

@ -6,7 +6,7 @@
// ==================== FP32 ==================== //
int test_quaternion_set_values_fp32()
void test_quaternion_set_values_fp32()
{
BgcQuaternionFP32 vector;
@ -15,32 +15,30 @@ int test_quaternion_set_values_fp32()
bgc_quaternion_set_values_fp32(1.0f, 2.0f, 3.0f, 4.0f, &vector);
if (vector.s0 != 1.0f || vector.x1 != 2.0f || vector.x2 != 3.0f || vector.x3 != 4.0f) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("First step failed");
return;
}
bgc_quaternion_set_values_fp32(-1.0f, -3.0f, -5.0f, -7.0f, &vector);
if (vector.s0 != -1.0f || vector.x1 != -3.0f || vector.x2 != -5.0f || vector.x3 != -7.0f) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("Second step failed");
return;
}
bgc_quaternion_set_values_fp32(-8.0f, -2.0f, 2.0f, 4.0f, &vector);
if (vector.s0 != -8.0f || vector.x1 != -2.0f || vector.x2 != 2.0f || vector.x3 != 4.0f) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("Third step failed");
return;
}
print_testing_success();
return TEST_SUCCESS;
}
// ==================== FP64 ==================== //
int test_quaternion_set_values_fp64()
void test_quaternion_set_values_fp64()
{
BgcQuaternionFP64 vector;
@ -49,38 +47,29 @@ int test_quaternion_set_values_fp64()
bgc_quaternion_set_values_fp64(1.0, 2.0, 3.0, 4.0, &vector);
if (vector.s0 != 1.0 || vector.x1 != 2.0 || vector.x2 != 3.0 || vector.x3 != 4.0) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("First step failed");
return;
}
bgc_quaternion_set_values_fp64(-1.0, -3.0, -5.0, -7.0, &vector);
if (vector.s0 != -1.0 || vector.x1 != -3.0 || vector.x2 != -5.0 || vector.x3 != -7.0) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("Second step failed");
return;
}
bgc_quaternion_set_values_fp64(-8.0, -2.0, 2.0, 4.0, &vector);
if (vector.s0 != -8.0 || vector.x1 != -2.0 || vector.x2 != 2.0 || vector.x3 != 4.0) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("Third step failed");
return;
}
print_testing_success();
return TEST_SUCCESS;
}
int test_quaternion_set_values()
void test_quaternion_set_values()
{
if (test_quaternion_set_values_fp32() != TEST_SUCCESS) {
return TEST_FAILED;
}
if (test_quaternion_set_values_fp64() != TEST_SUCCESS) {
return TEST_FAILED;
}
return TEST_SUCCESS;
test_quaternion_set_values_fp32();
test_quaternion_set_values_fp64();
}

6
basic-geometry-test/tests/quaternion/quaternion_set_values.h
View file

@ -1,10 +1,10 @@
#ifndef _TEST_QUATERNION_SET_VALUES_H_
#define _TEST_QUATERNION_SET_VALUES_H_
int test_quaternion_set_values_fp32();
void test_quaternion_set_values_fp32();
int test_quaternion_set_values_fp64();
void test_quaternion_set_values_fp64();
int test_quaternion_set_values();
void test_quaternion_set_values();
#endif

21
basic-geometry-test/tests/quaternion/quaternion_square_modulus.c
View file

@ -2,33 +2,22 @@
#include "./../../helpers.h"
int test_quaternion_square_modulus_fp32()
void test_quaternion_square_modulus_fp32()
{
print_testing_name("bgc_quaternion_is_zero_fp32");
print_testing_success();
return TEST_SUCCES;
}
int test_quaternion_square_modulus_fp64()
void test_quaternion_square_modulus_fp64()
{
print_testing_name("bgc_quaternion_is_zero_fp64");
print_testing_success();
return TEST_SUCCES;
}
int test_quaternion_square_modulus()
void test_quaternion_square_modulus()
{
if (test_quaternion_square_modulus_fp32() != TEST_SUCCES) {
return TEST_FAILED;
}
if (test_quaternion_square_modulus_fp64() != TEST_SUCCES) {
return TEST_FAILED;
}
return TEST_SUCCES;
test_quaternion_square_modulus_fp32();
test_quaternion_square_modulus_fp64();
}

6
basic-geometry-test/tests/quaternion/quaternion_square_modulus.h
View file

@ -1,10 +1,10 @@
#ifndef _TEST_QUATERNION_SQUARE_MODULUS_H_
#define _TEST_QUATERNION_SQUARE_MODULUS_H_
int test_quaternion_square_modulus_fp32();
void test_quaternion_square_modulus_fp32();
int test_quaternion_square_modulus_fp64();
void test_quaternion_square_modulus_fp64();
int test_quaternion_square_modulus();
void test_quaternion_square_modulus();
#endif

25
basic-geometry-test/tests/quaternion/quaternion_swap.c
View file

@ -22,7 +22,7 @@ static const BgcQuaternionFP32 _TEST_FP32_QUATERNION_LIST2[] = {
{ 1000.0f, -0.00025f, -0.419f, 0.844f }
};
int test_quaternion_swap_fp32()
void test_quaternion_swap_fp32()
{
BgcQuaternionFP32 quaternion1, quaternion2;
@ -43,13 +43,11 @@ int test_quaternion_swap_fp32()
quaternion2.x2 != _TEST_FP32_QUATERNION_LIST1[i].x2 ||
quaternion2.x3 != _TEST_FP32_QUATERNION_LIST1[i].x3) {
print_testing_failed();
return TEST_FAILED;
return;
}
}
print_testing_success();
return TEST_SUCCESS;
}
// ==================== FP64 ==================== //
@ -70,7 +68,7 @@ static const BgcQuaternionFP64 _TEST_FP64_QUATERNION_LIST2[] = {
{ 1000.0, -0.00025, -0.419, 0.844 }
};
int test_quaternion_swap_fp64()
void test_quaternion_swap_fp64()
{
BgcQuaternionFP64 quaternion1, quaternion2;
@ -91,24 +89,15 @@ int test_quaternion_swap_fp64()
quaternion2.x2 != _TEST_FP64_QUATERNION_LIST1[i].x2 ||
quaternion2.x3 != _TEST_FP64_QUATERNION_LIST1[i].x3) {
print_testing_failed();
return TEST_FAILED;
return;
}
}
print_testing_success();
return TEST_SUCCESS;
}
int test_quaternion_swap()
void test_quaternion_swap()
{
if (test_quaternion_swap_fp32() != TEST_SUCCESS) {
return TEST_FAILED;
}
if (test_quaternion_swap_fp64() != TEST_SUCCESS) {
return TEST_FAILED;
}
return TEST_SUCCESS;
test_quaternion_swap_fp32();
test_quaternion_swap_fp64();
}

6
basic-geometry-test/tests/quaternion/quaternion_swap.h
View file

@ -1,10 +1,10 @@
#ifndef _TEST_QUATERNION_SWAP_H_
#define _TEST_QUATERNION_SWAP_H_
int test_quaternion_swap_fp32();
void test_quaternion_swap_fp32();
int test_quaternion_swap_fp64();
void test_quaternion_swap_fp64();
int test_quaternion_swap();
void test_quaternion_swap();
#endif

53
basic-geometry-test/tests/utilities/are_close.c
View file

@ -2,20 +2,12 @@
#include "./../../helpers.h"
typedef struct {
float number1, number2;
} _TestNumberPairFP32;
typedef struct {
double number1, number2;
} _TestNumberPairFP64;
// ==================== FP32 ==================== //
static const int _TEST_FP32_CLOSE_NUMBERS_AMOUNT = 16;
static const int _TEST_FP32_DIFFERENT_NUMBERS_AMOUNT = 12;
static const _TestNumberPairFP32 _TEST_FP32_DATA_CLOSE[] = {
static const TestNumberPairFP32 _TEST_FP32_DATA_CLOSE[] = {
{0.0f, 0.0f},
{1.0f, 1.0f},
{-1.0f, -1.0f},
@ -38,7 +30,7 @@ static const _TestNumberPairFP32 _TEST_FP32_DATA_CLOSE[] = {
{-100.0f, -100.0f * (1.0f - 0.75f * BGC_EPSYLON_FP32)}
};
static const _TestNumberPairFP32 _TEST_FP32_DATA_DIFFERENT[] = {
static const TestNumberPairFP32 _TEST_FP32_DATA_DIFFERENT[] = {
{0.0f, 0.001f},
{1.0f, 0.999f},
{-1.0f, -0.999f},
@ -61,29 +53,27 @@ static const _TestNumberPairFP32 _TEST_FP32_DATA_DIFFERENT[] = {
{-100.0f, -100.0f * (1.0f - 1.25f * BGC_EPSYLON_FP32)}
};
int test_are_close_fp32()
void test_are_close_fp32()
{
print_testing_name("bgc_are_close_fp32");
// Testing close pairs of values:
for (int i = 0; i < _TEST_FP32_CLOSE_NUMBERS_AMOUNT; i++) {
if (!bgc_are_close_fp32(_TEST_FP32_DATA_CLOSE[i].number1, _TEST_FP32_DATA_CLOSE[i].number2)) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("A pair of close numbers was not recognized");
return;
}
}
// Testing different pairs of values:
for (int i = 0; i < _TEST_FP32_DIFFERENT_NUMBERS_AMOUNT; i++) {
if (bgc_are_close_fp32(_TEST_FP32_DATA_DIFFERENT[i].number1, _TEST_FP32_DATA_DIFFERENT[i].number2)) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("A pair of close numbers was not recognized");
return;
}
}
print_testing_success();
return TEST_SUCCESS;
}
// ==================== FP64 ==================== //
@ -91,7 +81,7 @@ int test_are_close_fp32()
static const int _TEST_FP64_CLOSE_NUMBERS_AMOUNT = 16;
static const int _TEST_FP64_DIFFERENT_NUMBERS_AMOUNT = 16;
static const _TestNumberPairFP64 _TEST_FP64_DATA_CLOSE[] = {
static const TestNumberPairFP64 _TEST_FP64_DATA_CLOSE[] = {
{0.0, 0.0},
{1.0, 1.0},
{-1.0, -1.0},
@ -114,7 +104,7 @@ static const _TestNumberPairFP64 _TEST_FP64_DATA_CLOSE[] = {
{-100.0, -100.0 * (1.0 - 0.75 * BGC_EPSYLON_FP64)}
};
static const _TestNumberPairFP64 _TEST_FP64_DATA_DIFFERENT[] = {
static const TestNumberPairFP64 _TEST_FP64_DATA_DIFFERENT[] = {
{0.0, 0.000001},
{1.0, 0.999999},
{-1.0, -0.999999},
@ -137,40 +127,31 @@ static const _TestNumberPairFP64 _TEST_FP64_DATA_DIFFERENT[] = {
{-100.0, -100.0 * (1.0 - 1.25 * BGC_EPSYLON_FP64)}
};
int test_are_close_fp64()
void test_are_close_fp64()
{
print_testing_name("bgc_are_close_fp64");
// Testing close pairs of values:
for (int i = 0; i < _TEST_FP64_CLOSE_NUMBERS_AMOUNT; i++) {
if (!bgc_are_close_fp64(_TEST_FP64_DATA_CLOSE[i].number1, _TEST_FP64_DATA_CLOSE[i].number2)) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("A pair of close numbers was not recognized");
return;
}
}
// Testing different pairs of values:
for (int i = 0; i < _TEST_FP64_DIFFERENT_NUMBERS_AMOUNT; i++) {
if (bgc_are_close_fp64(_TEST_FP64_DATA_DIFFERENT[i].number1, _TEST_FP64_DATA_DIFFERENT[i].number2)) {
print_testing_failed();
return TEST_FAILED;
print_testing_error("A pair of different numbers was recognized as close numbers");
return;
}
}
print_testing_success();
return TEST_SUCCESS;
}
int test_are_close()
void test_are_close()
{
if (test_are_close_fp32() != TEST_SUCCESS) {
return TEST_FAILED;
}
if (test_are_close_fp64() != TEST_SUCCESS) {
return TEST_FAILED;
}
return TEST_SUCCESS;
test_are_close_fp32();
test_are_close_fp64();
}

6
basic-geometry-test/tests/utilities/are_close.h
View file

@ -1,10 +1,10 @@
#ifndef _TEST_UTILITIES_ARE_CLOSE_H_
#define _TEST_UTILITIES_ARE_CLOSE_H_
int test_are_close_fp32();
void test_are_close_fp32();
int test_are_close_fp64();
void test_are_close_fp64();
int test_are_close();
void test_are_close();
#endif

18
basic-geometry-test/tests/utilities/is_unit.c
View file

@ -27,7 +27,7 @@ void test_is_unit_fp32()
// Testing unit values:
for (int i = 0; i < _TEST_FP32_UNIT_NUMBERS_AMOUNT; i++) {
if (!bgc_is_unit_fp32(_TEST_FP32_UNIT_NUMBERS[i])) {
print_testing_failed("A unit value was not recognized");
print_testing_error("A unit value was not recognized");
return;
}
}
@ -35,7 +35,7 @@ void test_is_unit_fp32()
// Testing non-unit values:
for (int i = 0; i < _TEST_FP32_NONUNIT_NUMBERS_AMOUNT; i++) {
if (bgc_is_unit_fp32(_TEST_FP32_NONUNIT_NUMBERS[i])) {
print_testing_failed("A non-unit value was recognized as a unit value");
print_testing_error("A non-unit value was recognized as a unit value");
return;
}
}
@ -68,7 +68,7 @@ void test_is_unit_fp64()
// Testing unit values:
for (int i = 0; i < _TEST_FP64_UNIT_NUMBERS_AMOUNT; i++) {
if (!bgc_is_unit_fp64(_TEST_FP64_UNIT_NUMBERS[i])) {
print_testing_failed("A unit value was not recognized");
print_testing_error("A unit value was not recognized");
return;
}
}
@ -76,7 +76,7 @@ void test_is_unit_fp64()
// Testing non-unit values:
for (int i = 0; i < _TEST_FP64_NONUNIT_NUMBERS_AMOUNT; i++) {
if (bgc_is_unit_fp64(_TEST_FP64_NONUNIT_NUMBERS[i])) {
print_testing_failed("A non-unit value was recognized as a unit value");
print_testing_error("A non-unit value was recognized as a unit value");
return;
}
}
@ -109,7 +109,7 @@ void test_is_sqare_unit_fp32()
// Testing unit values:
for (int i = 0; i < _TEST_FP32_DATA_SQUARE_UNIT_AMOUNT; i++) {
if (!bgc_is_sqare_unit_fp32(_TEST_FP32_DATA_SQUARE_UNIT[i])) {
print_testing_failed("A unit value was not recognized");
print_testing_error("A square unit value was not recognized");
return;
}
}
@ -117,7 +117,7 @@ void test_is_sqare_unit_fp32()
// Testing non-unit values:
for (int i = 0; i < _TEST_FP32_DATA_SQUARE_NONUNIT_AMOUNT; i++) {
if (bgc_is_sqare_unit_fp32(_TEST_FP32_DATA_SQUARE_NONUNIT[i])) {
print_testing_failed("A non-unit value was recognized as a unit value");
print_testing_error("A non-unit value was recognized as a square unit value");
return;
}
}
@ -150,7 +150,7 @@ void test_is_sqare_unit_fp64()
// Testing unit values:
for (int i = 0; i < _TEST_FP64_DATA_SQUARE_UNIT_AMOUNT; i++) {
if (!bgc_is_sqare_unit_fp64(_TEST_FP64_DATA_SQUARE_UNIT[i])) {
print_testing_failed();
print_testing_error("A square unit value was not recognized");
return;
}
}
@ -158,7 +158,7 @@ void test_is_sqare_unit_fp64()
// Testing non-unit values:
for (int i = 0; i < _TEST_FP64_DATA_SQUARE_NONUNIT_AMOUNT; i++) {
if (bgc_is_sqare_unit_fp64(_TEST_FP64_DATA_SQUARE_NONUNIT[i])) {
print_testing_failed("A non-unit value was recognized as a unit value");
print_testing_error("A non-unit value was recognized as a square unit value");
return;
}
}
@ -173,6 +173,4 @@ void test_is_unit()
test_is_sqare_unit_fp32();
test_is_sqare_unit_fp64();
return TEST_SUCCESS;
}

42
basic-geometry-test/tests/utilities/is_zero.c
View file

Internal server error - Personal Git Server: Beyond coding. We Forge.

500

Internal server error

Forgejo version: 11.0.1+gitea-1.22.0

 @ -4,16 +4,16 @@
// ==================== FP32 ==================== //
static const int _TEST_FP32_ZERO_NUMBER_AMOUNT = 3;
static const int _TEST_FP32_NONZERO_NUMBER_AMOUNT = 4;
static const int _TEST_FP32_ZERO_NUMBERS_AMOUNT = 3;
static const int _TEST_FP32_NONZERO_NUMBERS_AMOUNT = 4;
static const float _TEST_FP32_ZERO_NUMBER_LIST[] = {
static const float _TEST_FP32_ZERO_NUMBERS[] = {
0.0f,
0.75f * BGC_EPSYLON_FP32,
-0.75f * BGC_EPSYLON_FP32
};
static const float _TEST_FP32_NONZERO_NUMBER_LIST[] = {
static const float _TEST_FP32_NONZERO_NUMBERS[] = {
1.0f,
-1.0f,
1.25f * BGC_EPSYLON_FP32,
@ -25,17 +25,17 @@ void test_is_zero_fp32()
print_testing_name("bgc_is_zero_fp32");
// Testing zero values:
for (int i = 0; i < _TEST_FP32_ZERO_NUMBER_AMOUNT; i++) {
if (!bgc_is_zero_fp32(_TEST_FP32_ZERO_NUMBER_LIST[i])) {
print_testing_failed("A zero value was not recognized");
for (int i = 0; i < _TEST_FP32_ZERO_NUMBERS_AMOUNT; i++) {
if (!bgc_is_zero_fp32(_TEST_FP32_ZERO_NUMBERS[i])) {
print_testing_error("A zero value was not recognized");
return;
}
}
// Testing non-zero values:
for (int i = 0; i < _TEST_FP32_NONZERO_NUMBER_AMOUNT; i++) {
if (bgc_is_zero_fp32(_TEST_FP32_NONZERO_NUMBER_LIST[i])) {
print_testing_failed("A non-zero value was recognized as a zero value");
for (int i = 0; i < _TEST_FP32_NONZERO_NUMBERS_AMOUNT; i++) {
if (bgc_is_zero_fp32(_TEST_FP32_NONZERO_NUMBERS[i])) {
print_testing_error("A non-zero value was recognized as a zero value");
return;
}
}
@ -45,16 +45,16 @@ void test_is_zero_fp32()
// ==================== FP64 ==================== //
static const int _TEST_FP64_ZERO_NUMBER_AMOUNT = 3;
static const int _TEST_FP64_NONZERO_NUMBER_AMOUNT = 4;
static const int _TEST_FP64_ZERO_NUMBERS_AMOUNT = 3;
static const int _TEST_FP64_NONZERO_NUMBERS_AMOUNT = 4;
static const double _TEST_FP64_ZERO_NUMBER_LIST[] = {
static const double _TEST_FP64_ZERO_NUMBERS[] = {
0.0,
0.75 * BGC_EPSYLON_FP64,
-0.75 * BGC_EPSYLON_FP64
};
static const double _TEST_FP64_NONZERO_NUMBER_LIST[] = {
static const double _TEST_FP64_NONZERO_NUMBERS[] = {
1.0,
-1.0,
1.25 * BGC_EPSYLON_FP64,
@ -66,17 +66,17 @@ void test_is_zero_fp64()
print_testing_name("bgc_is_zero_fp64");
// Testing zero values:
for (int i = 0; i < _TEST_FP64_ZERO_NUMBER_AMOUNT; i++) {
if (!bgc_is_zero_fp64(_TEST_FP64_ZERO_NUMBER_LIST[i])) {
print_testing_failed("A zero value was not recognized");
for (int i = 0; i < _TEST_FP64_ZERO_NUMBERS_AMOUNT; i++) {
if (!bgc_is_zero_fp64(_TEST_FP64_ZERO_NUMBERS[i])) {
print_testing_error("A zero value was not recognized");
return;
}
}
// Testing non-zero values:
for (int i = 0; i < _TEST_FP64_NONZERO_NUMBER_AMOUNT; i++) {
if (bgc_is_zero_fp64(_TEST_FP64_NONZERO_NUMBER_LIST[i])) {
print_testing_failed("A non zero value was recognized as a zero value");