Trying to fix coverage.

source/include/material.h

@@ -46,6 +46,7 @@ public:
                                                       double_equal(this->emissive, b.emissive) &&
                                                       double_equal(this->refractiveIndex, b.refractiveIndex) &&
                                                       (this->colour == b.colour); };
+    bool operator!=(const Material &b) const { return !(*this == b); };
 };
 
 

source/include/tuple.h

@@ -26,6 +26,7 @@ public:
                                                    double_equal(this->y, b.y) &&
                                                    double_equal(this->z, b.z) &&
                                                    double_equal(this->w, b.w); };
+    bool operator!=(const Tuple &b) const { return !(*this == b); };
 
     Tuple operator+(const Tuple &b) const { return Tuple(this->x + b.x, this->y + b.y,
                                                          this->z + b.z, this->w + b.w); };

source/math_helper.cpp

@@ -43,13 +43,8 @@ double min3(double a, double b, double c)
     if (b <= a)
     {
         if (c < b) return c;
-        return b;
     }
-    if (c <= a)
-    {
-        if (b < c) return b;
-    }
-    return c;
+    return b;
 }
 
 double max3(double a, double b, double c)
@@ -62,11 +57,6 @@ double max3(double a, double b, double c)
     if (b >= a)
     {
         if (c > b) return c;
-        return b;
     }
-    if (c >= a)
-    {
-        if (b > c) return b;
-    }
-    return c;
+    return b;
 }

tests/material_test.cpp

@@ -122,3 +122,46 @@ TEST(MaterialTest, Transparency_and_refractive_index_for_the_default_material)
     ASSERT_EQ(m.transparency, 0.0);
     ASSERT_EQ(m.refractiveIndex, 1.0);
 }
+
+TEST(MaterialTest, Equality_tests)
+{
+    Material m = Material();
+    Material m2 = Material();
+
+    ASSERT_EQ(m, m2);
+
+    m.ambient = 42;
+    ASSERT_NE(m, m2);
+    m.ambient = m2.ambient;
+
+    m.diffuse = 42;
+    ASSERT_NE(m, m2);
+    m.diffuse = m2.diffuse;
+
+    m.specular = 42;
+    ASSERT_NE(m, m2);
+    m.specular = m2.specular;
+
+    m.shininess = 42;
+    ASSERT_NE(m, m2);
+    m.shininess = m2.shininess;
+
+    m.reflective = 42;
+    ASSERT_NE(m, m2);
+    m.reflective = m2.reflective;
+
+    m.transparency = 42;
+    ASSERT_NE(m, m2);
+    m.transparency = m2.transparency;
+
+    m.emissive = 42;
+    ASSERT_NE(m, m2);
+    m.emissive = m2.emissive;
+
+    m.refractiveIndex = 42;
+    ASSERT_NE(m, m2);
+    m.refractiveIndex = m2.refractiveIndex;
+
+    m.colour = Colour(32, 32, 32);
+    ASSERT_NE(m, m2);
+}

tests/tuple_test.cpp

@@ -22,6 +22,22 @@ TEST(TupleTest, Tuple_With_w_equal_1_and_is_point)
     ASSERT_FALSE(a.isVector());
 }
 
+TEST(TupleTest, Two_tuples_are_equal)
+{
+    Tuple a = Tuple(1, 2, 3, 4);
+    Tuple b = Tuple(1, 2, 3, 4);
+    Tuple c = Tuple(4, 3, 2, 1);
+    Tuple d = Tuple(1, 2, 3, 5);
+    Tuple e = Tuple(1, 2, 5, 5);
+    Tuple f = Tuple(1, 5, 5, 5);
+
+    ASSERT_EQ(a, b);
+    ASSERT_NE(a, c);
+    ASSERT_NE(a, d);
+    ASSERT_NE(a, e);
+    ASSERT_NE(a, f);
+}
+
 TEST(TupleTest, Tuple_With_w_equal_0_and_is_vector)
 {
     Tuple a = Tuple(4.3, -4.2, 3.1, 0.0);