test: Refactor test and introduce assertion_helper to separate tests and boilerplate

Signed-off-by: Sietze van Buuren <s.van.buuren@gmail.com>

Author: swvanbuuren

tests/assertion_helpers.hpp

@@ -0,0 +1,61 @@
+#include <vector>
+#include <gtest/gtest.h>
+
+
+namespace tcip {
+
+
+using Vector = std::vector<double>;
+using Vector2 = std::vector<Vector>;
+using Vector3 = std::vector<Vector2>;
+
+template <typename T>
+testing::AssertionResult Interp1DAssertions(Vector x, Vector f, Vector x_fine, Vector f_fine) {
+    T interp(x, f);
+    for ( auto i = 0; i < x_fine.size(); i++ ) {
+        auto val = interp.eval(x_fine[i]);
+        if (!testing::internal::CmpHelperFloatingPointEQ<double>("expected", "actual", val, f_fine[i])  ) {
+            return testing::AssertionFailure()
+                << "for x = " << x_fine[i] << "expected " << f_fine[i] << " but got " << val;
+        }
+    }
+    return testing::AssertionSuccess();
+}
+
+
+
+template <typename T>
+testing::AssertionResult Interp2DEvalAssertions(const tcip::Vector &x, const tcip::Vector &y, const Vector2 &f, const tcip::Vector &x_fine, const tcip::Vector &y_fine, const Vector2 &f_fine) {
+    T interp2(x, y, f);
+    for ( auto i = 0; i < x_fine.size(); ++i ) {
+        for ( auto j = 0; j < y_fine.size(); ++j ) {
+            auto val = interp2.eval(x_fine[i], y_fine[j]);
+            if (!testing::internal::CmpHelperFloatingPointEQ<double>("expected", "actual", val, f_fine[i][j])  ) {
+                return testing::AssertionFailure()
+                    << "for x = " << x_fine[i] << ", y = " << y_fine[j] << " expected " << f_fine[i][j] << " but got " << val;
+            }
+        }
+    }
+    return testing::AssertionSuccess();
+}
+
+
+template <typename T>
+testing::AssertionResult Interp3DEvalAssertions(const tcip::Vector &x, const tcip::Vector &y, const tcip::Vector &z, const Vector3 &f, const tcip::Vector &x_fine, const tcip::Vector &y_fine, const tcip::Vector &z_fine, const Vector3 &f_fine) {
+    T interp3(x, y, z, f);
+    for ( auto i = 0; i < x_fine.size(); ++i ) {
+        for ( auto j = 0; j < y_fine.size(); ++j ) {
+            for ( auto k = 0; k < y_fine.size(); ++k ) {
+                auto val = interp3.eval(x_fine[i], y_fine[j], z_fine[k]);
+                if (!testing::internal::CmpHelperFloatingPointEQ<double>("expected", "actual", val, f_fine[i][j][k])  ) {
+                    return testing::AssertionFailure()
+                        << "for x = " << x_fine[i] << ", y = " << y_fine[j] << ", z = " << z_fine[j] << " expected " << f_fine[i][j][k] << " but got " << val;
+                }
+            }
+        }
+    }
+    return testing::AssertionSuccess();
+}
+
+
+} // namespace tcip

tests/test_cubic_spline.cpp

@@ -1,27 +1,16 @@
-#include <vector>
 #include <gtest/gtest.h>
 #include <cubic_spline.hpp>
-
-using Vector = std::vector<double>;
+#include "assertion_helpers.hpp"
 
 
-testing::AssertionResult MonotonicSpline1DAssertions(Vector x, Vector f, Vector x_fine, Vector f_fine) {
-    cip::MonotonicSpline1D<double> interp(x, f);
-    for ( auto i = 0; i < x_fine.size(); i++ ) {
-        auto val = interp.eval(x_fine[i]);
-        if (!testing::internal::CmpHelperFloatingPointEQ<double>("expected", "actual", val, f_fine[i])  ) {
-            return testing::AssertionFailure()
-                << "for x = " << x_fine[i] << "expected " << f_fine[i] << " but got " << val;
-        }
-    }
-    return testing::AssertionSuccess();
-}
+using Vector = std::vector<double>;
+using MonotonicSpline = cip::MonotonicSpline1D<double>;
 
 
 TEST(TestCubicSpline1D, test_monotonic_spline_1d) {
-    Vector x = { 1, 2, 3, 4.0, 5.0, 5.5, 7.0, 8.0, 9.0, 9.5, 10 };
-    Vector f = { 0, 0, 0, 0.5, 0.4, 1.2, 1.2, 0.1, 0.0, 0.3, 0.6 };
-    Vector x_fine = { 1.0, 1.375, 1.75, 2.125, 2.5, 2.875, 3.25, 3.625, 4.0, 4.375, 4.75, 5.125, 5.5, 5.875, 6.25, 6.625, 7.0, 7.375, 7.75, 8.125, 8.5, 8.875, 9.25, 9.625, 10.0 };
-    Vector f_fine = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.07450161897651952, 0.3304738093015729, 0.5, 0.4542055428769416, 0.37848534450908033, 0.5453815182574999, 1.2, 1.2, 1.2, 1.2, 1.2000000000003865, 0.8762920673080998, 0.31081730769267324, 0.06762319711538467, 0.0009615384615386802, -0.01053185096153797, 0.11971153846116067, 0.3749999999999991, 0.5999999999999988 };
-    ASSERT_TRUE(MonotonicSpline1DAssertions(x, f, x_fine, f_fine));
+    tcip::Vector x = { 1, 2, 3, 4.0, 5.0, 5.5, 7.0, 8.0, 9.0, 9.5, 10 };
+    tcip::Vector f = { 0, 0, 0, 0.5, 0.4, 1.2, 1.2, 0.1, 0.0, 0.3, 0.6 };
+    tcip::Vector x_fine = { 1.0, 1.375, 1.75, 2.125, 2.5, 2.875, 3.25, 3.625, 4.0, 4.375, 4.75, 5.125, 5.5, 5.875, 6.25, 6.625, 7.0, 7.375, 7.75, 8.125, 8.5, 8.875, 9.25, 9.625, 10.0 };
+    tcip::Vector f_fine = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.07450161897651952, 0.3304738093015729, 0.5, 0.4542055428769416, 0.37848534450908033, 0.5453815182574999, 1.2, 1.2, 1.2, 1.2, 1.2000000000003865, 0.8762920673080998, 0.31081730769267324, 0.06762319711538467, 0.0009615384615386802, -0.01053185096153797, 0.11971153846116067, 0.3749999999999991, 0.5999999999999988 };
+    ASSERT_TRUE(tcip::Interp1DAssertions<MonotonicSpline>(x, f, x_fine, f_fine));
 }

tests/test_linear_interp.cpp

@@ -1,35 +1,19 @@
-#include <vector>
 #include <gtest/gtest.h>
 #include <utility>
 #include "linear_interp.hpp"
+#include "assertion_helpers.hpp"
+
 
-using Vector = std::vector<double>;
-using Vector2 = std::vector<Vector>;
-using Vector3 = std::vector<Vector2>;
 using VectorN1 = cip::VectorN<double, 1>;
 using VectorN2 = cip::VectorN<double, 2>;
 using VectorN3 = cip::VectorN<double, 3>;
 using Span = std::span<const double>;
 using Pr = std::pair<size_t, size_t>;
 
 
-testing::AssertionResult Interp1DAssertions(Vector x, Vector f, Vector x_fine, Vector f_fine) {
-    cip::LinearInterp1D<double> interp(x, f);
-    for ( auto i = 0; i < x_fine.size(); i++ ) {
-        auto val = interp.eval(x_fine[i]);
-        if (!testing::internal::CmpHelperFloatingPointEQ<double>("expected", "actual", val, f_fine[i])  ) {
-            return testing::AssertionFailure()
-                << "for x = " << x_fine[i] << "expected " << f_fine[i] << " but got " << val;
-        }
-    }
-    return testing::AssertionSuccess();
-}
-
-
-
 TEST(TestLinearCell1D, test_linear_cell_1d) {
-    Vector x = {0, 1, 2};
-    Vector f = {3, 3, 4};
+    tcip::Vector x = {0, 1, 2};
+    tcip::Vector f = {3, 3, 4};
 
     VectorN1 fvec(f);
     size_t i = 1;
@@ -45,27 +29,27 @@ TEST(TestLinearCell1D, test_linear_cell_1d) {
 
 
 TEST(TestInterp1D, test_linear_interp_1d_akima) {
-    Vector x = { 1.0, 2.0, 3.0, 4.0, 5.0, 5.5, 7.0, 8.0, 9.0, 9.5, 10.0 };
-    Vector f = { 0.0, 0.0, 0.0, 0.5, 0.4, 1.2, 1.2, 0.1, 0.0, 0.3, 0.6 };
-    Vector x_fine = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 };
-    Vector f_fine = { 0.0, 0.0, 0.0, 0.5, 0.4, 1.2, 1.2, 0.1, 0.0, 0.6 };
-    ASSERT_TRUE(Interp1DAssertions(x, f, x_fine, f_fine));
+    tcip::Vector x = { 1.0, 2.0, 3.0, 4.0, 5.0, 5.5, 7.0, 8.0, 9.0, 9.5, 10.0 };
+    tcip::Vector f = { 0.0, 0.0, 0.0, 0.5, 0.4, 1.2, 1.2, 0.1, 0.0, 0.3, 0.6 };
+    tcip::Vector x_fine = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 };
+    tcip::Vector f_fine = { 0.0, 0.0, 0.0, 0.5, 0.4, 1.2, 1.2, 0.1, 0.0, 0.6 };
+    ASSERT_TRUE(tcip::Interp1DAssertions<cip::LinearInterp1D<double>>(x, f, x_fine, f_fine));
 }
 
 
 TEST(TestInterp1D, test_linear_interp_1d_random) {
-    Vector x = { 1.0, 1.5714285714285714, 2.142857142857143, 2.7142857142857144, 3.2857142857142856, 3.8571428571428568, 4.428571428571429, 5.0 };
-    Vector f = { 4.0, 0.0, 6.0, 2.0, 3.0, 8.0, 4.0, 9.0 };
-    Vector x_fine = { 1.0, 1.4444444444444444, 1.8888888888888888, 2.333333333333333, 2.7777777777777777, 3.2222222222222223, 3.6666666666666665, 4.111111111111111, 4.555555555555555, 5.0 };
-    Vector f_fine = { 4.0, 0.8888888888888888, 3.3333333333333335, 4.66666666666667, 2.1111111111111107, 2.8888888888888893, 6.333333333333335, 6.222222222222224, 5.111111111111107, 9.0 };
-    ASSERT_TRUE(Interp1DAssertions(x, f, x_fine, f_fine));
+    tcip::Vector x = { 1.0, 1.5714285714285714, 2.142857142857143, 2.7142857142857144, 3.2857142857142856, 3.8571428571428568, 4.428571428571429, 5.0 };
+    tcip::Vector f = { 4.0, 0.0, 6.0, 2.0, 3.0, 8.0, 4.0, 9.0 };
+    tcip::Vector x_fine = { 1.0, 1.4444444444444444, 1.8888888888888888, 2.333333333333333, 2.7777777777777777, 3.2222222222222223, 3.6666666666666665, 4.111111111111111, 4.555555555555555, 5.0 };
+    tcip::Vector f_fine = { 4.0, 0.8888888888888888, 3.3333333333333335, 4.66666666666667, 2.1111111111111107, 2.8888888888888893, 6.333333333333335, 6.222222222222224, 5.111111111111107, 9.0 };
+    ASSERT_TRUE(tcip::Interp1DAssertions<cip::LinearInterp1D<double>>(x, f, x_fine, f_fine));
 }
 
 
 TEST(TestLinearCell2D, test_linear_cell_2d) {
-    Vector x = {0, 1, 2};
-    Vector y = {0, 1, 2};
-    Vector2 f = {{1, 2, 2},
+    tcip::Vector x = {0, 1, 2};
+    tcip::Vector y = {0, 1, 2};
+    tcip::Vector2 f = {{1, 2, 2},
                  {2, 3, 3},
                  {3, 3, 4}};
 
@@ -85,105 +69,74 @@ TEST(TestLinearCell2D, test_linear_cell_2d) {
 }
 
 
-testing::AssertionResult Interp2DEvalAssertions(const Vector &x, const Vector &y, const Vector2 &f, const Vector &x_fine, const Vector &y_fine, const Vector2 &f_fine) {
-    cip::LinearInterp2D<double> interp2(x, y, f);
-    for ( auto i = 0; i < x_fine.size(); ++i ) {
-        for ( auto j = 0; j < y_fine.size(); ++j ) {
-            auto val = interp2.eval(x_fine[i], y_fine[j]);
-            if (!testing::internal::CmpHelperFloatingPointEQ<double>("expected", "actual", val, f_fine[i][j])  ) {
-                return testing::AssertionFailure()
-                    << "for x = " << x_fine[i] << ", y = " << y_fine[j] << " expected " << f_fine[i][j] << " but got " << val;
-            }
-        }
-    }
-    return testing::AssertionSuccess();
-}
-
-
 TEST(TestInterp2D, test_linear_interp_2d_normalized) {
-    Vector x = { 0.0, 1.0, 2.0 };
-    Vector y = { 0.0, 1.0, 2.0 };
-    Vector2 f = { 
+    tcip::Vector x = { 0.0, 1.0, 2.0 };
+    tcip::Vector y = { 0.0, 1.0, 2.0 };
+    tcip::Vector2 f = { 
                 { 1.0, 2.0, 2.0 }, 
                 { 2.0, 3.0, 3.0 }, 
                 { 3.0, 3.0, 4.0 }
                 };
-    Vector x_fine = { 0.0, 0.5, 1.0, 1.5, 2.0 };
-    Vector y_fine = { 0.0, 0.5, 1.0, 1.5, 2.0 };
-    Vector2 f_fine = { 
+    tcip::Vector x_fine = { 0.0, 0.5, 1.0, 1.5, 2.0 };
+    tcip::Vector y_fine = { 0.0, 0.5, 1.0, 1.5, 2.0 };
+    tcip::Vector2 f_fine = { 
                     { 1.0, 1.5, 2.0, 2.0, 2.0 }, 
                     { 1.5, 2.0, 2.5, 2.5, 2.5 }, 
                     { 2.0, 2.5, 3.0, 3.0, 3.0 }, 
                     { 2.5, 2.75, 3.0, 3.25, 3.5 }, 
                     { 3.0, 3.0, 3.0, 3.5, 4.0 }
                     };
-    ASSERT_TRUE(Interp2DEvalAssertions(x, y, f, x_fine, y_fine, f_fine));    
+    ASSERT_TRUE(tcip::Interp2DEvalAssertions<cip::LinearInterp2D<double>>(x, y, f, x_fine, y_fine, f_fine));    
 }
 
 
 TEST(TestInterp2D, test_linear_interp_2d_standard) {
-    Vector x = { 0.0, 1.5, 3.0 };
-    Vector y = { 0.0, 2.0, 4.0 };
-    Vector2 f = { 
+    tcip::Vector x = { 0.0, 1.5, 3.0 };
+    tcip::Vector y = { 0.0, 2.0, 4.0 };
+    tcip::Vector2 f = { 
                 { 1.0, 2.0, 2.0 }, 
                 { 2.0, 3.0, 3.0 }, 
                 { 3.0, 3.0, 4.0 }
                 };
-    Vector x_fine = { 0.0, 0.75, 1.5, 2.25, 3.0 };
-    Vector y_fine = { 0.0, 1.0, 2.0, 3.0, 4.0 };
-    Vector2 f_fine = { 
+    tcip::Vector x_fine = { 0.0, 0.75, 1.5, 2.25, 3.0 };
+    tcip::Vector y_fine = { 0.0, 1.0, 2.0, 3.0, 4.0 };
+    tcip::Vector2 f_fine = { 
                     { 1.0, 1.5, 2.0, 2.0, 2.0 }, 
                     { 1.5, 2.0, 2.5, 2.5, 2.5 }, 
                     { 2.0, 2.5, 3.0, 3.0, 3.0 }, 
                     { 2.5, 2.75, 3.0, 3.25, 3.5 }, 
                     { 3.0, 3.0, 3.0, 3.5, 4.0 }
                     };
-    ASSERT_TRUE(Interp2DEvalAssertions(x, y, f, x_fine, y_fine, f_fine));    
+    ASSERT_TRUE(tcip::Interp2DEvalAssertions<cip::LinearInterp2D<double>>(x, y, f, x_fine, y_fine, f_fine));    
 }
 
 
 TEST(TestInterp2D, test_linear_interp_2d_non_monotonic) {
-    Vector x = { 0.0, 1.0, 1.5 };
-    Vector y = { 0.0, 0.5, 3.0 };
-    Vector2 f = { 
+    tcip::Vector x = { 0.0, 1.0, 1.5 };
+    tcip::Vector y = { 0.0, 0.5, 3.0 };
+    tcip::Vector2 f = { 
                 { 1.0, 2.0, 2.0 }, 
                 { 2.0, 3.0, 3.0 }, 
                 { 3.0, 3.0, 4.0 }
                 };
-    Vector x_fine = { 0.0, 0.375, 0.75, 1.125, 1.5 };
-    Vector y_fine = { 0.0, 0.75, 1.5, 2.25, 3.0 };
-    Vector2 f_fine = { 
+    tcip::Vector x_fine = { 0.0, 0.375, 0.75, 1.125, 1.5 };
+    tcip::Vector y_fine = { 0.0, 0.75, 1.5, 2.25, 3.0 };
+    tcip::Vector2 f_fine = { 
                     { 1.0, 2.0, 2.0, 2.0, 2.0 }, 
                     { 1.375, 2.375, 2.375, 2.375, 2.375 }, 
                     { 1.75, 2.75, 2.75, 2.75, 2.75 }, 
                     { 2.25, 3.025, 3.1, 3.175, 3.25 }, 
                     { 3.0, 3.1, 3.4, 3.7, 4.0 }
                     };
-    ASSERT_TRUE(Interp2DEvalAssertions(x, y, f, x_fine, y_fine, f_fine));    
+    ASSERT_TRUE(tcip::Interp2DEvalAssertions<cip::LinearInterp2D<double>>(x, y, f, x_fine, y_fine, f_fine));    
 }
 
 
-testing::AssertionResult Interp3DEvalAssertions(const Vector &x, const Vector &y, const Vector &z, const Vector3 &f, const Vector &x_fine, const Vector &y_fine, const Vector &z_fine, const Vector3 &f_fine) {
-    cip::LinearInterp3D<double> interp3(x, y, z, f);
-    for ( auto i = 0; i < x_fine.size(); ++i ) {
-        for ( auto j = 0; j < y_fine.size(); ++j ) {
-            for ( auto k = 0; k < y_fine.size(); ++k ) {
-                auto val = interp3.eval(x_fine[i], y_fine[j], z_fine[k]);
-                if (!testing::internal::CmpHelperFloatingPointEQ<double>("expected", "actual", val, f_fine[i][j][k])  ) {
-                    return testing::AssertionFailure()
-                        << "for x = " << x_fine[i] << ", y = " << y_fine[j] << ", z = " << z_fine[j] << " expected " << f_fine[i][j][k] << " but got " << val;
-                }
-            }
-        }
-    }
-    return testing::AssertionSuccess();
-}
-
 TEST(TestInterp3D, test_linear_interp_3d) {
-    Vector x = { 0.0, 1.0, 2.0 };
-    Vector y = { 0.0, 1.0, 2.0 };
-    Vector z = { 0.0, 1.0, 2.0 };
-    Vector3 f = { 
+    tcip::Vector x = { 0.0, 1.0, 2.0 };
+    tcip::Vector y = { 0.0, 1.0, 2.0 };
+    tcip::Vector z = { 0.0, 1.0, 2.0 };
+    tcip::Vector3 f = { 
               { 
                 { 1.0, 2.0, 2.0 }, 
                 { 2.0, 3.0, 3.0 }, 
@@ -200,10 +153,10 @@ TEST(TestInterp3D, test_linear_interp_3d) {
                 { 4.0, 4.0, 5.0 }
             }
             };
-    Vector x_fine = { 0.0, 0.5, 1.0, 1.5, 2.0 };
-    Vector y_fine = { 0.0, 0.5, 1.0, 1.5, 2.0 };
-    Vector z_fine = { 0.0, 0.5, 1.0, 1.5, 2.0 };
-    Vector3 f_fine = { 
+    tcip::Vector x_fine = { 0.0, 0.5, 1.0, 1.5, 2.0 };
+    tcip::Vector y_fine = { 0.0, 0.5, 1.0, 1.5, 2.0 };
+    tcip::Vector z_fine = { 0.0, 0.5, 1.0, 1.5, 2.0 };
+    tcip::Vector3 f_fine = { 
                    { 
                      { 1.0, 1.5, 2.0, 2.0, 2.0 }, 
                      { 1.5, 2.0, 2.5, 2.5, 2.5 }, 
@@ -241,6 +194,6 @@ TEST(TestInterp3D, test_linear_interp_3d) {
                  }
                 };
 
-ASSERT_TRUE(Interp3DEvalAssertions(x, y, z, f, x_fine, y_fine, z_fine, f_fine));    
+ASSERT_TRUE(tcip::Interp3DEvalAssertions<cip::LinearInterp3D<double>>(x, y, z, f, x_fine, y_fine, z_fine, f_fine));    
 
 }