From 6f6d69012f45a05f96168bf68341ff9f6b9841d1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= <mosra@centrum.cz>
Date: Wed, 24 Aug 2016 16:49:50 +0200
Subject: [PATCH] Math: added comparison operators to Bezier, expanded the
 test.

---
 src/Magnum/Math/Bezier.h            | 12 +++++
 src/Magnum/Math/Test/BezierTest.cpp | 75 ++++++++++++++++++++++++++---
 2 files changed, 80 insertions(+), 7 deletions(-)

diff --git a/src/Magnum/Math/Bezier.h b/src/Magnum/Math/Bezier.h
index 541df4750..7b45d7948 100644
--- a/src/Magnum/Math/Bezier.h
+++ b/src/Magnum/Math/Bezier.h
@@ -110,6 +110,18 @@ template<UnsignedInt order, UnsignedInt dimensions, class T> class Bezier {
         Vector<dimensions, T>& operator[](std::size_t i) { return _data[i]; }
         constexpr Vector<dimensions, T> operator[](std::size_t i) const { return _data[i]; } /**< @overload */
 
+        /** @brief Equality comparison */
+        bool operator==(const Bezier<order, dimensions, T>& other) const {
+            for(std::size_t i = 0; i != order + 1; ++i)
+                if((*this)[i] != other[i]) return false;
+            return true;
+        }
+
+        /** @brief Non-equality comparison */
+        bool operator!=(const Bezier<order, dimensions, T>& other) const {
+            return !operator==(other);
+        }
+
     private:
         /* Calculates and returns all intermediate points generated when using De Casteljau's algorithm */
         std::array<Bezier<order, dimensions, T>, order + 1> calculateIntermediatePoints(Float t) const {
diff --git a/src/Magnum/Math/Test/BezierTest.cpp b/src/Magnum/Math/Test/BezierTest.cpp
index 112962aa6..210fcb3be 100644
--- a/src/Magnum/Math/Test/BezierTest.cpp
+++ b/src/Magnum/Math/Test/BezierTest.cpp
@@ -41,7 +41,14 @@ typedef Math::CubicBezier2D<Float> CubicBezier2D;
 struct BezierTest : Corrade::TestSuite::Tester {
     explicit BezierTest();
 
-    void implicitConstructor();
+    void construct();
+    void constructDefault();
+    void constructNoInit();
+    void constructCopy();
+
+    void data();
+
+    void compare();
 
     void lerpQuadratic();
     void lerpCubic();
@@ -51,7 +58,14 @@ struct BezierTest : Corrade::TestSuite::Tester {
 };
 
 BezierTest::BezierTest() {
-    addTests({&BezierTest::implicitConstructor,
+    addTests({&BezierTest::construct,
+              &BezierTest::constructDefault,
+              &BezierTest::constructNoInit,
+              &BezierTest::constructCopy,
+
+              &BezierTest::data,
+
+              &BezierTest::compare,
 
               &BezierTest::lerpQuadratic,
               &BezierTest::lerpCubic,
@@ -60,11 +74,58 @@ BezierTest::BezierTest() {
               &BezierTest::configuration});
 }
 
-void BezierTest::implicitConstructor() {
-    QuadraticBezier2D bezier;
-    for(int i = 0; i < 3; ++i) {
-        CORRADE_COMPARE(bezier[i], Vector2{});
-    }
+void BezierTest::construct() {
+    /* The constructor should be implicit */
+    constexpr QuadraticBezier2D a = {Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}};
+    CORRADE_COMPARE(a, (QuadraticBezier2D{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}}));
+
+    CORRADE_VERIFY((std::is_nothrow_constructible<QuadraticBezier2D, Vector2, Vector2, Vector2>::value));
+}
+
+void BezierTest::constructDefault() {
+    constexpr QuadraticBezier2D a;
+    constexpr QuadraticBezier2D b{ZeroInit};
+    CORRADE_COMPARE(a, (QuadraticBezier2D{Vector2{}, Vector2{}, Vector2{}}));
+    CORRADE_COMPARE(b, (QuadraticBezier2D{Vector2{}, Vector2{}, Vector2{}}));
+
+    CORRADE_VERIFY(std::is_nothrow_default_constructible<QuadraticBezier2D>::value);
+    CORRADE_VERIFY((std::is_nothrow_constructible<QuadraticBezier2D, ZeroInitT>::value));
+}
+
+void BezierTest::constructNoInit() {
+    QuadraticBezier2D a{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}};
+    new(&a) QuadraticBezier2D{NoInit};
+    CORRADE_COMPARE(a, (QuadraticBezier2D{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}}));
+
+    CORRADE_VERIFY((std::is_nothrow_constructible<QuadraticBezier2D, NoInitT>::value));
+}
+
+void BezierTest::constructCopy() {
+    constexpr QuadraticBezier2D a{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}};
+    constexpr QuadraticBezier2D b{a};
+    CORRADE_COMPARE(b, (QuadraticBezier2D{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}}));
+
+    CORRADE_VERIFY(std::is_nothrow_copy_constructible<QuadraticBezier2D>::value);
+    CORRADE_VERIFY(std::is_nothrow_copy_assignable<QuadraticBezier2D>::value);
+}
+
+void BezierTest::data() {
+    QuadraticBezier2D a{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}};
+    a[0] = {};
+    a[2] = {0.7f, 20.3f};
+
+    CORRADE_COMPARE(a[0], (Vector2{0.0f, 0.0f}));
+    CORRADE_COMPARE(a[2], (Vector2{0.7f, 20.3f}));
+    CORRADE_COMPARE(a, (QuadraticBezier2D{Vector2{0.0f, 0.0f}, Vector2{1.1f, 0.3f}, Vector2{0.7f, 20.3f}}));
+
+    constexpr QuadraticBezier2D b{Vector2{3.5f, 0.1f}, Vector2{1.3f, 10.3f}, Vector2{0.0f, -1.2f}};
+    constexpr Vector2 c = b[2];
+    CORRADE_COMPARE(c, (Vector2{0.0f, -1.2f}));
+}
+
+void BezierTest::compare() {
+    CORRADE_VERIFY((QuadraticBezier2D{Vector2{0.5f, 1.0f + TypeTraits<Float>::epsilon()/2}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}} == QuadraticBezier2D{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}}));
+    CORRADE_VERIFY((QuadraticBezier2D{Vector2{0.5f, 1.1f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.0f + TypeTraits<Float>::epsilon()*2}} != QuadraticBezier2D{Vector2{0.5f, 1.1f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.0f}}));
 }
 
 void BezierTest::lerpQuadratic() {