Добавленные модульные тесты для модулей двумерных и трёхмерных векторов и кватернионов

basic-geometry-test/tests/quaternion.c

@@ -11,4 +11,5 @@ void test_quaternion()
     test_quaternion_swap();
     test_quaternion_is_zero();
     test_quaternion_is_unit();
+    test_quaternion_modulus();
 }

basic-geometry-test/tests/quaternion.h

@@ -9,6 +9,7 @@
 #include "./quaternion/quaternion_swap.h"
 #include "./quaternion/quaternion_is_zero.h"
 #include "./quaternion/quaternion_is_unit.h"
+#include "./quaternion/quaternion_modulus.h"
 
 void test_quaternion();
 

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

@@ -0,0 +1,117 @@
+#include "./quaternion_modulus.h"
+
+#include "./../../helpers.h"
+
+// ==================== FP32 ==================== //
+
+static const int _TEST_FP32_QUATERNION_AMOUNT = 4;
+
+static const BgcQuaternionFP32 _TEST_FP32_QUATERNION_LIST[] = {
+    { 0.0f, 4.0f, 3.0f, 0.0f },
+    { -1.0f, 1.0f, -1.0f, 1.0f },
+    { 100.0f, -100.0f, 0.0f, 100.0f },
+    { -0.86602540378f, 0.5f, -1.0f, 1.0f }
+};
+
+static const float _TEST_FP32_SQUARE_MODULUS_LIST[] = {
+    25.0f,
+    4.0f,
+    30000.0f,
+    3.0f
+};
+
+static const float _TEST_FP32_MODULUS_LIST[] = {
+    5.0f,
+    2.0f,
+    173.20508076f,
+    1.7320508076f
+};
+
+void test_quaternion_square_modulus_fp32()
+{
+    print_testing_name("bgc_quaternion_get_square_modulus_fp32");
+
+    for (int i = 0; i < _TEST_FP32_QUATERNION_AMOUNT; i++) {
+        if (!bgc_are_close_fp32(bgc_quaternion_get_square_modulus_fp32(&_TEST_FP32_QUATERNION_LIST[i]), _TEST_FP32_SQUARE_MODULUS_LIST[i])) {
+            print_testing_failed();
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+void test_quaternion_modulus_fp32()
+{
+    print_testing_name("bgc_quaternion_get_modulus_fp32");
+
+    for (int i = 0; i < _TEST_FP32_QUATERNION_AMOUNT; i++) {
+        if (!bgc_are_close_fp32(bgc_quaternion_get_modulus_fp32(&_TEST_FP32_QUATERNION_LIST[i]), _TEST_FP32_MODULUS_LIST[i])) {
+            print_testing_failed();
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+// ==================== FP64 ==================== //
+
+static const int _TEST_FP64_QUATERNION_AMOUNT = 4;
+
+static const BgcQuaternionFP64 _TEST_FP64_QUATERNION_LIST[] = {
+    { 0.0, 4.0, 3.0, 0.0 },
+    { -1.0, 1.0, -1.0, 1.0 },
+    { 100.0, -100.0, 0.0, 100.0 },
+    { -0.866025403784438647, 0.5, -1.0, 1.0 }
+};
+
+static const double _TEST_FP64_SQUARE_MODULUS_LIST[] = {
+    25.0,
+    4.0,
+    30000.0,
+    3.0
+};
+
+static const double _TEST_FP64_MODULUS_LIST[] = {
+    5.0,
+    2.0,
+    173.20508075688772935,
+    1.7320508075688772935
+};
+
+void test_quaternion_square_modulus_fp64()
+{
+    print_testing_name("bgc_quaternion_get_square_modulus_fp64");
+
+    for (int i = 0; i < _TEST_FP64_QUATERNION_AMOUNT; i++) {
+        if (!bgc_are_close_fp64(bgc_quaternion_get_square_modulus_fp64(&_TEST_FP64_QUATERNION_LIST[i]), _TEST_FP64_SQUARE_MODULUS_LIST[i])) {
+            print_testing_failed();
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+void test_quaternion_modulus_fp64()
+{
+    print_testing_name("bgc_quaternion_get_modulus_fp64");
+
+    for (int i = 0; i < _TEST_FP64_QUATERNION_AMOUNT; i++) {
+        if (!bgc_are_close_fp64(bgc_quaternion_get_modulus_fp64(&_TEST_FP64_QUATERNION_LIST[i]), _TEST_FP64_MODULUS_LIST[i])) {
+            print_testing_failed();
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+void test_quaternion_modulus()
+{
+    test_quaternion_square_modulus_fp32();
+    test_quaternion_square_modulus_fp64();
+    test_quaternion_modulus_fp32();
+    test_quaternion_modulus_fp64();
+}

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

@@ -0,0 +1,14 @@
+#ifndef _TEST_QUATERNION_MODULUS_H_
+#define _TEST_QUATERNION_MODULUS_H_
+
+void test_quaternion_square_modulus_fp32();
+
+void test_quaternion_square_modulus_fp64();
+
+void test_quaternion_modulus_fp32();
+
+void test_quaternion_modulus_fp64();
+
+void test_quaternion_modulus();
+
+#endif

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

@@ -1,23 +0,0 @@
-#include "./quaternion_square_modulus.h"
-
-#include "./../../helpers.h"
-
-void test_quaternion_square_modulus_fp32()
-{
-    print_testing_name("bgc_quaternion_is_zero_fp32");
-
-    print_testing_success();
-}
-
-void test_quaternion_square_modulus_fp64()
-{
-    print_testing_name("bgc_quaternion_is_zero_fp64");
-
-    print_testing_success();
-}
-
-void test_quaternion_square_modulus()
-{
-    test_quaternion_square_modulus_fp32();
-    test_quaternion_square_modulus_fp64();
-}

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

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

basic-geometry-test/tests/vector2.c

@@ -10,6 +10,7 @@ void test_vector2()
     test_vector2_swap();
     test_vector2_is_zero();
     test_vector2_is_unit();
+    test_vector2_modulus();
 }
 
 

basic-geometry-test/tests/vector2.h

@@ -8,6 +8,7 @@
 #include "./vector2/vector2_swap.h"
 #include "./vector2/vector2_is_zero.h"
 #include "./vector2/vector2_is_unit.h"
+#include "./vector2/vector2_modulus.h"
 
 void test_vector2();
 

basic-geometry-test/tests/vector2/vector2_modulus.c

@@ -0,0 +1,117 @@
+#include "./vector2_modulus.h"
+
+#include "./../../helpers.h"
+
+// ==================== FP32 ==================== //
+
+static const int _TEST_FP32_VECTOR2_AMOUNT = 4;
+
+static const BgcVector2FP32 _TEST_FP32_VECTOR2_LIST[] = {
+    { 4.0f, 3.0f },
+    { -3.0f, -4.0f },
+    { 100.0f, -100.0f },
+    { -0.86602540378f, 0.5f }
+};
+
+static const float _TEST_FP32_SQUARE_MODULUS_LIST[] = {
+    25.0f,
+    25.0f,
+    20000.0f,
+    1.0f
+};
+
+static const float _TEST_FP32_MODULUS_LIST[] = {
+    5.0f,
+    5.0f,
+    141.4213562373f,
+    1.0f
+};
+
+void test_vector2_square_modulus_fp32()
+{
+    print_testing_name("bgc_vector2_get_square_modulus_fp32");
+
+    for (int i = 0; i < _TEST_FP32_VECTOR2_AMOUNT; i++) {
+        if (!bgc_are_close_fp32(bgc_vector2_get_square_modulus_fp32(&_TEST_FP32_VECTOR2_LIST[i]), _TEST_FP32_SQUARE_MODULUS_LIST[i])) {
+            print_testing_failed();
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+void test_vector2_modulus_fp32()
+{
+    print_testing_name("bgc_vector2_get_modulus_fp32");
+
+    for (int i = 0; i < _TEST_FP32_VECTOR2_AMOUNT; i++) {
+        if (!bgc_are_close_fp32(bgc_vector2_get_modulus_fp32(&_TEST_FP32_VECTOR2_LIST[i]), _TEST_FP32_MODULUS_LIST[i])) {
+            print_testing_failed();
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+// ==================== FP64 ==================== //
+
+static const int _TEST_FP64_VECTOR2_AMOUNT = 4;
+
+static const BgcVector2FP64 _TEST_FP64_VECTOR2_LIST[] = {
+    { 4.0, 3.0 },
+    { -3.0, -4.0 },
+    { 100.0, -100.0 },
+    { -0.866025403784438647, 0.5 }
+};
+
+static const double _TEST_FP64_SQUARE_MODULUS_LIST[] = {
+    25.0,
+    25.0,
+    20000.0,
+    1.0
+};
+
+static const double _TEST_FP64_MODULUS_LIST[] = {
+    5.0,
+    5.0,
+    141.42135623730950488,
+    1.0
+};
+
+void test_vector2_square_modulus_fp64()
+{
+    print_testing_name("bgc_vector2_get_square_modulus_fp64");
+
+    for (int i = 0; i < _TEST_FP64_VECTOR2_AMOUNT; i++) {
+        if (!bgc_are_close_fp64(bgc_vector2_get_square_modulus_fp64(&_TEST_FP64_VECTOR2_LIST[i]), _TEST_FP64_SQUARE_MODULUS_LIST[i])) {
+            print_testing_failed();
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+void test_vector2_modulus_fp64()
+{
+    print_testing_name("bgc_vector2_get_modulus_fp64");
+
+    for (int i = 0; i < _TEST_FP64_VECTOR2_AMOUNT; i++) {
+        if (!bgc_are_close_fp64(bgc_vector2_get_modulus_fp64(&_TEST_FP64_VECTOR2_LIST[i]), _TEST_FP64_MODULUS_LIST[i])) {
+            print_testing_failed();
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+void test_vector2_modulus()
+{
+    test_vector2_square_modulus_fp32();
+    test_vector2_square_modulus_fp64();
+    test_vector2_modulus_fp32();
+    test_vector2_modulus_fp64();
+}

basic-geometry-test/tests/vector2/vector2_modulus.h

@@ -0,0 +1,14 @@
+#ifndef _TEST_VECTOR2_MODULUS_H_
+#define _TEST_VECTOR2_MODULUS_H_
+
+void test_vector2_square_modulus_fp32();
+
+void test_vector2_square_modulus_fp64();
+
+void test_vector2_modulus_fp32();
+
+void test_vector2_modulus_fp64();
+
+void test_vector2_modulus();
+
+#endif

basic-geometry-test/tests/vector3.c

@@ -10,4 +10,5 @@ void test_vector3()
     test_vector3_swap();
     test_vector3_is_zero();
     test_vector3_is_unit();
+    test_vector3_modulus();
 }

basic-geometry-test/tests/vector3.h

@@ -8,6 +8,7 @@
 #include "./vector3/vector3_swap.h"
 #include "./vector3/vector3_is_zero.h"
 #include "./vector3/vector3_is_unit.h"
+#include "./vector3/vector3_modulus.h"
 
 void test_vector3();
 

basic-geometry-test/tests/vector3/vector3_modulus.c

@@ -0,0 +1,117 @@
+#include "./vector3_modulus.h"
+
+#include "./../../helpers.h"
+
+// ==================== FP32 ==================== //
+
+static const int _TEST_FP32_VECTOR3_AMOUNT = 4;
+
+static const BgcVector3FP32 _TEST_FP32_VECTOR3_LIST[] = {
+    { 4.0f, 3.0f, 0.0f },
+    { 0.0f, -3.0f, -4.0f },
+    { 100.0f, -100.0f, 100.0f },
+    { -0.86602540378f, 0.5f, -1.0f }
+};
+
+static const float _TEST_FP32_SQUARE_MODULUS_LIST[] = {
+    25.0f,
+    25.0f,
+    30000.0f,
+    2.0f
+};
+
+static const float _TEST_FP32_MODULUS_LIST[] = {
+    5.0f,
+    5.0f,
+    173.20508076f,
+    1.4142135624f
+};
+
+void test_vector3_square_modulus_fp32()
+{
+    print_testing_name("bgc_vector3_get_square_modulus_fp32");
+
+    for (int i = 0; i < _TEST_FP32_VECTOR3_AMOUNT; i++) {
+        if (!bgc_are_close_fp32(bgc_vector3_get_square_modulus_fp32(&_TEST_FP32_VECTOR3_LIST[i]), _TEST_FP32_SQUARE_MODULUS_LIST[i])) {
+            print_testing_failed();
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+void test_vector3_modulus_fp32()
+{
+    print_testing_name("bgc_vector3_get_modulus_fp32");
+
+    for (int i = 0; i < _TEST_FP32_VECTOR3_AMOUNT; i++) {
+        if (!bgc_are_close_fp32(bgc_vector3_get_modulus_fp32(&_TEST_FP32_VECTOR3_LIST[i]), _TEST_FP32_MODULUS_LIST[i])) {
+            print_testing_failed();
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+// ==================== FP64 ==================== //
+
+static const int _TEST_FP64_VECTOR3_AMOUNT = 4;
+
+static const BgcVector3FP64 _TEST_FP64_VECTOR3_LIST[] = {
+    { 0.0, 4.0, 3.0 },
+    { -3.0, 0.0, -4.0 },
+    { 100.0, -100.0, 100.0 },
+    { -0.866025403784438647, 0.5, 1.0 }
+};
+
+static const double _TEST_FP64_SQUARE_MODULUS_LIST[] = {
+    25.0,
+    25.0,
+    30000.0,
+    2.0
+};
+
+static const double _TEST_FP64_MODULUS_LIST[] = {
+    5.0,
+    5.0,
+    173.20508075688772935,
+    1.4142135623730950488
+};
+
+void test_vector3_square_modulus_fp64()
+{
+    print_testing_name("bgc_vector3_get_square_modulus_fp64");
+
+    for (int i = 0; i < _TEST_FP64_VECTOR3_AMOUNT; i++) {
+        if (!bgc_are_close_fp64(bgc_vector3_get_square_modulus_fp64(&_TEST_FP64_VECTOR3_LIST[i]), _TEST_FP64_SQUARE_MODULUS_LIST[i])) {
+            print_testing_failed();
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+void test_vector3_modulus_fp64()
+{
+    print_testing_name("bgc_vector3_get_modulus_fp64");
+
+    for (int i = 0; i < _TEST_FP64_VECTOR3_AMOUNT; i++) {
+        if (!bgc_are_close_fp64(bgc_vector3_get_modulus_fp64(&_TEST_FP64_VECTOR3_LIST[i]), _TEST_FP64_MODULUS_LIST[i])) {
+            print_testing_failed();
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+void test_vector3_modulus()
+{
+    test_vector3_square_modulus_fp32();
+    test_vector3_square_modulus_fp64();
+    test_vector3_modulus_fp32();
+    test_vector3_modulus_fp64();
+}

basic-geometry-test/tests/vector3/vector3_modulus.h

@@ -0,0 +1,14 @@
+#ifndef _TEST_VECTOR3_MODULUS_H_
+#define _TEST_VECTOR3_MODULUS_H_
+
+void test_vector3_square_modulus_fp32();
+
+void test_vector3_square_modulus_fp64();
+
+void test_vector3_modulus_fp32();
+
+void test_vector3_modulus_fp64();
+
+void test_vector3_modulus();
+
+#endif