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

basic-geometry-test/helpers.c

@@ -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);
 }

basic-geometry-test/helpers.h

@@ -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

basic-geometry-test/main.c

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

basic-geometry-test/tests/quaternion.c

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

basic-geometry-test/tests/quaternion.h

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

basic-geometry-test/tests/quaternion/quaternion_copy.c

@@ -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) {
+    test_quaternion_copy_fp32();
-        return TEST_FAILED;
+    test_quaternion_copy_fp64();
-    }
-
-    if (test_quaternion_copy_fp64() != TEST_SUCCESS) {
-        return TEST_FAILED;
-    }
-
-    return TEST_SUCCESS;
 }

basic-geometry-test/tests/quaternion/quaternion_copy.h

@@ -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

basic-geometry-test/tests/quaternion/quaternion_is_unit.c

@@ -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();
+            print_testing_error("A unit quaternion was not recognized");
-            return TEST_FAILED;
+            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();
+            print_testing_error("A non-unit quaternion was recognized a unit quaternion");
-            return TEST_FAILED;
+            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();
+            print_testing_error("A unit quaternion was not recognized");
-            return TEST_FAILED;
+            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();
+            print_testing_error("A non-unit quaternion was recognized a unit quaternion");
-            return TEST_FAILED;
+            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) {
+    test_quaternion_is_unit_fp32();
-        return TEST_FAILED;
+    test_quaternion_is_unit_fp64();
-    }
-
-    if (test_quaternion_is_unit_fp64() != TEST_SUCCESS) {
-        return TEST_FAILED;
-    }
-
-    return TEST_SUCCESS;
 }

basic-geometry-test/tests/quaternion/quaternion_is_unit.h

@@ -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

basic-geometry-test/tests/quaternion/quaternion_is_zero.c

@@ -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();
+            print_testing_error("A zero quaternion was not recognized");
-            return TEST_FAILED;
+            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();
+            print_testing_error("A non-zero quaternion was recognized as a zero quaternion");
-            return TEST_FAILED;
+            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();
+            print_testing_error("A zero quaternion was not recognized");
-            return TEST_FAILED;
+            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();
+            print_testing_error("A non-zero quaternion was recognized as a zero quaternion");
-            return TEST_FAILED;
+            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) {
+    test_quaternion_is_zero_fp32();
-        return TEST_FAILED;
+    test_quaternion_is_zero_fp64();
-    }
-
-    if (test_quaternion_is_zero_fp64() != TEST_SUCCESS) {
-        return TEST_FAILED;
-    }
-
-    return TEST_SUCCESS;
 }

basic-geometry-test/tests/quaternion/quaternion_is_zero.h

@@ -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

basic-geometry-test/tests/quaternion/quaternion_reset.c

@@ -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) {
+    test_quaternion_reset_fp32();
-        return TEST_FAILED;
+    test_quaternion_reset_fp64();
-    }
-
-    if (test_quaternion_reset_fp64() != TEST_SUCCESS) {
-        return TEST_FAILED;
-    }
-
-    return TEST_SUCCESS;
 }

basic-geometry-test/tests/quaternion/quaternion_reset.h

@@ -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

basic-geometry-test/tests/quaternion/quaternion_set_to_identity.c

@@ -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) {
+    test_quaternion_set_to_identity_fp32();
-        return TEST_FAILED;
+    test_quaternion_set_to_identity_fp64();
-    }
-
-    if (test_quaternion_set_to_identity_fp64() != TEST_SUCCESS) {
-        return TEST_FAILED;
-    }
-
-    return TEST_SUCCESS;
 }

basic-geometry-test/tests/quaternion/quaternion_set_to_identity.h

@@ -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

basic-geometry-test/tests/quaternion/quaternion_set_values.c

@@ -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();
+        print_testing_error("First step failed");
-        return TEST_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();
+        print_testing_error("Second step failed");
-        return TEST_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();
+        print_testing_error("Third step failed");
-        return TEST_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();
+        print_testing_error("First step failed");
-        return TEST_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();
+        print_testing_error("Second step failed");
-        return TEST_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();
+        print_testing_error("Third step failed");
-        return TEST_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) {
+    test_quaternion_set_values_fp32();
-        return TEST_FAILED;
+    test_quaternion_set_values_fp64();
-    }
-
-    if (test_quaternion_set_values_fp64() != TEST_SUCCESS) {
-        return TEST_FAILED;
-    }
-
-    return TEST_SUCCESS;
 }

basic-geometry-test/tests/quaternion/quaternion_set_values.h

@@ -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

basic-geometry-test/tests/quaternion/quaternion_square_modulus.c

@@ -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) {
+    test_quaternion_square_modulus_fp32();
-        return TEST_FAILED;
+    test_quaternion_square_modulus_fp64();
-    }
-
-    if (test_quaternion_square_modulus_fp64() != TEST_SUCCES) {
-        return TEST_FAILED;
-    }
-
-    return TEST_SUCCES;
 }

basic-geometry-test/tests/quaternion/quaternion_square_modulus.h

@@ -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

basic-geometry-test/tests/quaternion/quaternion_swap.c

@@ -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) {
+    test_quaternion_swap_fp32();
-        return TEST_FAILED;
+    test_quaternion_swap_fp64();
-    }
-
-    if (test_quaternion_swap_fp64() != TEST_SUCCESS) {
-        return TEST_FAILED;
-    }
-
-    return TEST_SUCCESS;
 }

basic-geometry-test/tests/quaternion/quaternion_swap.h

@@ -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

basic-geometry-test/tests/utilities/are_close.c

@@ -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();
+            print_testing_error("A pair of close numbers was not recognized");
-            return TEST_FAILED;
+            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();
+            print_testing_error("A pair of close numbers was not recognized");
-            return TEST_FAILED;
+            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;