diff --git a/Test/Vector2.cpp b/Test/Vector2.cpp
index 648fc56..db568ea 100644
--- a/Test/Vector2.cpp
+++ b/Test/Vector2.cpp
@@ -12,7 +12,7 @@ namespace {
 }
 
 // Tests if all values are 0 after initialization via default constructor
-TEST_CASE(__FILE__"/New_Vector_All_0", "[Vector2]")
+TEST_CASE(__FILE__"/New_Vector_All_0", "[Vector][Vector2]")
 {
     Vector2d v2;
 
@@ -23,7 +23,7 @@ TEST_CASE(__FILE__"/New_Vector_All_0", "[Vector2]")
 }
 
 // Tests if values can be set via the constructor
-TEST_CASE(__FILE__"/Can_Set_Values_Constructor", "[Vector2]")
+TEST_CASE(__FILE__"/Can_Set_Values_Constructor", "[Vector][Vector2]")
 {
     Vector2d v2(69, 32);
 
@@ -34,7 +34,7 @@ TEST_CASE(__FILE__"/Can_Set_Values_Constructor", "[Vector2]")
 }
 
 // Tests if values can be set via letters
-TEST_CASE(__FILE__"/Can_Set_Values_Letters", "[Vector2]")
+TEST_CASE(__FILE__"/Can_Set_Values_Letters", "[Vector][Vector2]")
 {
     Vector2d v2;
     v2.x = 69;
@@ -47,7 +47,7 @@ TEST_CASE(__FILE__"/Can_Set_Values_Letters", "[Vector2]")
 }
 
 // Tests if values can be set via array descriptors
-TEST_CASE(__FILE__"/Can_Set_Values_ArrayDescriptor", "[Vector2]")
+TEST_CASE(__FILE__"/Can_Set_Values_ArrayDescriptor", "[Vector][Vector2]")
 {
     Vector2d v2;
     v2[0] = 69;
@@ -60,7 +60,7 @@ TEST_CASE(__FILE__"/Can_Set_Values_ArrayDescriptor", "[Vector2]")
 }
 
 // Tests if values can be set via an initializer list
-TEST_CASE(__FILE__"/Can_Set_Values_InitializerList", "[Vector2]")
+TEST_CASE(__FILE__"/Can_Set_Values_InitializerList", "[Vector][Vector2]")
 {
     Vector2d v2 = {69, 32};
 
@@ -71,7 +71,7 @@ TEST_CASE(__FILE__"/Can_Set_Values_InitializerList", "[Vector2]")
 }
 
 // Tests for vectors copied via the copy constructor to have the same values
-TEST_CASE(__FILE__"/Copy_Constructor_Same_Values", "[Vector2]")
+TEST_CASE(__FILE__"/Copy_Constructor_Same_Values", "[Vector][Vector2]")
 {
     Vector2d a(69, 32);
     Vector2d b(a);
@@ -83,7 +83,7 @@ TEST_CASE(__FILE__"/Copy_Constructor_Same_Values", "[Vector2]")
 }
 
 // Tests for vectors copied via the equals operator to have the same values
-TEST_CASE(__FILE__"/Operator_Equals_Same_Values", "[Vector2]")
+TEST_CASE(__FILE__"/Operator_Equals_Same_Values", "[Vector][Vector2]")
 {
     Vector2d a(69, 32);
     Vector2d b = a;
@@ -95,7 +95,7 @@ TEST_CASE(__FILE__"/Operator_Equals_Same_Values", "[Vector2]")
 }
 
 // Tests for vectors copied via the copy constructor to be modifyable without modifying the original object
-TEST_CASE(__FILE__"/Copy_Constructor_Independent", "[Vector2]")
+TEST_CASE(__FILE__"/Copy_Constructor_Independent", "[Vector][Vector2]")
 {
     Vector2d a(69, 32);
     Vector2d b(a);
@@ -113,7 +113,7 @@ TEST_CASE(__FILE__"/Copy_Constructor_Independent", "[Vector2]")
 }
 
 // Tests for vectors copied via the equals operator to be modifyable without modifying the original object
-TEST_CASE(__FILE__"/Operator_Equals_Independent", "[Vector2]")
+TEST_CASE(__FILE__"/Operator_Equals_Independent", "[Vector][Vector2]")
 {
     Vector2d a(69, 32);
     Vector2d b = a;
@@ -132,7 +132,7 @@ TEST_CASE(__FILE__"/Operator_Equals_Independent", "[Vector2]")
 
 // Tests if the dot product between two vectors angled 90 degrees from one another is 0. It should by definition be 0!
 // Dot products are commutative, so we'll check both directions.
-TEST_CASE(__FILE__"/DotProduct_90deg", "[Vector2]")
+TEST_CASE(__FILE__"/DotProduct_90deg", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 100; i++)
@@ -152,7 +152,7 @@ TEST_CASE(__FILE__"/DotProduct_90deg", "[Vector2]")
 
 // Test if the dot product is positive for two vectors angled less than 90 degrees from another
 // Dot products are commutative, so we'll check both directions.
-TEST_CASE(__FILE__"/DotProduct_LessThan90deg", "[Vector2]")
+TEST_CASE(__FILE__"/DotProduct_LessThan90deg", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -172,7 +172,7 @@ TEST_CASE(__FILE__"/DotProduct_LessThan90deg", "[Vector2]")
 
 // Test if the dot product is negative for two vectors angled greater than 90 degrees from another
 // Dot products are commutative, so we'll check both directions.
-TEST_CASE(__FILE__"/DotProduct_GreaterThan90deg", "[Vector2]")
+TEST_CASE(__FILE__"/DotProduct_GreaterThan90deg", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -191,7 +191,7 @@ TEST_CASE(__FILE__"/DotProduct_GreaterThan90deg", "[Vector2]")
 }
 
 // Tests that the dot product is correct for a known value
-TEST_CASE(__FILE__"/DotProduct_Oracle", "[Vector2]")
+TEST_CASE(__FILE__"/DotProduct_Oracle", "[Vector][Vector2]")
 {
     // Setup
     const Vector2d a(-99, 199);
@@ -207,7 +207,7 @@ TEST_CASE(__FILE__"/DotProduct_Oracle", "[Vector2]")
 }
 
 // Quick and dirty check if the useless int-method is working
-TEST_CASE(__FILE__"/DotProduct_Dirty_Int", "[Vector2]")
+TEST_CASE(__FILE__"/DotProduct_Dirty_Int", "[Vector][Vector2]")
 {
     Vector2i a;
     Vector2i b;
@@ -237,7 +237,7 @@ TEST_CASE(__FILE__"/DotProduct_Dirty_Int", "[Vector2]")
 }
 
 // Tests if the cross product of two vectors of the exact opposite direction is 0
-TEST_CASE(__FILE__"/CrossProduct_Opposite_Direction", "[Vector2]")
+TEST_CASE(__FILE__"/CrossProduct_Opposite_Direction", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -259,7 +259,7 @@ TEST_CASE(__FILE__"/CrossProduct_Opposite_Direction", "[Vector2]")
 }
 
 // Tests if the cross product of two vectors of the exact same direction is 0
-TEST_CASE(__FILE__"/CrossProduct_Same_Direction", "[Vector2]")
+TEST_CASE(__FILE__"/CrossProduct_Same_Direction", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -281,7 +281,7 @@ TEST_CASE(__FILE__"/CrossProduct_Same_Direction", "[Vector2]")
 }
 
 // Tests for the cross product to be positive, if vector b is to the left of a
-TEST_CASE(__FILE__"/CrossProduct_BToTheLeft", "[Vector2]")
+TEST_CASE(__FILE__"/CrossProduct_BToTheLeft", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -303,7 +303,7 @@ TEST_CASE(__FILE__"/CrossProduct_BToTheLeft", "[Vector2]")
 }
 
 // Tests for the cross product to be negative, if vector b is to the left of a
-TEST_CASE(__FILE__"/CrossProduct_BToTheRight", "[Vector2]")
+TEST_CASE(__FILE__"/CrossProduct_BToTheRight", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -325,7 +325,7 @@ TEST_CASE(__FILE__"/CrossProduct_BToTheRight", "[Vector2]")
 }
 
 // Quick and dirty check if the useless int-method is working
-TEST_CASE(__FILE__"/CrossProduct_Dirty_Int", "[Vector2]")
+TEST_CASE(__FILE__"/CrossProduct_Dirty_Int", "[Vector][Vector2]")
 {
     Vector2i a;
     Vector2i b;
@@ -360,7 +360,7 @@ TEST_CASE(__FILE__"/CrossProduct_Dirty_Int", "[Vector2]")
 }
 
 // Tests the SqrMagnitude method to work as expected with random numbers
-TEST_CASE(__FILE__"/SqrMagnitude", "[Vector2]")
+TEST_CASE(__FILE__"/SqrMagnitude", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -376,7 +376,7 @@ TEST_CASE(__FILE__"/SqrMagnitude", "[Vector2]")
 }
 
 // Checks if the int method is working
-TEST_CASE(__FILE__"/SqrMagnitude_Int", "[Vector2]")
+TEST_CASE(__FILE__"/SqrMagnitude_Int", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -392,14 +392,14 @@ TEST_CASE(__FILE__"/SqrMagnitude_Int", "[Vector2]")
 }
 
 // Tests for the length of the vector (0,0) being 0
-TEST_CASE(__FILE__"/Magnitude_Is_0_On_Vec0", "[Vector2]")
+TEST_CASE(__FILE__"/Magnitude_Is_0_On_Vec0", "[Vector][Vector2]")
 {
     REQUIRE(0.0 == Vector2d(0, 0).Magnitude());
     return;
 }
 
 // Tests for a vector of a known length to actually return that
-TEST_CASE(__FILE__"/Magnitude_One_Axis_X", "[Vector2]")
+TEST_CASE(__FILE__"/Magnitude_One_Axis_X", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -413,7 +413,7 @@ TEST_CASE(__FILE__"/Magnitude_One_Axis_X", "[Vector2]")
 }
 
 // Tests for a vector of a known length to actually return that
-TEST_CASE(__FILE__"/Magnitude_One_Axis_Y", "[Vector2]")
+TEST_CASE(__FILE__"/Magnitude_One_Axis_Y", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -427,7 +427,7 @@ TEST_CASE(__FILE__"/Magnitude_One_Axis_Y", "[Vector2]")
 }
 
 // Tests for a known result
-TEST_CASE(__FILE__"/Magnitude", "[Vector2]")
+TEST_CASE(__FILE__"/Magnitude", "[Vector][Vector2]")
 {
     // Ya'll got more of 'dem digits?
     REQUIRE(204.02205763103165736538358032703399658203125 == Vector2d(192, -69).Magnitude());
@@ -435,7 +435,7 @@ TEST_CASE(__FILE__"/Magnitude", "[Vector2]")
 }
 
 // Tests for expected lerp result 0.00
-TEST_CASE(__FILE__"/Lerp_000", "[Vector2]")
+TEST_CASE(__FILE__"/Lerp_000", "[Vector][Vector2]")
 {
     const Vector2d a(100, 1000);
     const Vector2d b(200, 4000);
@@ -447,7 +447,7 @@ TEST_CASE(__FILE__"/Lerp_000", "[Vector2]")
 }
 
 // Tests for expected lerp result 0.25
-TEST_CASE(__FILE__"/Lerp_025", "[Vector2]")
+TEST_CASE(__FILE__"/Lerp_025", "[Vector][Vector2]")
 {
     const Vector2d a(100, 1000);
     const Vector2d b(200, 4000);
@@ -459,7 +459,7 @@ TEST_CASE(__FILE__"/Lerp_025", "[Vector2]")
 }
 
 // Tests for expected lerp result 0.50
-TEST_CASE(__FILE__"/Lerp_050", "[Vector2]")
+TEST_CASE(__FILE__"/Lerp_050", "[Vector][Vector2]")
 {
     const Vector2d a(100, 1000);
     const Vector2d b(200, 4000);
@@ -471,7 +471,7 @@ TEST_CASE(__FILE__"/Lerp_050", "[Vector2]")
 }
 
 // Tests for expected lerp result 0.75
-TEST_CASE(__FILE__"/Lerp_075", "[Vector2]")
+TEST_CASE(__FILE__"/Lerp_075", "[Vector][Vector2]")
 {
     const Vector2d a(100, 1000);
     const Vector2d b(200, 4000);
@@ -483,7 +483,7 @@ TEST_CASE(__FILE__"/Lerp_075", "[Vector2]")
 }
 
 // Tests for expected lerp result 1.00
-TEST_CASE(__FILE__"/Lerp_100", "[Vector2]")
+TEST_CASE(__FILE__"/Lerp_100", "[Vector][Vector2]")
 {
     const Vector2d a(100, 1000);
     const Vector2d b(200, 4000);
@@ -495,7 +495,7 @@ TEST_CASE(__FILE__"/Lerp_100", "[Vector2]")
 }
 
 // Tests lerpself
-TEST_CASE(__FILE__"/LerpSelf", "[Vector2]")
+TEST_CASE(__FILE__"/LerpSelf", "[Vector][Vector2]")
 {
     Vector2d a(100, 1000);
     Vector2d b(200, 4000);
@@ -508,7 +508,7 @@ TEST_CASE(__FILE__"/LerpSelf", "[Vector2]")
 }
 
 // Tests if an input vector of length 0 is handled correctly by the normalize method
-TEST_CASE(__FILE__"/Normalize_Length_Before_Is_0", "[Vector2]")
+TEST_CASE(__FILE__"/Normalize_Length_Before_Is_0", "[Vector][Vector2]")
 {
     const Vector2d vec(0, 0);
     REQUIRE(0.0 == vec.Normalize().Magnitude());
@@ -516,7 +516,7 @@ TEST_CASE(__FILE__"/Normalize_Length_Before_Is_0", "[Vector2]")
 }
 
 // Tests for any normalized vector to be of length 1
-TEST_CASE(__FILE__"/Normalize_Length_Is_1", "[Vector2]")
+TEST_CASE(__FILE__"/Normalize_Length_Is_1", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -536,7 +536,7 @@ TEST_CASE(__FILE__"/Normalize_Length_Is_1", "[Vector2]")
 }
 
 // Tests the normalize method with known values
-TEST_CASE(__FILE__"/Normalize_Oracle", "[Vector2]")
+TEST_CASE(__FILE__"/Normalize_Oracle", "[Vector][Vector2]")
 {
     // Setup
     Vector2d v(3.2, -5.3);
@@ -550,7 +550,7 @@ TEST_CASE(__FILE__"/Normalize_Oracle", "[Vector2]")
 }
 
 // Tests for a normalized vector to still point in the exact same direction
-TEST_CASE(__FILE__"/Normalize_Direction_Stays_Unaffected", "[Vector2]")
+TEST_CASE(__FILE__"/Normalize_Direction_Stays_Unaffected", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -580,7 +580,7 @@ TEST_CASE(__FILE__"/Normalize_Direction_Stays_Unaffected", "[Vector2]")
 
 // Kinda dumb method, but ok lol
 // DON'T NORMALIZE INT-VECTORS WHAT IS WRONG WITH YOU
-TEST_CASE(__FILE__"/Normalized_Int_Vector_Is_0", "[Vector2]")
+TEST_CASE(__FILE__"/Normalized_Int_Vector_Is_0", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -599,7 +599,7 @@ TEST_CASE(__FILE__"/Normalized_Int_Vector_Is_0", "[Vector2]")
 }
 
 // Tests that NormalizeSelf() results in the same as Normalize()
-TEST_CASE(__FILE__"/NormalizeSelf_IsSameAs_Normalize", "[Vector2]")
+TEST_CASE(__FILE__"/NormalizeSelf_IsSameAs_Normalize", "[Vector][Vector2]")
 {
     // Run test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -616,7 +616,7 @@ TEST_CASE(__FILE__"/NormalizeSelf_IsSameAs_Normalize", "[Vector2]")
 }
 
 // Tests for the VectorScale() method to work
-TEST_CASE(__FILE__"/VectorScale", "[Vector2]")
+TEST_CASE(__FILE__"/VectorScale", "[Vector][Vector2]")
 {
     // Run test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -641,7 +641,7 @@ TEST_CASE(__FILE__"/VectorScale", "[Vector2]")
 }
 
 // Tests for operator- (unary) to work
-TEST_CASE(__FILE__"/Operator_Unary_Negative", "[Vector2]")
+TEST_CASE(__FILE__"/Operator_Unary_Negative", "[Vector][Vector2]")
 {
     const Vector2d v(29, -5);
 
@@ -651,7 +651,7 @@ TEST_CASE(__FILE__"/Operator_Unary_Negative", "[Vector2]")
 }
 
 // Tests for operator+ to work as expected
-TEST_CASE(__FILE__"/Operator_Add", "[Vector2]")
+TEST_CASE(__FILE__"/Operator_Add", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -671,7 +671,7 @@ TEST_CASE(__FILE__"/Operator_Add", "[Vector2]")
 }
 
 // Tests for operator+= to work as expected
-TEST_CASE(__FILE__"/Operator_Add_Equals", "[Vector2]")
+TEST_CASE(__FILE__"/Operator_Add_Equals", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -691,7 +691,7 @@ TEST_CASE(__FILE__"/Operator_Add_Equals", "[Vector2]")
 }
 
 // Tests for operator- to work as expected
-TEST_CASE(__FILE__"/Operator_Sub", "[Vector2]")
+TEST_CASE(__FILE__"/Operator_Sub", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -711,7 +711,7 @@ TEST_CASE(__FILE__"/Operator_Sub", "[Vector2]")
 }
 
 // Tests for operator-= to work as expected
-TEST_CASE(__FILE__"/Operator_Sub_Equals", "[Vector2]")
+TEST_CASE(__FILE__"/Operator_Sub_Equals", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -731,7 +731,7 @@ TEST_CASE(__FILE__"/Operator_Sub_Equals", "[Vector2]")
 }
 
 // Tests for operator* to work as expected
-TEST_CASE(__FILE__"/Operator_Mult", "[Vector2]")
+TEST_CASE(__FILE__"/Operator_Mult", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -749,7 +749,7 @@ TEST_CASE(__FILE__"/Operator_Mult", "[Vector2]")
 }
 
 // Tests for operator*= to work as expected
-TEST_CASE(__FILE__"/Operator_Mult_Equals", "[Vector2]")
+TEST_CASE(__FILE__"/Operator_Mult_Equals", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -768,7 +768,7 @@ TEST_CASE(__FILE__"/Operator_Mult_Equals", "[Vector2]")
 }
 
 // Tests for operator/ to work as expected
-TEST_CASE(__FILE__"/Operator_Div", "[Vector2]")
+TEST_CASE(__FILE__"/Operator_Div", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -786,7 +786,7 @@ TEST_CASE(__FILE__"/Operator_Div", "[Vector2]")
 }
 
 // Tests for operator/= to work as expected
-TEST_CASE(__FILE__"/Operator_Div_Equals", "[Vector2]")
+TEST_CASE(__FILE__"/Operator_Div_Equals", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -805,7 +805,7 @@ TEST_CASE(__FILE__"/Operator_Div_Equals", "[Vector2]")
 }
 
 // Tests for operator== to work as expected
-TEST_CASE(__FILE__"/Operator_Compare_Equals", "[Vector2]")
+TEST_CASE(__FILE__"/Operator_Compare_Equals", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -828,7 +828,7 @@ TEST_CASE(__FILE__"/Operator_Compare_Equals", "[Vector2]")
 }
 
 // Tests for operator!= to work as expected
-TEST_CASE(__FILE__"/Operator_Not_Equals", "[Vector2]")
+TEST_CASE(__FILE__"/Operator_Not_Equals", "[Vector][Vector2]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -851,7 +851,7 @@ TEST_CASE(__FILE__"/Operator_Not_Equals", "[Vector2]")
 }
 
 // Tests loose comparison via Vector2d::Similar -> true
-TEST_CASE(__FILE__"/Similar_True", "[Vector2]")
+TEST_CASE(__FILE__"/Similar_True", "[Vector][Vector2]")
 {
     REQUIRE(
         Vector2d(0.00000000000000000000001, -6.6666666666666666666666666666).Similar(
@@ -861,7 +861,7 @@ TEST_CASE(__FILE__"/Similar_True", "[Vector2]")
 }
 
 // Tests loose comparison via Vector2d::Similar -> false
-TEST_CASE(__FILE__"/Similar_False", "[Vector2]")
+TEST_CASE(__FILE__"/Similar_False", "[Vector][Vector2]")
 {
     REQUIRE_FALSE(
         Vector2d(0.00000000000000000000001, -6.6666666666666666666666666666).Similar(
@@ -871,7 +871,7 @@ TEST_CASE(__FILE__"/Similar_False", "[Vector2]")
 }
 
 // Tests that the move constructor works
-TEST_CASE(__FILE__"/Move_Constructor", "[Vector2]")
+TEST_CASE(__FILE__"/Move_Constructor", "[Vector][Vector2]")
 {
     const Vector2d a(1, 2);
     const Vector2d b(std::move(a));
@@ -883,7 +883,7 @@ TEST_CASE(__FILE__"/Move_Constructor", "[Vector2]")
 }
 
 // Tests that the move operator works
-TEST_CASE(__FILE__"/Move_Operator", "[Vector2]")
+TEST_CASE(__FILE__"/Move_Operator", "[Vector][Vector2]")
 {
     const Vector2d a(1, 2);
     const Vector2d b = std::move(a);
diff --git a/Test/Vector3.cpp b/Test/Vector3.cpp
index 4567e95..661af82 100644
--- a/Test/Vector3.cpp
+++ b/Test/Vector3.cpp
@@ -11,7 +11,7 @@ namespace {
 }
 
 // Tests if all values are 0 after initialization via default constructor
-TEST_CASE(__FILE__"/New_Vector_All_0", "[Vector3]")
+TEST_CASE(__FILE__"/New_Vector_All_0", "[Vector][Vector3]")
 {
     Vector3d v3;
 
@@ -23,7 +23,7 @@ TEST_CASE(__FILE__"/New_Vector_All_0", "[Vector3]")
 }
 
 // Tests if values can be set via the constructor
-TEST_CASE(__FILE__"/Can_Set_Values_Constructor", "[Vector3]")
+TEST_CASE(__FILE__"/Can_Set_Values_Constructor", "[Vector][Vector3]")
 {
     Vector3d v3(69, 32, 16);
 
@@ -35,7 +35,7 @@ TEST_CASE(__FILE__"/Can_Set_Values_Constructor", "[Vector3]")
 }
 
 // Tests if values can be set via letters
-TEST_CASE(__FILE__"/Can_Set_Values_Letters", "[Vector3]")
+TEST_CASE(__FILE__"/Can_Set_Values_Letters", "[Vector][Vector3]")
 {
     Vector3d v3;
     v3.x = 69;
@@ -50,7 +50,7 @@ TEST_CASE(__FILE__"/Can_Set_Values_Letters", "[Vector3]")
 }
 
 // Tests if values can be set via array descriptors
-TEST_CASE(__FILE__"/Can_Set_Values_ArrayDescriptor", "[Vector3]")
+TEST_CASE(__FILE__"/Can_Set_Values_ArrayDescriptor", "[Vector][Vector3]")
 {
     Vector3d v3;
     v3[0] = 69;
@@ -65,7 +65,7 @@ TEST_CASE(__FILE__"/Can_Set_Values_ArrayDescriptor", "[Vector3]")
 }
 
 // Tests if values can be set via an initializer list
-TEST_CASE(__FILE__"/Can_Set_Values_InitializerList", "[Vector3]")
+TEST_CASE(__FILE__"/Can_Set_Values_InitializerList", "[Vector][Vector3]")
 {
     Vector3d v3 = { 69, 32, 16 };
 
@@ -77,7 +77,7 @@ TEST_CASE(__FILE__"/Can_Set_Values_InitializerList", "[Vector3]")
 }
 
 // Tests for vectors copied via the copy constructor to have the same values
-TEST_CASE(__FILE__"/Copy_Constructor_Same_Values", "[Vector3]")
+TEST_CASE(__FILE__"/Copy_Constructor_Same_Values", "[Vector][Vector3]")
 {
     Vector3d a(69, 32, 16);
     Vector3d b(a);
@@ -90,7 +90,7 @@ TEST_CASE(__FILE__"/Copy_Constructor_Same_Values", "[Vector3]")
 }
 
 // Tests for vectors copied via the equals operator to have the same values
-TEST_CASE(__FILE__"/Operator_Equals_Same_Values", "[Vector3]")
+TEST_CASE(__FILE__"/Operator_Equals_Same_Values", "[Vector][Vector3]")
 {
     Vector3d a(69, 32, 16);
     Vector3d b = a;
@@ -103,7 +103,7 @@ TEST_CASE(__FILE__"/Operator_Equals_Same_Values", "[Vector3]")
 }
 
 // Tests for vectors copied via the copy constructor to be modifyable without modifying the original object
-TEST_CASE(__FILE__"/Copy_Constructor_Independent", "[Vector3]")
+TEST_CASE(__FILE__"/Copy_Constructor_Independent", "[Vector][Vector3]")
 {
     Vector3d a(69, 32, 16);
     Vector3d b(a);
@@ -124,7 +124,7 @@ TEST_CASE(__FILE__"/Copy_Constructor_Independent", "[Vector3]")
 }
 
 // Tests for vectors copied via the equals operator to be modifyable without modifying the original object
-TEST_CASE(__FILE__"/Operator_Equals_Independent", "[Vector3]")
+TEST_CASE(__FILE__"/Operator_Equals_Independent", "[Vector][Vector3]")
 {
     Vector3d a(69, 32, 16);
     Vector3d b = a;
@@ -147,7 +147,7 @@ TEST_CASE(__FILE__"/Operator_Equals_Independent", "[Vector3]")
 // Tests if the dot product between two vectors angled 90 degrees from one another is 0. It should by definition be 0!
 // Dot products are commutative, so we'll check both directions.
 // This test tests all possible 90 degree setups with 1000x random lengths
-TEST_CASE(__FILE__"/DotProduct_90deg", "[Vector3]")
+TEST_CASE(__FILE__"/DotProduct_90deg", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 100; i++)
@@ -197,7 +197,7 @@ TEST_CASE(__FILE__"/DotProduct_90deg", "[Vector3]")
 
 // Test if the dot product is positive for two vectors angled less than 90 degrees from another
 // Dot products are commutative, so we'll check both directions.
-TEST_CASE(__FILE__"/DotProduct_LessThan90deg", "[Vector3]")
+TEST_CASE(__FILE__"/DotProduct_LessThan90deg", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -218,7 +218,7 @@ TEST_CASE(__FILE__"/DotProduct_LessThan90deg", "[Vector3]")
 
 // Test if the dot product is negative for two vectors angled greater than 90 degrees from another
 // Dot products are commutative, so we'll check both directions.
-TEST_CASE(__FILE__"/DotProduct_GreaterThan90deg", "[Vector3]")
+TEST_CASE(__FILE__"/DotProduct_GreaterThan90deg", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -237,7 +237,7 @@ TEST_CASE(__FILE__"/DotProduct_GreaterThan90deg", "[Vector3]")
 }
 
 // Tests that the dot product is correct for a known value
-TEST_CASE(__FILE__"/DotProduct_Oracle", "[Vector3]")
+TEST_CASE(__FILE__"/DotProduct_Oracle", "[Vector][Vector3]")
 {
     // Setup
     Vector3d a(-99, 199, -32);
@@ -253,7 +253,7 @@ TEST_CASE(__FILE__"/DotProduct_Oracle", "[Vector3]")
 }
 
 // Quick and dirty check if the useless int-method is working
-TEST_CASE(__FILE__"/DotProduct_Dirty_Int", "[Vector3]")
+TEST_CASE(__FILE__"/DotProduct_Dirty_Int", "[Vector][Vector3]")
 {
     Vector3i a;
     Vector3i b;
@@ -283,7 +283,7 @@ TEST_CASE(__FILE__"/DotProduct_Dirty_Int", "[Vector3]")
 }
 
 // Tests for the cross product between the same vector being 0
-TEST_CASE(__FILE__"/CrossProduct_Same_Vector_Is_0", "[Vector3]")
+TEST_CASE(__FILE__"/CrossProduct_Same_Vector_Is_0", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -302,7 +302,7 @@ TEST_CASE(__FILE__"/CrossProduct_Same_Vector_Is_0", "[Vector3]")
 }
 
 // Tests for the cross product between opposite vectors being 0
-TEST_CASE(__FILE__"/CrossProduct_Opposite_Vector_Is_0", "[Vector3]")
+TEST_CASE(__FILE__"/CrossProduct_Opposite_Vector_Is_0", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -322,7 +322,7 @@ TEST_CASE(__FILE__"/CrossProduct_Opposite_Vector_Is_0", "[Vector3]")
 }
 
 // Tests for known values
-TEST_CASE(__FILE__"/CrossProduct_KnownValues", "[Vector3]")
+TEST_CASE(__FILE__"/CrossProduct_KnownValues", "[Vector][Vector3]")
 {
     Vector3d a;
     Vector3d b;
@@ -366,7 +366,7 @@ TEST_CASE(__FILE__"/CrossProduct_KnownValues", "[Vector3]")
 }
 
 // Tests for known values, but with int vectors
-TEST_CASE(__FILE__"/CrossProduct_KnownValues_Int", "[Vector3]")
+TEST_CASE(__FILE__"/CrossProduct_KnownValues_Int", "[Vector][Vector3]")
 {
     Vector3i a;
     Vector3i b;
@@ -410,7 +410,7 @@ TEST_CASE(__FILE__"/CrossProduct_KnownValues_Int", "[Vector3]")
 }
 
 // Tests the SqrMagnitude method to work as expected with random numbers
-TEST_CASE(__FILE__"/SqrMagnitude", "[Vector3]")
+TEST_CASE(__FILE__"/SqrMagnitude", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -427,7 +427,7 @@ TEST_CASE(__FILE__"/SqrMagnitude", "[Vector3]")
 }
 
 // Tests the SqrMagnitude method to work as expected with random numbers, but with an int-vector
-TEST_CASE(__FILE__"/SqrMagnitude_Int", "[Vector3]")
+TEST_CASE(__FILE__"/SqrMagnitude_Int", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -444,14 +444,14 @@ TEST_CASE(__FILE__"/SqrMagnitude_Int", "[Vector3]")
 }
 
 // Tests for the length of the vector (0,0,0) being 0
-TEST_CASE(__FILE__"/Magnitude_Is_0_On_Vec0", "[Vector3]")
+TEST_CASE(__FILE__"/Magnitude_Is_0_On_Vec0", "[Vector][Vector3]")
 {
     REQUIRE(0.0 == Vector3d(0, 0, 0).Magnitude());
     return;
 }
 
 // Tests for a vector of a known length to actually return that
-TEST_CASE(__FILE__"/Magnitude_One_Axis_X", "[Vector3]")
+TEST_CASE(__FILE__"/Magnitude_One_Axis_X", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -470,7 +470,7 @@ TEST_CASE(__FILE__"/Magnitude_One_Axis_X", "[Vector3]")
 }
 
 // Tests for a vector of a known length to actually return that
-TEST_CASE(__FILE__"/Magnitude_One_Axis_Y", "[Vector3]")
+TEST_CASE(__FILE__"/Magnitude_One_Axis_Y", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -489,7 +489,7 @@ TEST_CASE(__FILE__"/Magnitude_One_Axis_Y", "[Vector3]")
 }
 
 // Tests for a vector of a known length to actually return that
-TEST_CASE(__FILE__"/Magnitude_One_Axis_Z", "[Vector3]")
+TEST_CASE(__FILE__"/Magnitude_One_Axis_Z", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -508,7 +508,7 @@ TEST_CASE(__FILE__"/Magnitude_One_Axis_Z", "[Vector3]")
 }
 
 // Tests for a known result
-TEST_CASE(__FILE__"/Magnitude", "[Vector3]")
+TEST_CASE(__FILE__"/Magnitude", "[Vector][Vector3]")
 {
     // Ya'll got more of 'dem digits?
     REQUIRE(426.14786166306174663986894302070140838623046875 == Vector3d(69, -420, 21).Magnitude());
@@ -516,7 +516,7 @@ TEST_CASE(__FILE__"/Magnitude", "[Vector3]")
 }
 
 // Tests for expected lerp result 0.00
-TEST_CASE(__FILE__"/Lerp_000", "[Vector3]")
+TEST_CASE(__FILE__"/Lerp_000", "[Vector][Vector3]")
 {
     Vector3d a(100, 1000, 10);
     Vector3d b(200, 4000, 100);
@@ -528,7 +528,7 @@ TEST_CASE(__FILE__"/Lerp_000", "[Vector3]")
 }
 
 // Tests for expected lerp result 0.25
-TEST_CASE(__FILE__"/Lerp_025", "[Vector3]")
+TEST_CASE(__FILE__"/Lerp_025", "[Vector][Vector3]")
 {
     Vector3d a(100, 1000, 10);
     Vector3d b(200, 4000, 100);
@@ -540,7 +540,7 @@ TEST_CASE(__FILE__"/Lerp_025", "[Vector3]")
 }
 
 // Tests for expected lerp result 0.50
-TEST_CASE(__FILE__"/Lerp_050", "[Vector3]")
+TEST_CASE(__FILE__"/Lerp_050", "[Vector][Vector3]")
 {
     Vector3d a(100, 1000, 10);
     Vector3d b(200, 4000, 100);
@@ -552,7 +552,7 @@ TEST_CASE(__FILE__"/Lerp_050", "[Vector3]")
 }
 
 // Tests for expected lerp result 0.75
-TEST_CASE(__FILE__"/Lerp_075", "[Vector3]")
+TEST_CASE(__FILE__"/Lerp_075", "[Vector][Vector3]")
 {
     Vector3d a(100, 1000, 10);
     Vector3d b(200, 4000, 100);
@@ -564,7 +564,7 @@ TEST_CASE(__FILE__"/Lerp_075", "[Vector3]")
 }
 
 // Tests for expected lerp result 1.00
-TEST_CASE(__FILE__"/Lerp_100", "[Vector3]")
+TEST_CASE(__FILE__"/Lerp_100", "[Vector][Vector3]")
 {
     Vector3d a(100, 1000, 10);
     Vector3d b(200, 4000, 100);
@@ -576,7 +576,7 @@ TEST_CASE(__FILE__"/Lerp_100", "[Vector3]")
 }
 
 // Tests lerpself
-TEST_CASE(__FILE__"/LerpSelf", "[Vector3]")
+TEST_CASE(__FILE__"/LerpSelf", "[Vector][Vector3]")
 {
     Vector3d a(100, 1000, 10);
     Vector3d b(200, 4000, 100);
@@ -589,7 +589,7 @@ TEST_CASE(__FILE__"/LerpSelf", "[Vector3]")
 }
 
 // Tests if an input vector of length 0 is handled correctly by the normalize method
-TEST_CASE(__FILE__"/Normalize_Length_Before_Is_0", "[Vector3]")
+TEST_CASE(__FILE__"/Normalize_Length_Before_Is_0", "[Vector][Vector3]")
 {
     Vector3d vec(0, 0, 0);
     vec.NormalizeSelf();
@@ -598,7 +598,7 @@ TEST_CASE(__FILE__"/Normalize_Length_Before_Is_0", "[Vector3]")
 }
 
 // Tests for any normalized vector to be of length 1
-TEST_CASE(__FILE__"/Normalize_Length_Is_1", "[Vector3]")
+TEST_CASE(__FILE__"/Normalize_Length_Is_1", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -621,7 +621,7 @@ TEST_CASE(__FILE__"/Normalize_Length_Is_1", "[Vector3]")
 }
 
 // Tests the normalize method with known values
-TEST_CASE(__FILE__"/Normalize_Oracle", "[Vector3]")
+TEST_CASE(__FILE__"/Normalize_Oracle", "[Vector][Vector3]")
 {
     // Setup
     Vector3d v(3.2, -5.3, 9.88);
@@ -635,7 +635,7 @@ TEST_CASE(__FILE__"/Normalize_Oracle", "[Vector3]")
 }
 
 // Tests for a normalized vector to still point in the exact same direction
-TEST_CASE(__FILE__"/Normalize_Direction_Stays_Unaffected", "[Vector3]")
+TEST_CASE(__FILE__"/Normalize_Direction_Stays_Unaffected", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -665,7 +665,7 @@ TEST_CASE(__FILE__"/Normalize_Direction_Stays_Unaffected", "[Vector3]")
 
 // Kinda dumb method, but ok lol
 // DON'T NORMALIZE INT-VECTORS WHAT IS WRONG WITH YOU
-TEST_CASE(__FILE__"/Normalized_Int_Vector_Is_0", "[Vector3]")
+TEST_CASE(__FILE__"/Normalized_Int_Vector_Is_0", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -684,7 +684,7 @@ TEST_CASE(__FILE__"/Normalized_Int_Vector_Is_0", "[Vector3]")
 }
 
 // Tests that NormalizeSelf() results in the same as Normalize()
-TEST_CASE(__FILE__"/NormalizeSelf_IsSameAs_Normalize", "[Vector3]")
+TEST_CASE(__FILE__"/NormalizeSelf_IsSameAs_Normalize", "[Vector][Vector3]")
 {
     // Run test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -701,7 +701,7 @@ TEST_CASE(__FILE__"/NormalizeSelf_IsSameAs_Normalize", "[Vector3]")
 }
 
 // Tests for the VectorScale() method to work
-TEST_CASE(__FILE__"/VectorScale", "[Vector3]")
+TEST_CASE(__FILE__"/VectorScale", "[Vector][Vector3]")
 {
     // Run test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -729,7 +729,7 @@ TEST_CASE(__FILE__"/VectorScale", "[Vector3]")
 }
 
 // Tests for operator- (unary) to work
-TEST_CASE(__FILE__"/Operator_Unary_Negative", "[Vector3]")
+TEST_CASE(__FILE__"/Operator_Unary_Negative", "[Vector][Vector3]")
 {
     const Vector3d v(29, -5, 35);
 
@@ -739,7 +739,7 @@ TEST_CASE(__FILE__"/Operator_Unary_Negative", "[Vector3]")
 }
 
 // Tests for operator+ to work as expected
-TEST_CASE(__FILE__"/Operator_Add", "[Vector3]")
+TEST_CASE(__FILE__"/Operator_Add", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -761,7 +761,7 @@ TEST_CASE(__FILE__"/Operator_Add", "[Vector3]")
 }
 
 // Tests for operator+= to work as expected
-TEST_CASE(__FILE__"/Operator_Add_Equals", "[Vector3]")
+TEST_CASE(__FILE__"/Operator_Add_Equals", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -783,7 +783,7 @@ TEST_CASE(__FILE__"/Operator_Add_Equals", "[Vector3]")
 }
 
 // Tests for operator- to work as expected
-TEST_CASE(__FILE__"/Operator_Sub", "[Vector3]")
+TEST_CASE(__FILE__"/Operator_Sub", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -805,7 +805,7 @@ TEST_CASE(__FILE__"/Operator_Sub", "[Vector3]")
 }
 
 // Tests for operator-= to work as expected
-TEST_CASE(__FILE__"/Operator_Sub_Equals", "[Vector3]")
+TEST_CASE(__FILE__"/Operator_Sub_Equals", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -827,7 +827,7 @@ TEST_CASE(__FILE__"/Operator_Sub_Equals", "[Vector3]")
 }
 
 // Tests for operator* to work as expected
-TEST_CASE(__FILE__"/Operator_Mult", "[Vector3]")
+TEST_CASE(__FILE__"/Operator_Mult", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -846,7 +846,7 @@ TEST_CASE(__FILE__"/Operator_Mult", "[Vector3]")
 }
 
 // Tests for operator*= to work as expected
-TEST_CASE(__FILE__"/Operator_Mult_Equals", "[Vector3]")
+TEST_CASE(__FILE__"/Operator_Mult_Equals", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -866,7 +866,7 @@ TEST_CASE(__FILE__"/Operator_Mult_Equals", "[Vector3]")
 }
 
 // Tests for operator/ to work as expected
-TEST_CASE(__FILE__"/Operator_Div", "[Vector3]")
+TEST_CASE(__FILE__"/Operator_Div", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -885,7 +885,7 @@ TEST_CASE(__FILE__"/Operator_Div", "[Vector3]")
 }
 
 // Tests for operator/= to work as expected
-TEST_CASE(__FILE__"/Operator_Div_Equals", "[Vector3]")
+TEST_CASE(__FILE__"/Operator_Div_Equals", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -905,7 +905,7 @@ TEST_CASE(__FILE__"/Operator_Div_Equals", "[Vector3]")
 }
 
 // Tests for operator== to work as expected
-TEST_CASE(__FILE__"/Operator_Equals", "[Vector3]")
+TEST_CASE(__FILE__"/Operator_Equals", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 10000; i++)
@@ -930,7 +930,7 @@ TEST_CASE(__FILE__"/Operator_Equals", "[Vector3]")
 }
 
 // Tests for operator!= to work as expected
-TEST_CASE(__FILE__"/Operator_Not_Equals", "[Vector3]")
+TEST_CASE(__FILE__"/Operator_Not_Equals", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 10000; i++)
@@ -955,7 +955,7 @@ TEST_CASE(__FILE__"/Operator_Not_Equals", "[Vector3]")
 }
 
 // Tests for matrix multiplication working regarding rotation
-TEST_CASE(__FILE__"/MatrixMult_Rotate_Yaw", "[Vector3]")
+TEST_CASE(__FILE__"/MatrixMult_Rotate_Yaw", "[Vector][Vector3]")
 {
     // Create vector
     Vector3d vec(69, 32, 16);
@@ -993,7 +993,7 @@ TEST_CASE(__FILE__"/MatrixMult_Rotate_Yaw", "[Vector3]")
 }
 
 // Tests for matrix multiplication working regarding rotation
-TEST_CASE(__FILE__"/MatrixMult_Rotate_Roll", "[Vector3]")
+TEST_CASE(__FILE__"/MatrixMult_Rotate_Roll", "[Vector][Vector3]")
 {
     // Create vector
     Vector3d vec(69, 32, 16);
@@ -1031,7 +1031,7 @@ TEST_CASE(__FILE__"/MatrixMult_Rotate_Roll", "[Vector3]")
 }
 
 // Tests for matrix multiplication working regarding rotation
-TEST_CASE(__FILE__"/MatrixMult_Rotate_Pitch", "[Vector3]")
+TEST_CASE(__FILE__"/MatrixMult_Rotate_Pitch", "[Vector][Vector3]")
 {
     // Create vector
     Vector3d vec(69, 32, 16);
@@ -1069,7 +1069,7 @@ TEST_CASE(__FILE__"/MatrixMult_Rotate_Pitch", "[Vector3]")
 }
 
 // Tests if rotating a vector (1,1,1) by (45,45,45) eulers works
-TEST_CASE(__FILE__"/MatrixMult_Rotate_Unit_Combined", "[Vector3]")
+TEST_CASE(__FILE__"/MatrixMult_Rotate_Unit_Combined", "[Vector][Vector3]")
 {
     // Create vector
     Vector3d vec(1, 1, 1);
@@ -1095,7 +1095,7 @@ TEST_CASE(__FILE__"/MatrixMult_Rotate_Unit_Combined", "[Vector3]")
 }
 
 // Tests if rotating a vector (69,32,16) by (45,45,45) eulers works
-TEST_CASE(__FILE__"/MatrixMult_Rotate_HalfUnit_Combined", "[Vector3]")
+TEST_CASE(__FILE__"/MatrixMult_Rotate_HalfUnit_Combined", "[Vector][Vector3]")
 {
     // Create vector
     Vector3d vec(69, 32, 16);
@@ -1121,7 +1121,7 @@ TEST_CASE(__FILE__"/MatrixMult_Rotate_HalfUnit_Combined", "[Vector3]")
 }
 
 // Tests if rotating a vector (69,32,16) by (45,45,45) eulers works
-TEST_CASE(__FILE__"/MatrixMult_Rotate_Combined", "[Vector3]")
+TEST_CASE(__FILE__"/MatrixMult_Rotate_Combined", "[Vector][Vector3]")
 {
     // Create vector
     Vector3d vec(69, 32, 16);
@@ -1147,7 +1147,7 @@ TEST_CASE(__FILE__"/MatrixMult_Rotate_Combined", "[Vector3]")
 }
 
 // Tests if matrix scaling works ( x axis only )
-TEST_CASE(__FILE__"/MatrixMult_Scale_X", "[Vector3]")
+TEST_CASE(__FILE__"/MatrixMult_Scale_X", "[Vector][Vector3]")
 {
     // Create vector
     Vector3d vec(5, 6, 7);
@@ -1169,7 +1169,7 @@ TEST_CASE(__FILE__"/MatrixMult_Scale_X", "[Vector3]")
 }
 
 // Tests if matrix scaling works ( y axis only )
-TEST_CASE(__FILE__"/MatrixMult_Scale_Y", "[Vector3]")
+TEST_CASE(__FILE__"/MatrixMult_Scale_Y", "[Vector][Vector3]")
 {
     // Create vector
     Vector3d vec(5, 6, 7);
@@ -1191,7 +1191,7 @@ TEST_CASE(__FILE__"/MatrixMult_Scale_Y", "[Vector3]")
 }
 
 // Tests if matrix scaling works ( z axis only )
-TEST_CASE(__FILE__"/MatrixMult_Scale_Z", "[Vector3]")
+TEST_CASE(__FILE__"/MatrixMult_Scale_Z", "[Vector][Vector3]")
 {
     // Create vector
     Vector3d vec(5, 6, 7);
@@ -1213,7 +1213,7 @@ TEST_CASE(__FILE__"/MatrixMult_Scale_Z", "[Vector3]")
 }
 
 // Tests if matrix scaling works ( all axes )
-TEST_CASE(__FILE__"/MatrixMult_Scale_Combined", "[Vector3]")
+TEST_CASE(__FILE__"/MatrixMult_Scale_Combined", "[Vector][Vector3]")
 {
     // Create vector
     Vector3d vec(5, 6, 7);
@@ -1235,7 +1235,7 @@ TEST_CASE(__FILE__"/MatrixMult_Scale_Combined", "[Vector3]")
 }
 
 // Tests if translation via matrix multiplication works
-TEST_CASE(__FILE__"/MatrixMult_Translation", "[Vector3]")
+TEST_CASE(__FILE__"/MatrixMult_Translation", "[Vector][Vector3]")
 {
     // Create vector
     Vector3d vec(5, 6, 7);
@@ -1257,7 +1257,7 @@ TEST_CASE(__FILE__"/MatrixMult_Translation", "[Vector3]")
 }
 
 // Tests the multiplication operator (*) with a simple matrix. All other tests used the * operator (without the '=')
-TEST_CASE(__FILE__"/MatrixMult_Not_Using_MultEqualsOperator", "[Vector3]")
+TEST_CASE(__FILE__"/MatrixMult_Not_Using_MultEqualsOperator", "[Vector][Vector3]")
 {
     // Create vector
     Vector3d vec(5.1, 6.4, 7.99);
@@ -1289,7 +1289,7 @@ TEST_CASE(__FILE__"/MatrixMult_Not_Using_MultEqualsOperator", "[Vector3]")
 }
 
 // A simple matrix multiplication tested on an int vector
-TEST_CASE(__FILE__"/MatrixMult_Dirty_Int_Check", "[Vector3]")
+TEST_CASE(__FILE__"/MatrixMult_Dirty_Int_Check", "[Vector][Vector3]")
 {
     // Create vector
     Vector3i vec(5, 6, 7);
@@ -1315,7 +1315,7 @@ TEST_CASE(__FILE__"/MatrixMult_Dirty_Int_Check", "[Vector3]")
 }
 
 // Tests the multiplication operator (*) with a simple matrix. All other tests used the * operator (without the '=')
-TEST_CASE(__FILE__"/MatrixMult_Dirty_Int_Check_Not_Using_MultEqualsOperator", "[Vector3]")
+TEST_CASE(__FILE__"/MatrixMult_Dirty_Int_Check_Not_Using_MultEqualsOperator", "[Vector][Vector3]")
 {
     // Create vector
     Vector3i vec(5, 6, 7);
@@ -1341,7 +1341,7 @@ TEST_CASE(__FILE__"/MatrixMult_Dirty_Int_Check_Not_Using_MultEqualsOperator", "[
 }
 
 //This tests the multiplication equals operator (*=) procedurally
-TEST_CASE(__FILE__"/MatrixMult_Equals_Procedural", "[Vector3]")
+TEST_CASE(__FILE__"/MatrixMult_Equals_Procedural", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -1385,7 +1385,7 @@ TEST_CASE(__FILE__"/MatrixMult_Equals_Procedural", "[Vector3]")
 }
 
 //This tests the multiplication operator (*) procedurally
-TEST_CASE(__FILE__"/MatrixMult_Procedural", "[Vector3]")
+TEST_CASE(__FILE__"/MatrixMult_Procedural", "[Vector][Vector3]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -1429,7 +1429,7 @@ TEST_CASE(__FILE__"/MatrixMult_Procedural", "[Vector3]")
 }
 
 // Tests loose comparison via Vector3d::Similar -> true
-TEST_CASE(__FILE__"/Similar_True", "[Vector3]")
+TEST_CASE(__FILE__"/Similar_True", "[Vector][Vector3]")
 {
     REQUIRE(
         Vector3d(0.00000000000000000000001, -6.6666666666666666666666666666, 9.9999999999999999999999999999).Similar(
@@ -1439,7 +1439,7 @@ TEST_CASE(__FILE__"/Similar_True", "[Vector3]")
 }
 
 // Tests loose comparison via Vector3d::Similar -> false
-TEST_CASE(__FILE__"/Similar_False", "[Vector3]")
+TEST_CASE(__FILE__"/Similar_False", "[Vector][Vector3]")
 {
     REQUIRE_FALSE(
         Vector3d(0.00000000000000000000001, -6.6666666666666666666666666666, 9.9999999999999999999999999999).Similar(
@@ -1449,7 +1449,7 @@ TEST_CASE(__FILE__"/Similar_False", "[Vector3]")
 }
 
 // Tests that the move constructor works
-TEST_CASE(__FILE__"/Move_Constructor", "[Vector3]")
+TEST_CASE(__FILE__"/Move_Constructor", "[Vector][Vector3]")
 {
     Vector3d a(1,2,3);
     Vector3d b(std::move(a));
@@ -1462,7 +1462,7 @@ TEST_CASE(__FILE__"/Move_Constructor", "[Vector3]")
 }
 
 // Tests that the move operator works
-TEST_CASE(__FILE__"/Move_Operator", "[Vector3]")
+TEST_CASE(__FILE__"/Move_Operator", "[Vector][Vector3]")
 {
     Vector3d a(1, 2, 3);
     Vector3d b = std::move(a);
diff --git a/Test/Vector4.cpp b/Test/Vector4.cpp
index d476b5d..01a42ac 100644
--- a/Test/Vector4.cpp
+++ b/Test/Vector4.cpp
@@ -13,7 +13,7 @@ namespace {
 }
 
 // Tests if all values are 0 after initialization via default constructor
-TEST_CASE(__FILE__"/New_Vector_All_0", "[Vector4]")
+TEST_CASE(__FILE__"/New_Vector_All_0", "[Vector][Vector4]")
 {
     const Vector4d v4;
 
@@ -26,7 +26,7 @@ TEST_CASE(__FILE__"/New_Vector_All_0", "[Vector4]")
 }
 
 // Tests if values can be set via the constructor
-TEST_CASE(__FILE__"/Can_Set_Values_Constructor", "[Vector4]")
+TEST_CASE(__FILE__"/Can_Set_Values_Constructor", "[Vector][Vector4]")
 {
     const Vector4d v4(69, 32, 16, 10);
 
@@ -39,7 +39,7 @@ TEST_CASE(__FILE__"/Can_Set_Values_Constructor", "[Vector4]")
 }
 
 // Tests if values can be set via letters
-TEST_CASE(__FILE__"/Can_Set_Values_Letters", "[Vector4]")
+TEST_CASE(__FILE__"/Can_Set_Values_Letters", "[Vector][Vector4]")
 {
     Vector4d v4;
     v4.x = 69;
@@ -56,7 +56,7 @@ TEST_CASE(__FILE__"/Can_Set_Values_Letters", "[Vector4]")
 }
 
 // Tests if values can be set via array descriptors
-TEST_CASE(__FILE__"/Can_Set_Values_ArrayDescriptor", "[Vector4]")
+TEST_CASE(__FILE__"/Can_Set_Values_ArrayDescriptor", "[Vector][Vector4]")
 {
     Vector4d v4;
     v4[0] = 69;
@@ -73,7 +73,7 @@ TEST_CASE(__FILE__"/Can_Set_Values_ArrayDescriptor", "[Vector4]")
 }
 
 // Tests if values can be set via an initializer list
-TEST_CASE(__FILE__"/Can_Set_Values_InitializerList", "[Vector4]")
+TEST_CASE(__FILE__"/Can_Set_Values_InitializerList", "[Vector][Vector4]")
 {
     const Vector4d v4 = { 69, 32, 16, 10 };
 
@@ -86,7 +86,7 @@ TEST_CASE(__FILE__"/Can_Set_Values_InitializerList", "[Vector4]")
 }
 
 // Tests for vectors copied via the copy constructor to have the same values
-TEST_CASE(__FILE__"/Copy_Constructor_Same_Values", "[Vector4]")
+TEST_CASE(__FILE__"/Copy_Constructor_Same_Values", "[Vector][Vector4]")
 {
     const Vector4d a(69, 32, 16, 10);
     Vector4d b(a);
@@ -100,7 +100,7 @@ TEST_CASE(__FILE__"/Copy_Constructor_Same_Values", "[Vector4]")
 }
 
 // Tests for vectors copied via the equals operator to have the same values
-TEST_CASE(__FILE__"/Operator_Equals_Same_Values", "[Vector4]")
+TEST_CASE(__FILE__"/Operator_Equals_Same_Values", "[Vector][Vector4]")
 {
     const Vector4d a(69, 32, 16, 10);
     Vector4d b = a;
@@ -114,7 +114,7 @@ TEST_CASE(__FILE__"/Operator_Equals_Same_Values", "[Vector4]")
 }
 
 // Tests for vectors copied via the copy constructor to be modifyable without modifying the original object
-TEST_CASE(__FILE__"/Copy_Constructor_Independent", "[Vector4]")
+TEST_CASE(__FILE__"/Copy_Constructor_Independent", "[Vector][Vector4]")
 {
     const Vector4d a(69, 32, 16, 10);
     Vector4d b(a);
@@ -138,7 +138,7 @@ TEST_CASE(__FILE__"/Copy_Constructor_Independent", "[Vector4]")
 }
 
 // Tests for vectors copied via the equals operator to be modifyable without modifying the original object
-TEST_CASE(__FILE__"/Operator_Equals_Independent", "[Vector4]")
+TEST_CASE(__FILE__"/Operator_Equals_Independent", "[Vector][Vector4]")
 {
     const Vector4d a(69, 32, 16, 10);
     Vector4d b = a;
@@ -162,7 +162,7 @@ TEST_CASE(__FILE__"/Operator_Equals_Independent", "[Vector4]")
 }
 
 // Tests the SqrMagnitude method to work as expected with random numbers
-TEST_CASE(__FILE__"/SqrMagnitude", "[Vector4]")
+TEST_CASE(__FILE__"/SqrMagnitude", "[Vector][Vector4]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -180,14 +180,14 @@ TEST_CASE(__FILE__"/SqrMagnitude", "[Vector4]")
 }
 
 // Tests for the length of the vector (0,0,0,0) being 0
-TEST_CASE(__FILE__"/Magnitude_Is_0_On_Vec0", "[Vector4]")
+TEST_CASE(__FILE__"/Magnitude_Is_0_On_Vec0", "[Vector][Vector4]")
 {
     REQUIRE(0.0 == Vector4d(0, 0, 0, 0).Magnitude());
     return;
 }
 
 // Tests for a vector of a known length to actually return that
-TEST_CASE(__FILE__"/Magnitude_One_Axis_X", "[Vector4]")
+TEST_CASE(__FILE__"/Magnitude_One_Axis_X", "[Vector][Vector4]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -201,7 +201,7 @@ TEST_CASE(__FILE__"/Magnitude_One_Axis_X", "[Vector4]")
 }
 
 // Tests for a vector of a known length to actually return that
-TEST_CASE(__FILE__"/Magnitude_One_Axis_Y", "[Vector4]")
+TEST_CASE(__FILE__"/Magnitude_One_Axis_Y", "[Vector][Vector4]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -215,7 +215,7 @@ TEST_CASE(__FILE__"/Magnitude_One_Axis_Y", "[Vector4]")
 }
 
 // Tests for a vector of a known length to actually return that
-TEST_CASE(__FILE__"/Magnitude_One_Axis_Z", "[Vector4]")
+TEST_CASE(__FILE__"/Magnitude_One_Axis_Z", "[Vector][Vector4]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -229,7 +229,7 @@ TEST_CASE(__FILE__"/Magnitude_One_Axis_Z", "[Vector4]")
 }
 
 // Tests for a vector of a known length to actually return that
-TEST_CASE(__FILE__"/Magnitude_One_Axis_W", "[Vector4]")
+TEST_CASE(__FILE__"/Magnitude_One_Axis_W", "[Vector][Vector4]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -243,7 +243,7 @@ TEST_CASE(__FILE__"/Magnitude_One_Axis_W", "[Vector4]")
 }
 
 // Tests for a known result
-TEST_CASE(__FILE__"/Magnitude", "[Vector4]")
+TEST_CASE(__FILE__"/Magnitude", "[Vector][Vector4]")
 {
     // Ya'll got more of 'dem digits?
     REQUIRE(78.5746530377322045524124405346810817718505859375 == Vector4d(-23.76, 15.82, 66.75, 30.06).Magnitude());
@@ -251,7 +251,7 @@ TEST_CASE(__FILE__"/Magnitude", "[Vector4]")
 }
 
 // Tests for expected lerp result 0.00
-TEST_CASE(__FILE__"/Lerp_000", "[Vector4]")
+TEST_CASE(__FILE__"/Lerp_000", "[Vector][Vector4]")
 {
     const Vector4d a(100, 1000, 10, -200);
     const Vector4d b(200, 4000, 100, 200);
@@ -263,7 +263,7 @@ TEST_CASE(__FILE__"/Lerp_000", "[Vector4]")
 }
 
 // Tests for expected lerp result 0.25
-TEST_CASE(__FILE__"/Lerp_025", "[Vector4]")
+TEST_CASE(__FILE__"/Lerp_025", "[Vector][Vector4]")
 {
     const Vector4d a(100, 1000, 10, -200);
     const Vector4d b(200, 4000, 100, 200);
@@ -275,7 +275,7 @@ TEST_CASE(__FILE__"/Lerp_025", "[Vector4]")
 }
 
 // Tests for expected lerp result 0.50
-TEST_CASE(__FILE__"/Lerp_050", "[Vector4]")
+TEST_CASE(__FILE__"/Lerp_050", "[Vector][Vector4]")
 {
     const Vector4d a(100, 1000, 10, -200);
     const Vector4d b(200, 4000, 100, 200);
@@ -287,7 +287,7 @@ TEST_CASE(__FILE__"/Lerp_050", "[Vector4]")
 }
 
 // Tests for expected lerp result 0.75
-TEST_CASE(__FILE__"/Lerp_075", "[Vector4]")
+TEST_CASE(__FILE__"/Lerp_075", "[Vector][Vector4]")
 {
     const Vector4d a(100, 1000, 10, -200);
     const Vector4d b(200, 4000, 100, 200);
@@ -299,7 +299,7 @@ TEST_CASE(__FILE__"/Lerp_075", "[Vector4]")
 }
 
 // Tests for expected lerp result 1.00
-TEST_CASE(__FILE__"/Lerp_100", "[Vector4]")
+TEST_CASE(__FILE__"/Lerp_100", "[Vector][Vector4]")
 {
     const Vector4d a(100, 1000, 10, -200);
     const Vector4d b(200, 4000, 100, 200);
@@ -311,7 +311,7 @@ TEST_CASE(__FILE__"/Lerp_100", "[Vector4]")
 }
 
 // Tests lerpself
-TEST_CASE(__FILE__"/LerpSelf", "[Vector4]")
+TEST_CASE(__FILE__"/LerpSelf", "[Vector][Vector4]")
 {
     Vector4d a(100, 1000, 10, -200);
     Vector4d b(200, 4000, 100, 200);
@@ -324,7 +324,7 @@ TEST_CASE(__FILE__"/LerpSelf", "[Vector4]")
 }
 
 // Tests if an input vector of length 0 is handled correctly by the normalize method
-TEST_CASE(__FILE__"/Normalize_Length_Before_Is_0", "[Vector4]")
+TEST_CASE(__FILE__"/Normalize_Length_Before_Is_0", "[Vector][Vector4]")
 {
     Vector4d vec(0, 0, 0, 0);
     vec.NormalizeSelf();
@@ -333,7 +333,7 @@ TEST_CASE(__FILE__"/Normalize_Length_Before_Is_0", "[Vector4]")
 }
 
 // Tests for any normalized vector to be of length 1
-TEST_CASE(__FILE__"/Normalize_Length_Is_1", "[Vector4]")
+TEST_CASE(__FILE__"/Normalize_Length_Is_1", "[Vector][Vector4]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -357,7 +357,7 @@ TEST_CASE(__FILE__"/Normalize_Length_Is_1", "[Vector4]")
 }
 
 // Tests the normalize method with known values
-TEST_CASE(__FILE__"/Normalize_Oracle", "[Vector4]")
+TEST_CASE(__FILE__"/Normalize_Oracle", "[Vector][Vector4]")
 {
     // Setup
     Vector4d v(3.2, -5.3, 9.88, 69.420);
@@ -372,7 +372,7 @@ TEST_CASE(__FILE__"/Normalize_Oracle", "[Vector4]")
 
 // Kinda dumb method, but ok lol
 // DON'T NORMALIZE INT-VECTORS WHAT IS WRONG WITH YOU
-TEST_CASE(__FILE__"/Normalized_Int_Vector_Is_0", "[Vector4]")
+TEST_CASE(__FILE__"/Normalized_Int_Vector_Is_0", "[Vector][Vector4]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -392,7 +392,7 @@ TEST_CASE(__FILE__"/Normalized_Int_Vector_Is_0", "[Vector4]")
 }
 
 // Tests that NormalizeSelf() results in the same as Normalize()
-TEST_CASE(__FILE__"/NormalizeSelf_IsSameAs_Normalize", "[Vector4]")
+TEST_CASE(__FILE__"/NormalizeSelf_IsSameAs_Normalize", "[Vector][Vector4]")
 {
     // Run test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -409,7 +409,7 @@ TEST_CASE(__FILE__"/NormalizeSelf_IsSameAs_Normalize", "[Vector4]")
 }
 
 // Tests for the VectorScale() method to work
-TEST_CASE(__FILE__"/VectorScale", "[Vector4]")
+TEST_CASE(__FILE__"/VectorScale", "[Vector][Vector4]")
 {
     // Run test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -440,7 +440,7 @@ TEST_CASE(__FILE__"/VectorScale", "[Vector4]")
 }
 
 // Tests for operator- (unary) to work
-TEST_CASE(__FILE__"/Operator_Unary_Negative", "[Vector4]")
+TEST_CASE(__FILE__"/Operator_Unary_Negative", "[Vector][Vector4]")
 {
     const Vector4d v(29, -5, 35, -69);
 
@@ -450,7 +450,7 @@ TEST_CASE(__FILE__"/Operator_Unary_Negative", "[Vector4]")
 }
 
 // Tests for operator+ to work as expected
-TEST_CASE(__FILE__"/Operator_Add", "[Vector4]")
+TEST_CASE(__FILE__"/Operator_Add", "[Vector][Vector4]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -474,7 +474,7 @@ TEST_CASE(__FILE__"/Operator_Add", "[Vector4]")
 }
 
 // Tests for operator+= to work as expected
-TEST_CASE(__FILE__"/Operator_Add_Equals", "[Vector4]")
+TEST_CASE(__FILE__"/Operator_Add_Equals", "[Vector][Vector4]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -498,7 +498,7 @@ TEST_CASE(__FILE__"/Operator_Add_Equals", "[Vector4]")
 }
 
 // Tests for operator- to work as expected
-TEST_CASE(__FILE__"/Operator_Sub", "[Vector4]")
+TEST_CASE(__FILE__"/Operator_Sub", "[Vector][Vector4]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -522,7 +522,7 @@ TEST_CASE(__FILE__"/Operator_Sub", "[Vector4]")
 }
 
 // Tests for operator-= to work as expected
-TEST_CASE(__FILE__"/Operator_Sub_Equals", "[Vector4]")
+TEST_CASE(__FILE__"/Operator_Sub_Equals", "[Vector][Vector4]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -546,7 +546,7 @@ TEST_CASE(__FILE__"/Operator_Sub_Equals", "[Vector4]")
 }
 
 // Tests for operator* to work as expected
-TEST_CASE(__FILE__"/Operator_Mult", "[Vector4]")
+TEST_CASE(__FILE__"/Operator_Mult", "[Vector][Vector4]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -566,7 +566,7 @@ TEST_CASE(__FILE__"/Operator_Mult", "[Vector4]")
 }
 
 // Tests for operator*= to work as expected
-TEST_CASE(__FILE__"/Operator_Mult_Equals", "[Vector4]")
+TEST_CASE(__FILE__"/Operator_Mult_Equals", "[Vector][Vector4]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -587,7 +587,7 @@ TEST_CASE(__FILE__"/Operator_Mult_Equals", "[Vector4]")
 }
 
 // Tests for operator/ to work as expected
-TEST_CASE(__FILE__"/Operator_Div", "[Vector4]")
+TEST_CASE(__FILE__"/Operator_Div", "[Vector][Vector4]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -607,7 +607,7 @@ TEST_CASE(__FILE__"/Operator_Div", "[Vector4]")
 }
 
 // Tests for operator/= to work as expected
-TEST_CASE(__FILE__"/Operator_Div_Equals", "[Vector4]")
+TEST_CASE(__FILE__"/Operator_Div_Equals", "[Vector][Vector4]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -628,7 +628,7 @@ TEST_CASE(__FILE__"/Operator_Div_Equals", "[Vector4]")
 }
 
 // Tests for operator== to work as expected
-TEST_CASE(__FILE__"/Operator_Equals", "[Vector4]")
+TEST_CASE(__FILE__"/Operator_Equals", "[Vector][Vector4]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -655,7 +655,7 @@ TEST_CASE(__FILE__"/Operator_Equals", "[Vector4]")
 }
 
 // Tests for operator!= to work as expected
-TEST_CASE(__FILE__"/Operator_Not_Equals", "[Vector4]")
+TEST_CASE(__FILE__"/Operator_Not_Equals", "[Vector][Vector4]")
 {
     // Test 1000 times
     for (std::size_t i = 0; i < 1000; i++)
@@ -682,7 +682,7 @@ TEST_CASE(__FILE__"/Operator_Not_Equals", "[Vector4]")
 }
 
 // Tests matrix multiplication with the multiplication operator (*) with a known result
-TEST_CASE(__FILE__"/MatrixMult", "[Vector4]")
+TEST_CASE(__FILE__"/MatrixMult", "[Vector][Vector4]")
 {
     Vector4d vec(117, 12, -36, 500);
 
@@ -700,7 +700,7 @@ TEST_CASE(__FILE__"/MatrixMult", "[Vector4]")
 }
 
 // Tests matrix multiplication with the multiplication equals operator (*=) with a known result
-TEST_CASE(__FILE__"/MatrixMult_Equals", "[Vector4]")
+TEST_CASE(__FILE__"/MatrixMult_Equals", "[Vector][Vector4]")
 {
     Vector4d vec(117, 12, -36, 500);
 
@@ -718,7 +718,7 @@ TEST_CASE(__FILE__"/MatrixMult_Equals", "[Vector4]")
 }
 
 // Tests matrix multiplication with the multiplication operator (*) with a known result, but with an int-vector
-TEST_CASE(__FILE__"/MatrixMult_Int", "[Vector4]")
+TEST_CASE(__FILE__"/MatrixMult_Int", "[Vector][Vector4]")
 {
     Vector4i vec(112, -420, 80085, 1);
 
@@ -736,7 +736,7 @@ TEST_CASE(__FILE__"/MatrixMult_Int", "[Vector4]")
 }
 
 // Tests matrix multiplication with the multiplication equals operator (*=) with a known result, but with an int - vector
-TEST_CASE(__FILE__"/MatrixMult_Equals_Int", "[Vector4]")
+TEST_CASE(__FILE__"/MatrixMult_Equals_Int", "[Vector][Vector4]")
 {
     Vector4i vec(112, -420, 80085, 1);
 
@@ -754,7 +754,7 @@ TEST_CASE(__FILE__"/MatrixMult_Equals_Int", "[Vector4]")
 }
 
 // Tests loose comparison via Vector4d::Similar -> true
-TEST_CASE(__FILE__"/Loose_Comparison_True_Vector4d", "[Vector4]")
+TEST_CASE(__FILE__"/Loose_Comparison_True_Vector4d", "[Vector][Vector4]")
 {
     REQUIRE(
         Vector4d(0.00000000000000000000001, -6.6666666666666666666666666666, 9.9999999999999999999999999999, -3.3333333333333333333333333333333333333).Similar(
@@ -764,7 +764,7 @@ TEST_CASE(__FILE__"/Loose_Comparison_True_Vector4d", "[Vector4]")
 }
 
 // Tests loose comparison via Vector4d::Similar -> false
-TEST_CASE(__FILE__"/Loose_Comparison_False_Vector4d", "[Vector4]")
+TEST_CASE(__FILE__"/Loose_Comparison_False_Vector4d", "[Vector][Vector4]")
 {
     REQUIRE_FALSE(
         Vector4d(0.00000000000000000000001, -6.6666666666666666666666666666, 9.9999999999999999999999999999, -3.3333333333333333333333333333333333333).Similar(
@@ -774,7 +774,7 @@ TEST_CASE(__FILE__"/Loose_Comparison_False_Vector4d", "[Vector4]")
 }
 
 // Tests that the move constructor works
-TEST_CASE(__FILE__"/Move_Constructor", "[Vector4]")
+TEST_CASE(__FILE__"/Move_Constructor", "[Vector][Vector4]")
 {
     Vector4d a(1, 2, 3, 4);
     Vector4d b(std::move(a));
@@ -788,7 +788,7 @@ TEST_CASE(__FILE__"/Move_Constructor", "[Vector4]")
 }
 
 // Tests that the move operator works
-TEST_CASE(__FILE__"/Move_Operator", "[Vector4]")
+TEST_CASE(__FILE__"/Move_Operator", "[Vector][Vector4]")
 {
     Vector4d a(1, 2, 3, 4);
     Vector4d b = std::move(a);