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/intersection_tests/intersections_tests.cpp

+#include <intersections.h>
+#include <gtest/gtest.h>
+#include <edge.h>
+
+TEST (IntersectionTests, EdgeToEdgeTest) {
+    Edge e1 {{5,0}, {2,6}};
+    Edge e2 {{1,1}, {4,2}};
+
+    auto p = intersectionWithinEdge(e1, e2);
+    Point actual_point = p.value();
+    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

+#include <gtest/gtest.h>
+#include <orientation.h>
+#include <point.h>
+
+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, 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/point_in_triangle_tests.cpp

+#include <gtest/gtest.h>
+#include <triangle.h>
+
+TEST(PointInTriangleTests, PointInTriangle) {
+    Triangle t = Triangle({1, 0.5}, {3, 0.2}, {2, 1}, 0);
+    EXPECT_TRUE(t.pointInTriangle({1.96, 0.467}));
+    EXPECT_FALSE(t.pointInTriangle({1.107,0.834}));
+    EXPECT_FALSE(t.pointInTriangle({2.553, 0.823}));
+    EXPECT_FALSE(t.pointInTriangle({1.63, 0.13}));
+    EXPECT_FALSE(t.pointInTriangle({1, 0.5}));
+    EXPECT_FALSE(t.pointInTriangle({3, 0.2}));
+    EXPECT_FALSE(t.pointInTriangle({2,1}));
+}
\ No newline at end of file

tests/unit_tests/simple_triangle_tests.cpp

-#include "gtest/gtest.h"
-#include "../../src/shapes/triangle.h"
-#include "../../src/intersections/intersections.h"
+#include <gtest/gtest.h>
+#include <triangle.h>
+#include <intersections.h>
 
 TEST (TriangleIntersectionTests, TriangleIntersection) {
-    auto t1 = Triangle(Point(0,0), Point(2,3), Point(5,0), 0);
-    auto t2 = Triangle(Point(3,1), Point(4,3), Point(6,1), 0);
+    auto t1 = Triangle(Point{0,0}, Point{2,3}, Point{5,0}, 0);
+    auto t2 = Triangle(Point{3,1}, Point{4,3}, Point{6,1}, 0);
 
     std::vector<Point> results = intersections(t1, t2);
 
@@ -12,3 +12,4 @@ TEST (TriangleIntersectionTests, TriangleIntersection) {
 
 }
 
+

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