feat: add all vector tests

include/math/vector4.h

@@ -2,24 +2,25 @@
 #define VECTOR4_H
 
 typedef struct {
-    float x;
-    float y;
-    float z;
-    float w;
+    float x, y, z, w;
 } Vec4;
 
 Vec4* vec4(float x, float y, float z, float w);
+
 Vec4* vec4Add(Vec4* v1, Vec4* v2);
 Vec4* vec4Sub(Vec4* v1, Vec4* v2);
 Vec4* vec4Scale(Vec4* v, float scalar);
+
 float vec4Dot(Vec4* a, Vec4* b);
 float vec4Len(Vec4* v);
+
 Vec4* vec4Norm(Vec4* v);
 Vec4* vec4Lerp(Vec4* a, Vec4* b, float t);
 float vec4Angle(Vec4* a, Vec4* b);
 Vec4* vec4Proj(Vec4* a, Vec4* b);
 Vec4* vec4Refl(Vec4* v, Vec4* normal);
 float vec4Dist(Vec4* a, Vec4* b);
+
 void vec4Free(Vec4* v);
 
 

test/test_main.c

@@ -1,15 +1,39 @@
-#include "test_vec3.h"
+#include "test_vec.h"
 
 #include <stdio.h>
 
 int main() {
-    addVector3_test();
-    subVector3_test();
-    scaleVector3_test();
-    dotVector3_test();
-    lenVector3_test();
-    normVector3_test();
-    distVector3_test();
+
+    // --- Vector3 ---
+    
+    void addVector3_test();
+    void subVector3_test();
+    void scaleVector3_test();
+    void dotVector3_test();
+    void lenVector3_test();
+    void normVector3_test();
+    void lerpVector3_test();
+    void anglVector3_test();
+    void projVector3_test();
+    void reflVector3_test();
+    void distVector3_test();
     printf("All Vector3 tests succeeded\n");
+
+    // --- Vector4 ---
+    
+    void addVector4_test();
+    void subVector4_test();
+    void scaleVector4_test();
+    void dotVector4_test();
+    void lenVector4_test();
+    void normVector4_test();
+    void lerpVector4_test();
+    void anglVector4_test();
+    void projVector4_test();
+    void reflVector4_test();
+    void distVector4_test();
+    printf("All Vector4 tests succeeded\n");
+
+    printf("All tests succeeded\n");
     return 0;
 }

test/test_vec.c

@@ -0,0 +1,204 @@
+#include <assert.h>
+#include <stdio.h>
+#include <math.h>
+
+#include "math/vector.h"
+#include "test_vec.h"
+
+void printVector3(const Vec3* v) {
+    printf("Vec3: [%f, %f, %f]\n", v->x, v->y, v->z);
+}
+
+void printVector4(const Vec4* v) {
+    printf("Vec4: [%f, %f, %f, %f]\n", v->x, v->y, v->z, v->w);
+}
+
+// --- Tests Vec3 ---
+
+void addVector3_test() {
+    Vec3 a = {1, 2, 3};
+    Vec3 b = {4, 5, 6};
+    Vec3* r = vec3Add(&a, &b);
+    printVector3(r);
+    assert(r->x == 5 && r->y == 7 && r->z == 9);
+    vec3Free(r);
+}
+
+void subVector3_test() {
+    Vec3 a = {5, 6, 7};
+    Vec3 b = {1, 2, 3};
+    Vec3* r = vec3Sub(&a, &b);
+    printVector3(r);
+    assert(r->x == 4 && r->y == 4 && r->z == 4);
+    vec3Free(r);
+}
+
+void scaleVector3_test() {
+    Vec3 a = {1, 2, 3};
+    Vec3* r = vec3Scale(&a, 2);
+    printVector3(r);
+    assert(r->x == 2 && r->y == 4 && r->z == 6);
+    vec3Free(r);
+}
+
+void dotVector3_test() {
+    Vec3 a = {1, 2, 3};
+    Vec3 b = {4, 5, 6};
+    float result = vec3Dot(&a, &b);
+    printf("Dot product: %f\n", result);
+    assert(result == 32);
+}
+
+void lenVector3_test() {
+    Vec3 a = {1, 2, 2};
+    float result = vec3Len(&a);
+    printf("Length: %f\n", result);
+    assert(fabs(result - 3) < 0.0001f);
+}
+
+void normVector3_test() {
+    Vec3 a = {3, 4, 0};
+    Vec3* r = vec3Norm(&a);
+    printVector3(r);
+    assert(fabs(r->x - 0.6f) < 0.0001f);
+    assert(fabs(r->y - 0.8f) < 0.0001f);
+    vec3Free(r);
+}
+
+void lerpVector3_test() {
+    Vec3 a = {0, 0, 0};
+    Vec3 b = {10, 10, 10};
+    Vec3* r = vec3Lerp(&a, &b, 0.5f);
+    printVector3(r);
+    assert(r->x == 5 && r->y == 5 && r->z == 5);
+    vec3Free(r);
+}
+
+void anglVector3_test() {
+    Vec3 a = {1, 0, 0};
+    Vec3 b = {0, 1, 0};
+    float result = vec3Angle(&a, &b);
+    printf("Angle: %f radians\n", result);
+    assert(fabs(result - (M_PI / 2)) < 0.0001f);
+}
+
+void projVector3_test() {
+    Vec3 a = {3, 4, 0};
+    Vec3 b = {1, 0, 0};
+    Vec3* r = vec3Proj(&a, &b);
+    printVector3(r);
+    assert(r->x == 3 && r->y == 0 && r->z == 0);
+    vec3Free(r);
+}
+
+void reflVector3_test() {
+    Vec3 v = {1, -1, 0};
+    Vec3 normal = {0, 1, 0};
+    Vec3* r = vec3Refl(&v, &normal);
+    printVector3(r);
+    assert(r->x == 1 && r->y == 1 && r->z == 0);
+    vec3Free(r);
+}
+
+void distVector3_test() {
+    Vec3 a = {1, 2, 3};
+    Vec3 b = {4, 5, 6};
+    float result = vec3Dist(&a, &b);
+    printf("Distance: %f\n", result);
+    assert(fabs(result - 5.1962f) < 0.0001f);
+}
+
+// --- Tests Vec4 ---
+
+void addVector4_test() {
+    Vec4 a = {1, 2, 3, 4};
+    Vec4 b = {4, 5, 6, 7};
+    Vec4* r = vec4Add(&a, &b);
+    printVector4(r);
+    assert(r->x == 5 && r->y == 7 && r->z == 9 && r->w == 11);
+    vec4Free(r);
+}
+
+void subVector4_test() {
+    Vec4 a = {5, 6, 7, 8};
+    Vec4 b = {1, 2, 3, 4};
+    Vec4* r = vec4Sub(&a, &b);
+    printVector4(r);
+    assert(r->x == 4 && r->y == 4 && r->z == 4 && r->w == 4);
+    vec4Free(r);
+}
+
+void scaleVector4_test() {
+    Vec4 a = {1, 2, 3, 4};
+    Vec4* r = vec4Scale(&a, 2);
+    printVector4(r);
+    assert(r->x == 2 && r->y == 4 && r->z == 6 && r->w == 8);
+    vec4Free(r);
+}
+
+void dotVector4_test() {
+    Vec4 a = {1, 2, 3, 4};
+    Vec4 b = {4, 5, 6, 7};
+    float result = vec4Dot(&a, &b);
+    printf("Dot product: %f\n", result);
+    assert(result == (1 * 4 + 2 * 5 + 3 * 6 + 4 * 7));
+}
+
+void lenVector4_test() {
+    Vec4 a = {1, 2, 2, 1};
+    float result = vec4Len(&a);
+    printf("Length: %f\n", result);
+    assert(fabs(result - sqrtf(10)) < 0.0001f);
+}
+
+void normVector4_test() {
+    Vec4 a = {3, 4, 0, 0};
+    Vec4* r = vec4Norm(&a);
+    printVector4(r);
+    assert(fabs(r->x - (3.0f / 5.0f)) < 0.0001f);
+    assert(fabs(r->y - (4.0f / 5.0f)) < 0.0001f);
+    vec4Free(r);
+}
+
+void lerpVector4_test() {
+    Vec4 a = {0, 0, 0, 0};
+    Vec4 b = {10, 10, 10, 10};
+    Vec4* r = vec4Lerp(&a, &b, 0.5f);
+    printVector4(r);
+    assert(r->x == 5 && r->y == 5 && r->z == 5 && r->w == 5);
+    vec4Free(r);
+}
+
+void distVector4_test() {
+    Vec4 a = {1, 2, 3, 4};
+    Vec4 b = {4, 5, 6, 7};
+    float result = vec4Dist(&a, &b);
+    printf("Distance: %f\n", result);
+    assert(fabs(result - sqrtf(12)) < 0.0001f);
+}
+
+void anglVector4_test() {
+    Vec4 a = {1, 0, 0, 0};
+    Vec4 b = {0, 1, 0, 0};
+    float result = vec4Angle(&a, &b);
+    printf("Angle: %f radians\n", result);
+    assert(fabs(result - (M_PI / 2)) < 0.0001f);
+}
+
+void projVector4_test() {
+    Vec4 a = {3, 4, 0, 0};
+    Vec4 b = {1, 0, 0, 0};
+    Vec4* r = vec4Proj(&a, &b);
+    printVector4(r);
+    assert(r->x == 3 && r->y == 0 && r->z == 0 && r->w == 0);
+    vec4Free(r);
+}
+
+void reflVector4_test() {
+    Vec4 v = {1, -1, 0, 0};
+    Vec4 normal = {0, 1, 0, 0};
+    Vec4* r = vec4Refl(&v, &normal);
+    printVector4(r);
+    assert(r->x == 1 && r->y == 1 && r->z == 0 && r->w == 0);
+    vec4Free(r);
+}

test/test_vec.h

@@ -0,0 +1,32 @@
+#ifndef TEST_V4
+#define TEST_V4
+
+// --- Vector3 ---
+
+void addVector3_test();
+void subVector3_test();
+void scaleVector3_test();
+void dotVector3_test();
+void lenVector3_test();
+void normVector3_test();
+void lerpVector3_test();
+void anglVector3_test();
+void projVector3_test();
+void reflVector3_test();
+void distVector3_test();
+
+// --- Vector4 ---
+
+void addVector4_test();
+void subVector4_test();
+void scaleVector4_test();
+void dotVector4_test();
+void lenVector4_test();
+void normVector4_test();
+void lerpVector4_test();
+void anglVector4_test();
+void projVector4_test();
+void reflVector4_test();
+void distVector4_test();
+
+#endif // TEST_V4

test/test_vec3.c

@@ -1,112 +0,0 @@
-#include <assert.h>
-#include <stdio.h>
-#include <math.h>
-
-#include "math/vector3.h"
-#include "test_vec3.h"
-
-void printVector3(const Vec3* v) {
-    if (!v) {
-        printf("Vector is NULL\n");
-        return;
-    }
-    printf("Vector: [%f, %f, %f]\n", v->x, v->y, v->z);
-}
-
-void addVector3_test() {
-    printf("Test: Add Vector 3D\n");
-
-    Vec3 a = {1.0f, 2.0f, 3.0f};
-    Vec3 b = {4.0f, 5.0f, 6.0f};
-
-    Vec3* result = vec3Add(&a, &b);
-    printVector3(result);
-
-    assert(result->x == 5.0f);
-    assert(result->y == 7.0f);
-    assert(result->z == 9.0f);
-
-    vec3Free(result);
-}
-
-void subVector3_test() {
-    printf("Test: Subtract Vector 3D\n");
-
-    Vec3 a = {5.0f, 6.0f, 7.0f};
-    Vec3 b = {1.0f, 2.0f, 3.0f};
-
-    Vec3* result = vec3Sub(&a, &b);
-    printVector3(result);
-
-    assert(result->x == 4.0f);
-    assert(result->y == 4.0f);
-    assert(result->z == 4.0f);
-
-    vec3Free(result);
-}
-
-void scaleVector3_test() {
-    printf("Test: Scale Vector 3D\n");
-
-    Vec3 a = {1.0f, 2.0f, 3.0f};
-    float scalar = 2.0f;
-
-    Vec3* result = vec3Scale(&a, scalar);
-    printVector3(result);
-
-    assert(result->x == 2.0f);
-    assert(result->y == 4.0f);
-    assert(result->z == 6.0f);
-
-    vec3Free(result);
-}
-
-void dotVector3_test() {
-    printf("Test: Dot Product Vector 3D\n");
-
-    Vec3 a = {1.0f, 2.0f, 3.0f};
-    Vec3 b = {4.0f, 5.0f, 6.0f};
-
-    float result = vec3Dot(&a, &b);
-    printf("Dot product: %f\n", result);
-
-    assert(result == 32.0f);
-}
-
-void lenVector3_test() {
-    printf("Test: Length of Vector 3D\n");
-
-    Vec3 a = {1.0f, 2.0f, 2.0f};
-
-    float result = vec3Len(&a);
-    printf("Length: %f\n", result);
-
-    assert(fabs(result - 3.0f) < 0.0001f);
-}
-
-void normVector3_test() {
-    printf("Test: Normalize Vector 3D\n");
-
-    Vec3 a = {3.0f, 4.0f, 0.0f};
-
-    Vec3* result = vec3Norm(&a);
-    printVector3(result);
-
-    assert(fabs(result->x - 0.6f) < 0.0001f);
-    assert(fabs(result->y - 0.8f) < 0.0001f);
-    assert(fabs(result->z - 0.0f) < 0.0001f);
-
-    vec3Free(result);
-}
-
-void distVector3_test() {
-    printf("Test: Distance between Vector 3D\n");
-
-    Vec3 a = {1.0f, 2.0f, 3.0f};
-    Vec3 b = {4.0f, 5.0f, 6.0f};
-
-    float result = vec3Dist(&a, &b);
-    printf("Distance: %f\n", result);
-
-    assert(fabs(result - 5.1962f) < 0.0001f);
-}

test/test_vec3.h

@@ -1,12 +0,0 @@
-#ifndef TEST_V4
-#define TEST_V4
-
-void addVector3_test();
-void subVector3_test();
-void scaleVector3_test();
-void dotVector3_test();
-void lenVector3_test();
-void normVector3_test();
-void distVector3_test();
-
-#endif // TEST_V4