tests/union_neighbours_tests.cpp

+#include <gtest/gtest.h>
+#include <triangle.h>
+#include <union.h>
+
+TEST (UnionNeighbourTests, NeighbourTest) {
+	Triangle t1 = Triangle({}, {}, {}, 1, {2});
+	Triangle t2 = Triangle({}, {}, {}, 2, {1});
+
+	auto results = unionize(t1, t2);
+	std::vector<Triangle> expected ={t1, t2} ;
+
+	EXPECT_EQ(results, expected);
+}

tests/union_tests.cpp

 #include "gtest/gtest.h"
 #include <union.h>
 #include <triangle.h>
+#include <orientation.h>
+#include <shift_triangle.h>
+#include "union_tests.h"
+
+std::ostream &operator<<(std::ostream &os, const UnionParams &u) {
+	os << u.t1 << "|" << u.t2;
+	return os;
+}
 
 TEST(UnionTrivialTests, NotTouching)
 {
@@ -15,38 +23,45 @@ TEST(UnionTrivialTests, NotTouching)
 TEST(UnionTests, TwoIntersections)
 {
 
-    auto t1 = Triangle(Point{0, 0}, Point{5, 0}, Point{2, 3}, 0);
-    auto t2 = Triangle(Point{3, 1}, Point{6, 1}, Point{4, 3}, 1);
+    auto t1 = Triangle(Point{0, 0, 0}, Point{5, 0, 0}, Point{2, 3, 0}, 1);
+    auto t2 = Triangle(Point{3, 1, 1}, Point{6, 1, 1}, Point{4, 3, 1}, 2);
 
     auto ts = unionize(t1, t2);
 
     EXPECT_TRUE(ts.size() == 3);
 
     std::vector<Triangle> expected{
-	    Triangle({4,1}, {3.3333, 1.6666}, {4,3}, 1, 0),
-		    Triangle({4,1}, {4,3}, {6,1}, 1,0),
-    Triangle({0,0}, {5,0}, {2,3}, 0, 0)};
+	    Triangle({6,1,1}, {4,3,1}, {3.333333,1.66666,1}, 2),
+		    Triangle({6,1,1}, {3.33333,1.66667,1}, {4,1,1},2),
+    Triangle({0,0}, {5,0}, {2,3}, 1)};
     EXPECT_EQ(ts, expected);
 }
 
 // Edge Case
+
 TEST(UnionTests, SharesPointTest)
 {
     // Case 1 t1 covers t2
-    Triangle bottom = Triangle({0, 5}, {3, 2}, {5, 3}, 1, 1);
-    Triangle top = Triangle({0.1, 7}, {5, 3}, {3.2, 9}, 2, 2);
+    Triangle top = Triangle({0, 5}, {3, 2}, {5, 3}, 1);
+    Triangle bottom = Triangle({0.1, 7, 5}, {5, 3,5}, {3.2, 9,5}, 2);
 
     auto results = unionize(bottom, top);
-    std::vector<Triangle> expected_results_1;
+    std::vector<Triangle> expected_results_1 = {
+	Triangle({0.1, 7, 5}, {5, 3,5}, {3.2, 9,5}, 2),
+    	Triangle({0, 5}, {3, 2}, {5, 3}, 1)
+    };
 
     EXPECT_EQ(results, expected_results_1);
 
     // Case 2 t2 covers t1
-    bottom.depth = 3;
+    shiftZ(top, 10);
 
     results = unionize(bottom, top);
 
-    std::vector<Triangle> expected_results_2;
+    std::vector<Triangle> expected_results_2 {
+	Triangle({0, 5, 10}, {3, 2, 10}, {5, 3, 10}, 1),
+	Triangle({0.1, 7, 5}, {5, 3,5}, {3.2, 9,5}, 2)
+    };
 
     EXPECT_EQ(results, expected_results_2);
 }
@@ -54,60 +69,86 @@ TEST(UnionTests, SharesPointTest)
 TEST(UnionTests, FoldTriangleTest)
 {
 
-    Triangle bottom = Triangle({0, 5}, {3, 2}, {5, 3}, 1, 1);
-    Triangle top = Triangle({0.1, 9}, {5, 5}, {2, 4}, 2, 2);
+    Triangle top = Triangle({0, 5}, {3, 2}, {5, 3}, 1);
+    Triangle bottom = Triangle({0.1, 9,1}, {2, 4,1}, {5,5,1}, 2);
 
     auto results = unionize(bottom, top);
 
-    std::vector<Triangle> expected_results_1;
+    std::vector<Triangle> expected_results_1 = {
+	    Triangle({0.1,9,1}, {1.91038,4.23585,1}, {2.27273,4.09091,1}, 2), 
+	    Triangle({0.1,9,1}, {2.27273,4.09091,1}, {5,5,1}, 2), 
+	    Triangle({0,5,0}, {3,2,0}, {5,3,0}, 1)
+    };
 
     EXPECT_EQ(results, expected_results_1);
 
-    bottom.depth = 3;
+    shiftZ(top, 3);
 
     results = unionize(bottom, top);
 
-    std::vector<Triangle> expected_results_2;
+    std::vector<Triangle> expected_results_2 = {
+	    Triangle({0,5,3}, {2.6129,2.3871,3}, {1.91038,4.23585,3}, 1),
+	    Triangle({3,2,3}, {5,3,3}, {2.27273,4.09091,3}, 1), 
+	    Triangle({3,2,3}, {2.27273,4.09091,3}, {2.6129,2.3871,3}, 1),
+	    Triangle({2.6129,2.3871,3}, {2.27273,4.09091,3}, {2,4,3}, 1), 
+	    Triangle({0.1,9,1}, {2,4,1}, {5,5,1}, 2)
+    };
 
     EXPECT_EQ(results, expected_results_2);
 }
 
-TEST(UnionTests, IceCreamTest)
+
+TEST(UnionTests, StarTest)
 {
-    Triangle bottom = Triangle({0, 5}, {3, 2}, {5, 3}, 2, 1);
-    Triangle top = Triangle({-1, 5}, {2, 4}, {5, 7}, 1, 2);
+    Triangle top = Triangle({0, 3,0}, {5, 3,0}, {2.5, 6,0}, 1);
+    Triangle bot = Triangle({0, 5, 1}, {2, 0, 1}, {5, 5, 1}, 2);
 
-    auto results = unionize(bottom, top);
+    ASSERT_EQ(orientation(top.points[0], top.points[1], top.points[2]), Counterclockwise);
+    ASSERT_EQ(orientation(bot.points[0], bot.points[1], bot.points[2]), Counterclockwise);
+
+    auto results = unionize(top, bot);
 
-    std::vector<Triangle> expected_results_1;
+    std::vector<Triangle> expected_results_1 = {
+        Triangle({2,0,1}, {3.8, 3,1}, {0.8, 3, 1}, 2),
+        Triangle({5,5,1}, {3.33333, 5, 1}, {4.30233, 3.83721, 1}, 2),
+        Triangle({0,5,1}, {0.540541, 3.64865, 1}, {1.66667, 5, 1}, 2),
+        Triangle({0, 3}, {5, 3}, {2.5, 6}, 1)
+    };
 
     EXPECT_EQ(results, expected_results_1);
 
-    top.depth = 3;
+    shiftZ(top, 3);
 
-    results = unionize(bottom, top);
+    results = unionize(top, bot);
 
-    std::vector<Triangle> expected_results_2;
+    std::vector<Triangle> expected_results_2 = {
+        Triangle({0,3,3}, {0.8,3,3}, {0.540541,3.64865,3}, 1),
+        Triangle({5,3,3}, {4.30233,3.83721,3}, {3.8,3,3}, 1),
+        Triangle({2.5,6,3}, {1.66667,5,3}, {3.33333,5,3}, 1),
+        Triangle({0,5, 1}, {2,0,1}, {5,5,1}, 2)
+    };
 
     EXPECT_EQ(results, expected_results_2);
 }
 
-TEST(UnionTests, StarTest)
-{
-    Triangle bottom = Triangle({0, 3}, {2.5, 6}, {5, 3}, 1, 1);
-    Triangle top = Triangle({0, 5}, {2, 0}, {5, 5}, 2, 2);
 
-    auto results = unionize(bottom, top);
-
-    std::vector<Triangle> expected_results_1;
-
-    EXPECT_EQ(results, expected_results_1);
-
-    bottom.depth = 3;
+TEST_P(InstantiateUnionTests, UnionTest)
+{
+	const Triangle &t1 = GetParam().t1;
+	const Triangle &t2 = GetParam().t2;
+	auto expected = GetParam().expected;
 
-    results = unionize(bottom, top);
+	ASSERT_NE(orientation(t1), Clockwise);
+	ASSERT_NE(orientation(t2), Clockwise);
 
-    std::vector<Triangle> expected_results_2;
+	auto result = unionize(t1, t2);
 
-    EXPECT_EQ(results, expected_results_2);
+	EXPECT_EQ(result, expected);
 }
+
+INSTANTIATE_TEST_SUITE_P(ParameterizedUnionTests, InstantiateUnionTests, testing::Values(
+    UnionParams{Triangle({0, 0, 0}, {5, 0, 0}, {2, 3, 0}, 1), Triangle(Point{3, 1, 10}, Point{6, 1, 2}, Point{4, 3, 1}, 2), 
+    {Triangle({6,1,2}, {4,3,1}, {3.333333,1.66666,7.23542}, 2),
+     Triangle({6,1,2}, {3.33333,1.66667,7.23542}, {4,1,7.3680},2),
+      Triangle({0,0}, {5,0}, {2,3}, 1)}}, UnionParams{Triangle({0,0.1,10}, {0.234, 0.3, 9}, {0.1, 0.5, 9}, 1), Triangle({-100, -100, 0}, {100, -100, 0}, {25, 50, 0}, 2), {Triangle({-100, -100}, {100, -100}, {25, 50}, 2)}}
+));
\ No newline at end of file

tests/union_tests.h

+#pragma once
+#include <triangle.h>
+
+struct UnionParams
+{
+	Triangle t1;
+	Triangle t2;
+	std::vector<Triangle> expected;
+};
+
+class InstantiateUnionTests : public testing::TestWithParam<UnionParams>{};
+
+
+std::ostream &operator<<(std::ostream &os, const UnionParams &u);
+

tests/unit_tests/contourize_tests.cpp

@@ -4,12 +4,35 @@
 #include <intersections.h>
 
 TEST(ContourizeTest, Simple) {
-	std::vector<Point> points{{6,1}, {4,3}, {4, 1}, {3.3333, 1.6666}};
+	std::vector<Point> points{{0,0}, {5,0}, {2, 3}};
 
 	auto result = contourize(points);
 
-	std::vector<Point> expected{{4,1}, {3.3333,1.6666}, {4,3}, {6,1}};
+	std::vector<Point> expected{{0,0}, {5,0}, {2, 3}};
 	EXPECT_EQ(result, expected);
 }
 
+TEST (ContourizeTest, Collinear) {
+	std::vector<Point> points {{2,3,5}, {0,0,5}, {2.5,2.5,5}, {-0,0,5}};
+	auto result = contourize(points);
+	
+}
+
+TEST(ContourizeTest, Triangle) {
+	std::vector<Point> points{{3,1}, {4,1}, {3.33333, 1.6666}};
+	auto result = contourize(points);
+
+	std::vector<Point> expected{{3,1}, {4,1}, {3.33333, 1.6666}};
+	EXPECT_EQ(result, expected);
+}
+
+/*
+TEST(ContourizeTest, TestCase3) {
+
+	std::vector<Point> points{{0.100000001,9}, {5,5}, {1.91037738, 4.2358489}, {2.27272725, 4.090909}, {9.80392265, 1.07843113}};
+	auto result = contourize(points);
+
 
+	std::vector<Point> expected{{3,1}, {4,1}, {3.33333, 1.6666}};
+	EXPECT_EQ(result, expected);
+}*/

tests/unit_tests/convex_triangulation_tests.cpp

@@ -14,12 +14,12 @@ TEST(ConvexTriangulationTests, Simple) {
 		p1, p2, p3, p4, p5
 	};	
 
-	auto results = convexTriangulation(points, 2, 2);
+	auto results = convexTriangulation(points, 2, std::make_shared<std::vector<int>>());
 
 	std::vector<Triangle> expected_result {
-		Triangle(p1, p2, p3, 2, 2),
-			Triangle(p1, p3, p5, 2, 2),
-			Triangle(p5, p3, p4, 2, 2)
+		Triangle(p1, p2, p3, 2),
+			Triangle(p1, p3, p5, 2),
+			Triangle(p5, p3, p4, 2)
 	};
 	
 	EXPECT_EQ(results, expected_result);
@@ -33,8 +33,8 @@ TEST(ConvexTriangulationTests, TrivialTriangle) {
 		{1.5, 2}
 	};
 
-	auto results = convexTriangulation(points, 1, 1);
-	Triangle expected_triangle = Triangle({0,0}, {2,0}, {1.5, 2}, 1, 1);
+	auto results = convexTriangulation(points, 1, std::make_shared<std::vector<int>>());
+	Triangle expected_triangle = Triangle({0,0}, {2,0}, {1.5, 2}, 1);
 
 	EXPECT_EQ(results.size(), 1);
 	EXPECT_EQ(results[0], expected_triangle);

tests/unit_tests/ear_removal_tests.cpp

-#include <gtest/gtest.h>
-#include <triangulation.h>
-#include <vector>
-#include <point.h>
-#include <pointList.h>
-
-TEST(EarRemovalTests, SingleEarRemoval) {
-    std::vector<Point> polygon = {
-        {3,48}, {52, 8}, {99,50}, {138,25},
-         {175, 77}, {131, 72}, {111, 113},
-          {72, 43}, {26, 55}, {29, 100}};
-
-    PointList pointList = PointList(polygon);
-    int index = 0;
-    auto t = removeEar(index, pointList, polygon);
-    EXPECT_FALSE(t.has_value());
-    EXPECT_TRUE(true);
-
-    auto t2 = removeEar(index, pointList, polygon);
-
-    auto t3 = removeEar(index, pointList, polygon);
-}
\ No newline at end of file

tests/unit_tests/edge_direction_intr_tests.cpp

-#include <intersections.h>
-#include <gtest/gtest.h>
-#include <edge.h>
-
-TEST(EdgeDirectionIntersectionTests, BasicTests) {
-	Edge e1{ {5,0}, {2,3}};
-
-	Edge e2{{3,1}, {6,1}};
-
-	auto result = intersectionWithinEdgeDirection(e1, e2);
-
-	ASSERT_TRUE(result.has_value());
-
-	Point expected = Point{4,1};
-	EXPECT_EQ(result.value(), expected);
-
-	Edge e3{{4,3}, {3,1}};
-	auto result2 = intersectionWithinEdgeDirection(e3, e1);
-
-	ASSERT_TRUE(result2.has_value());
-	Point expected2 = Point{3.33333,1.66667};
-	EXPECT_EQ(result2.value(), expected2);
-
-	Edge e4{{3,1}, {4,3}};
-	Edge e5{{0,0}, {5,0}};
-
-	auto result3 = intersectionWithinEdgeDirection(e4, e5);
-	EXPECT_FALSE(result3.has_value()) << result3.value();
-}
-

tests/unit_tests/interpolate_z_tests.cpp

+#include <gtest/gtest.h>
+#include <interpolate_z.h>
+#include <point.h>
+#include <edge.h>
+
+struct InterpolateParams {
+    Edge e;
+    Point point;
+    float expected_z;
+};
+
+std::ostream &operator<<(std::ostream & out, const Edge &e) {
+    return out << e.p1 << ", " << e.p2;
+}
+
+std::ostream &operator<<(std::ostream & out, const InterpolateParams &p) {
+    return out << "Edge: " << p.e << "Point: " << p.point;
+}
+
+class InstantiateInterpolateZTests : public testing::TestWithParam<InterpolateParams>{
+};
+
+TEST_P (InstantiateInterpolateZTests, Interpolate) {
+    
+	Edge e = GetParam().e;
+    Point point = GetParam().point;
+
+    float z = interpolateZ(e, point);
+
+    EXPECT_EQ(z,GetParam().expected_z);
+}
+
+INSTANTIATE_TEST_SUITE_P(Interpolation, InstantiateInterpolateZTests, testing::Values(
+    InterpolateParams{{{1,1,3}, {2,2,3}}, {1.5,1.5},3},
+    InterpolateParams{{{1,1,5}, {1,1,5}}, {1,1},5},
+    InterpolateParams{{{1,1,10}, {2,3,15}}, {2,3},15},
+    InterpolateParams{{{1,1,10}, {2,2,0}}, {1,1},10},
+    InterpolateParams{{{1,1,10}, {2,2,0}}, {2,2},0},
+    InterpolateParams{{{5, 3,3}, {2.5, 6,3}}, {0.540541,3.64865},3}
+    ));
+

tests/unit_tests/intersections_tests.cpp → tests/unit_tests/intersection_tests/intersections_tests.cpp

@@ -11,3 +11,13 @@ TEST (IntersectionTests, EdgeToEdgeTest) {
     Point expected_point = Point{4,2};
     EXPECT_TRUE(actual_point == expected_point);
 }
+
+
+TEST (IntersectionTests, EdgeTest) {
+    Edge e1{{0.8, 3}, {5,3}};
+    Edge e2{{2,0}, {5,5}};
+
+    auto p = intersectionFirstSide(e1,e2);
+
+    EXPECT_TRUE(p.has_value());
+}
\ No newline at end of file

tests/unit_tests/orientation_tests.cpp

@@ -2,10 +2,25 @@
 #include <orientation.h>
 #include <point.h>
 
-TEST (OrientationTests, Collinear) {
-    EXPECT_EQ(orientation(Point{0,0}, Point{1,0}, Point{2,0}), Collinear);
+TEST(OrientationTests, Collinear)
+{
+    EXPECT_EQ(orientation(Point{0, 0}, Point{1, 0}, Point{2, 0}), Collinear);
 }
 
-TEST (OrientationTests, ExampleCounterClockwiseTest) {
-    EXPECT_EQ(orientation(Point{0,0}, Point{4,4}, Point{1,2}), Counterclockwise);
+TEST(OrientationTests, ExampleCounterClockwiseTest)
+{
+    EXPECT_EQ(orientation(Point{0, 0}, Point{4, 4}, Point{1, 2}), Counterclockwise);
 }
+
+TEST (OrientationTests, Counterclockwise) {
+    EXPECT_EQ(orientation({0,0}, {5,0}, {2,3}), Counterclockwise);
+}
+
+TEST(OrientationTests, TestAll)
+{
+    Point p1 = {3, 1};
+    Point p2 = {4, 1};
+    Point p3 = {3.333, 1.666};
+    EXPECT_EQ(orientation(p1, p2, p3), Counterclockwise);
+    EXPECT_EQ(orientation(p2, p1, p3), Clockwise);
+}
\ No newline at end of file

tests/unit_tests/split_triangle_tests.cpp

+#include <gtest/gtest.h>
+#include <split_triangle.h>
+#include <triangle.h>
+#include <edge.h>
+
+
+TEST(SplitTriangleTests, NormalCase2) {
+    std::vector<Point> t {{0.1, 9}, {2,4}, {5,5}};
+    Edge e{{5,3}, {0,5}};
+
+    auto results = splitShape(t, e);
+
+    auto pos = results[0];
+    EXPECT_TRUE(pos.size() > 1);
+}
+
+TEST(SplitTriangleTests, InvisibleIntersection) {
+    Edge e {{0.1,9}, {2,4}};
+    std::vector<Point> t{{0,5}, {3,2}, {5,5}};
+
+    auto results = splitShape(t,e);
+
+    EXPECT_TRUE(results[1].size() > 2);
+}
+
+TEST (SplitTriangleTests, Quadric) {
+    Edge e {{2,4}, {5,5}};
+    std::vector<Point> p{{3,2}, {5,3}, {1.91037738, 4.2358489}, {2.61290312,2.38709688}};
+
+    auto results = splitShape(p,e);
+
+    EXPECT_TRUE(results[0].size() > 2);
+}
+
+TEST(SplitTriangleTests, OnEdge1) {
+    std::vector<Point> t {{0,0}, {0,5}, {2,3}};
+    Edge e = Edge{{1,1}, {0,1}};
+
+    auto results = splitShape(t, e);
+
+    EXPECT_EQ(results[0].size(), 4);
+    EXPECT_EQ(results[1].size(), 3);
+}
+
+TEST(SplitTriangleTests, OnEdge2) {
+
+    std::vector<Point> t {{0,0}, {0,5}, {2,3}};
+    Edge e {{1,1}, {0,3}};
+
+    auto results = splitShape(t,e);
+
+    EXPECT_EQ(results[0].size(), 4);
+}

tests/unit_tests/triangulation_tests.cpp

-#include "gtest/gtest.h"
-#include <point.h>
-#include <triangulation.h>
-
-TEST(TriangulationTests, Page3Example) {
-    std::vector<Point> polygon = {
-        {3,48}, {52, 8}, {99,50}, {138,25},
-         {175, 77}, {131, 72}, {111, 113},
-          {72, 43}, {26, 55}, {29, 100}};
-
-    auto t = triangulate(polygon);    
-    EXPECT_TRUE(t.size() > 0);
-}
\ No newline at end of file