Fix unitary tests

git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/branches/persistence_representation_integration_cmake_improvement@3088 636b058d-ea47-450e-bf9e-a15bfbe3eedb

Former-commit-id: db6f2e909552d643597925b312b7b50743924dfa

5 files changed, 145 insertions, 169 deletions

diff --git a/src/Persistence_representations/test/persistence_intervals_test.cpp b/src/Persistence_representations/test/persistence_intervals_test.cpp
index 545330c4..c8f67966 100644
--- a/src/Persistence_representations/test/persistence_intervals_test.cpp
+++ b/src/Persistence_representations/test/persistence_intervals_test.cpp
@@ -25,25 +25,20 @@
 #include <boost/test/unit_test.hpp>
 #include <gudhi/reader_utils.h>
 #include "gudhi/Persistence_intervals.h"
+#include <gudhi/common_persistence_representations.h>
+#include <gudhi/Unitary_tests_utils.h>
 
 #include <iostream>
 
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
-double epsilon = 0.0000005;
-
-// cout << "Left most end of the interval : " << min_max_.first << std::endl;
-// cout << "Right most end of the interval : " << min_max_.second << std::endl;
 BOOST_AUTO_TEST_CASE(check_min_max_function) {
-	std::cerr << "First test \n";
   Persistence_intervals p("data/file_with_diagram");
   std::pair<double, double> min_max_ = p.get_x_range();
 
-  // cout << min_max_.first << " " << min_max_.second << std::endl;getchar();
-
-  BOOST_CHECK(fabs(min_max_.first - 0.0290362) <= epsilon);
-  BOOST_CHECK(fabs(min_max_.second - 0.994537) <= epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(min_max_.first, 0.0290362, Gudhi::Persistence_representations::epsi);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(min_max_.second, 0.994537, Gudhi::Persistence_representations::epsi);
 }
 
 BOOST_AUTO_TEST_CASE(check_length_of_dominant_intervals) {
@@ -61,7 +56,8 @@ BOOST_AUTO_TEST_CASE(check_length_of_dominant_intervals) {
   dominant_intervals_length.push_back(0.700468);
   dominant_intervals_length.push_back(0.622177);
   for (size_t i = 0; i != dominant_ten_intervals_length.size(); ++i) {
-    BOOST_CHECK(fabs(dominant_ten_intervals_length[i] - dominant_intervals_length[i]) <= epsilon);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(dominant_ten_intervals_length[i], dominant_intervals_length[i],
+                                    Gudhi::Persistence_representations::epsi);
   }
 }
 BOOST_AUTO_TEST_CASE(check_dominant_intervals) {
@@ -81,8 +77,10 @@ BOOST_AUTO_TEST_CASE(check_dominant_intervals) {
   templ.push_back(std::pair<double, double>(0.267421, 0.889597));
 
   for (size_t i = 0; i != ten_dominant_intervals.size(); ++i) {
-    BOOST_CHECK(fabs(ten_dominant_intervals[i].first - templ[i].first) <= epsilon);
-    BOOST_CHECK(fabs(ten_dominant_intervals[i].second - templ[i].second) <= epsilon);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(ten_dominant_intervals[i].first, templ[i].first,
+                                    Gudhi::Persistence_representations::epsi);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(ten_dominant_intervals[i].second, templ[i].second,
+                                    Gudhi::Persistence_representations::epsi);
   }
 }
 
@@ -102,7 +100,7 @@ BOOST_AUTO_TEST_CASE(check_histogram_of_lengths) {
   template_histogram.push_back(1);
   template_histogram.push_back(1);
   for (size_t i = 0; i != histogram.size(); ++i) {
-    BOOST_CHECK(fabs(histogram[i] - template_histogram[i]) <= epsilon);
+    BOOST_CHECK(histogram[i] == template_histogram[i]);
   }
 }
 
@@ -123,7 +121,7 @@ BOOST_AUTO_TEST_CASE(check_cumulative_histograms_of_lengths) {
   template_cumulative_histogram.push_back(45);
 
   for (size_t i = 0; i != cumulative_histogram.size(); ++i) {
-    BOOST_CHECK(fabs(cumulative_histogram[i] - template_cumulative_histogram[i]) <= epsilon);
+    BOOST_CHECK(cumulative_histogram[i] == template_cumulative_histogram[i]);
   }
 }
 BOOST_AUTO_TEST_CASE(check_characteristic_function_of_diagram) {
@@ -143,15 +141,8 @@ BOOST_AUTO_TEST_CASE(check_characteristic_function_of_diagram) {
   template_char_funct_diag.push_back(0.0676303);
 
   for (size_t i = 0; i != char_funct_diag.size(); ++i) {
-    // cout << char_funct_diag[i] << std::endl;
-    if (fabs(char_funct_diag[i] - template_char_funct_diag[i]) >= 0.0001) {
-      std::cout << "Boost test fail  check_characteristic_function_of_diagram : " << std::endl;
-      std::cerr << char_funct_diag[i] << " " << template_char_funct_diag[i] << std::endl;
-      std::cerr << fabs(char_funct_diag[i] - template_char_funct_diag[i]) << std::endl;
-      std::cerr << 0.0001 << std::endl;
-      //getchar();
-    }
-    BOOST_CHECK(fabs(char_funct_diag[i] - template_char_funct_diag[i]) <= 0.0001);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(char_funct_diag[i], template_char_funct_diag[i],
+                                    Gudhi::Persistence_representations::epsi);
   }
 }
 
@@ -174,110 +165,110 @@ BOOST_AUTO_TEST_CASE(check_cumulative_characteristic_function_of_diagram) {
   template_char_funct_diag_cumul.push_back(9.48386);
 
   for (size_t i = 0; i != cumul_char_funct_diag.size(); ++i) {
-    // cout << cumul_char_funct_diag[i] << std::endl;
-    BOOST_CHECK(fabs(cumul_char_funct_diag[i] - template_char_funct_diag_cumul[i]) <= 0.0001);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(cumul_char_funct_diag[i], template_char_funct_diag_cumul[i],
+                                    Gudhi::Persistence_representations::epsi);
   }
 }
 
 BOOST_AUTO_TEST_CASE(check_compute_persistent_betti_numbers) {
   Persistence_intervals p("data/file_with_diagram");
-  std::vector<std::pair<double, double> > pbns;
-  pbns.push_back(std::pair<double, double>(0.0290362, 1));
-  pbns.push_back(std::pair<double, double>(0.0307676, 2));
-  pbns.push_back(std::pair<double, double>(0.0366312, 3));
-  pbns.push_back(std::pair<double, double>(0.0544614, 4));
-  pbns.push_back(std::pair<double, double>(0.0920033, 5));
-  pbns.push_back(std::pair<double, double>(0.104599, 6));
-  pbns.push_back(std::pair<double, double>(0.114718, 7));
-  pbns.push_back(std::pair<double, double>(0.117379, 8));
-  pbns.push_back(std::pair<double, double>(0.123493, 9));
-  pbns.push_back(std::pair<double, double>(0.133638, 10));
-  pbns.push_back(std::pair<double, double>(0.137798, 9));
-  pbns.push_back(std::pair<double, double>(0.149798, 10));
-  pbns.push_back(std::pair<double, double>(0.155421, 11));
-  pbns.push_back(std::pair<double, double>(0.158443, 12));
-  pbns.push_back(std::pair<double, double>(0.176956, 13));
-  pbns.push_back(std::pair<double, double>(0.183234, 12));
-  pbns.push_back(std::pair<double, double>(0.191069, 13));
-  pbns.push_back(std::pair<double, double>(0.191333, 14));
-  pbns.push_back(std::pair<double, double>(0.191836, 15));
-  pbns.push_back(std::pair<double, double>(0.192675, 16));
-  pbns.push_back(std::pair<double, double>(0.208564, 17));
-  pbns.push_back(std::pair<double, double>(0.218425, 18));
-  pbns.push_back(std::pair<double, double>(0.219902, 17));
-  pbns.push_back(std::pair<double, double>(0.23233, 16));
-  pbns.push_back(std::pair<double, double>(0.234558, 17));
-  pbns.push_back(std::pair<double, double>(0.237166, 16));
-  pbns.push_back(std::pair<double, double>(0.247352, 17));
-  pbns.push_back(std::pair<double, double>(0.267421, 18));
-  pbns.push_back(std::pair<double, double>(0.268093, 19));
-  pbns.push_back(std::pair<double, double>(0.278734, 18));
-  pbns.push_back(std::pair<double, double>(0.284722, 19));
-  pbns.push_back(std::pair<double, double>(0.284998, 20));
-  pbns.push_back(std::pair<double, double>(0.294069, 21));
-  pbns.push_back(std::pair<double, double>(0.306293, 22));
-  pbns.push_back(std::pair<double, double>(0.322361, 21));
-  pbns.push_back(std::pair<double, double>(0.323152, 22));
-  pbns.push_back(std::pair<double, double>(0.371021, 23));
-  pbns.push_back(std::pair<double, double>(0.372395, 24));
-  pbns.push_back(std::pair<double, double>(0.387744, 25));
-  pbns.push_back(std::pair<double, double>(0.435537, 26));
-  pbns.push_back(std::pair<double, double>(0.462911, 25));
-  pbns.push_back(std::pair<double, double>(0.483569, 26));
-  pbns.push_back(std::pair<double, double>(0.489209, 25));
-  pbns.push_back(std::pair<double, double>(0.517115, 24));
-  pbns.push_back(std::pair<double, double>(0.522197, 23));
-  pbns.push_back(std::pair<double, double>(0.532665, 22));
-  pbns.push_back(std::pair<double, double>(0.545262, 23));
-  pbns.push_back(std::pair<double, double>(0.587227, 22));
-  pbns.push_back(std::pair<double, double>(0.593036, 23));
-  pbns.push_back(std::pair<double, double>(0.602647, 24));
-  pbns.push_back(std::pair<double, double>(0.605044, 25));
-  pbns.push_back(std::pair<double, double>(0.621962, 24));
-  pbns.push_back(std::pair<double, double>(0.629449, 23));
-  pbns.push_back(std::pair<double, double>(0.636719, 22));
-  pbns.push_back(std::pair<double, double>(0.64957, 21));
-  pbns.push_back(std::pair<double, double>(0.650781, 22));
-  pbns.push_back(std::pair<double, double>(0.654951, 23));
-  pbns.push_back(std::pair<double, double>(0.683489, 24));
-  pbns.push_back(std::pair<double, double>(0.687172, 23));
-  pbns.push_back(std::pair<double, double>(0.69703, 22));
-  pbns.push_back(std::pair<double, double>(0.701174, 21));
-  pbns.push_back(std::pair<double, double>(0.717623, 22));
-  pbns.push_back(std::pair<double, double>(0.722023, 21));
-  pbns.push_back(std::pair<double, double>(0.722298, 20));
-  pbns.push_back(std::pair<double, double>(0.725347, 19));
-  pbns.push_back(std::pair<double, double>(0.73071, 18));
-  pbns.push_back(std::pair<double, double>(0.758355, 17));
-  pbns.push_back(std::pair<double, double>(0.770913, 18));
-  pbns.push_back(std::pair<double, double>(0.790833, 17));
-  pbns.push_back(std::pair<double, double>(0.821211, 16));
-  pbns.push_back(std::pair<double, double>(0.849305, 17));
-  pbns.push_back(std::pair<double, double>(0.853669, 16));
-  pbns.push_back(std::pair<double, double>(0.866659, 15));
-  pbns.push_back(std::pair<double, double>(0.872896, 16));
-  pbns.push_back(std::pair<double, double>(0.889597, 15));
-  pbns.push_back(std::pair<double, double>(0.900231, 14));
-  pbns.push_back(std::pair<double, double>(0.903847, 13));
-  pbns.push_back(std::pair<double, double>(0.906299, 12));
-  pbns.push_back(std::pair<double, double>(0.910852, 11));
-  pbns.push_back(std::pair<double, double>(0.93453, 10));
-  pbns.push_back(std::pair<double, double>(0.944757, 9));
-  pbns.push_back(std::pair<double, double>(0.947812, 8));
-  pbns.push_back(std::pair<double, double>(0.959154, 7));
-  pbns.push_back(std::pair<double, double>(0.975654, 6));
-  pbns.push_back(std::pair<double, double>(0.976719, 5));
-  pbns.push_back(std::pair<double, double>(0.977343, 4));
-  pbns.push_back(std::pair<double, double>(0.980129, 3));
-  pbns.push_back(std::pair<double, double>(0.987842, 2));
-  pbns.push_back(std::pair<double, double>(0.990127, 1));
-  pbns.push_back(std::pair<double, double>(0.994537, 0));
+  std::vector<std::pair<double, size_t> > pbns;
+  pbns.push_back(std::pair<double, size_t>(0.0290362, 1));
+  pbns.push_back(std::pair<double, size_t>(0.0307676, 2));
+  pbns.push_back(std::pair<double, size_t>(0.0366312, 3));
+  pbns.push_back(std::pair<double, size_t>(0.0544614, 4));
+  pbns.push_back(std::pair<double, size_t>(0.0920033, 5));
+  pbns.push_back(std::pair<double, size_t>(0.104599, 6));
+  pbns.push_back(std::pair<double, size_t>(0.114718, 7));
+  pbns.push_back(std::pair<double, size_t>(0.117379, 8));
+  pbns.push_back(std::pair<double, size_t>(0.123493, 9));
+  pbns.push_back(std::pair<double, size_t>(0.133638, 10));
+  pbns.push_back(std::pair<double, size_t>(0.137798, 9));
+  pbns.push_back(std::pair<double, size_t>(0.149798, 10));
+  pbns.push_back(std::pair<double, size_t>(0.155421, 11));
+  pbns.push_back(std::pair<double, size_t>(0.158443, 12));
+  pbns.push_back(std::pair<double, size_t>(0.176956, 13));
+  pbns.push_back(std::pair<double, size_t>(0.183234, 12));
+  pbns.push_back(std::pair<double, size_t>(0.191069, 13));
+  pbns.push_back(std::pair<double, size_t>(0.191333, 14));
+  pbns.push_back(std::pair<double, size_t>(0.191836, 15));
+  pbns.push_back(std::pair<double, size_t>(0.192675, 16));
+  pbns.push_back(std::pair<double, size_t>(0.208564, 17));
+  pbns.push_back(std::pair<double, size_t>(0.218425, 18));
+  pbns.push_back(std::pair<double, size_t>(0.219902, 17));
+  pbns.push_back(std::pair<double, size_t>(0.23233, 16));
+  pbns.push_back(std::pair<double, size_t>(0.234558, 17));
+  pbns.push_back(std::pair<double, size_t>(0.237166, 16));
+  pbns.push_back(std::pair<double, size_t>(0.247352, 17));
+  pbns.push_back(std::pair<double, size_t>(0.267421, 18));
+  pbns.push_back(std::pair<double, size_t>(0.268093, 19));
+  pbns.push_back(std::pair<double, size_t>(0.278734, 18));
+  pbns.push_back(std::pair<double, size_t>(0.284722, 19));
+  pbns.push_back(std::pair<double, size_t>(0.284998, 20));
+  pbns.push_back(std::pair<double, size_t>(0.294069, 21));
+  pbns.push_back(std::pair<double, size_t>(0.306293, 22));
+  pbns.push_back(std::pair<double, size_t>(0.322361, 21));
+  pbns.push_back(std::pair<double, size_t>(0.323152, 22));
+  pbns.push_back(std::pair<double, size_t>(0.371021, 23));
+  pbns.push_back(std::pair<double, size_t>(0.372395, 24));
+  pbns.push_back(std::pair<double, size_t>(0.387744, 25));
+  pbns.push_back(std::pair<double, size_t>(0.435537, 26));
+  pbns.push_back(std::pair<double, size_t>(0.462911, 25));
+  pbns.push_back(std::pair<double, size_t>(0.483569, 26));
+  pbns.push_back(std::pair<double, size_t>(0.489209, 25));
+  pbns.push_back(std::pair<double, size_t>(0.517115, 24));
+  pbns.push_back(std::pair<double, size_t>(0.522197, 23));
+  pbns.push_back(std::pair<double, size_t>(0.532665, 22));
+  pbns.push_back(std::pair<double, size_t>(0.545262, 23));
+  pbns.push_back(std::pair<double, size_t>(0.587227, 22));
+  pbns.push_back(std::pair<double, size_t>(0.593036, 23));
+  pbns.push_back(std::pair<double, size_t>(0.602647, 24));
+  pbns.push_back(std::pair<double, size_t>(0.605044, 25));
+  pbns.push_back(std::pair<double, size_t>(0.621962, 24));
+  pbns.push_back(std::pair<double, size_t>(0.629449, 23));
+  pbns.push_back(std::pair<double, size_t>(0.636719, 22));
+  pbns.push_back(std::pair<double, size_t>(0.64957, 21));
+  pbns.push_back(std::pair<double, size_t>(0.650781, 22));
+  pbns.push_back(std::pair<double, size_t>(0.654951, 23));
+  pbns.push_back(std::pair<double, size_t>(0.683489, 24));
+  pbns.push_back(std::pair<double, size_t>(0.687172, 23));
+  pbns.push_back(std::pair<double, size_t>(0.69703, 22));
+  pbns.push_back(std::pair<double, size_t>(0.701174, 21));
+  pbns.push_back(std::pair<double, size_t>(0.717623, 22));
+  pbns.push_back(std::pair<double, size_t>(0.722023, 21));
+  pbns.push_back(std::pair<double, size_t>(0.722298, 20));
+  pbns.push_back(std::pair<double, size_t>(0.725347, 19));
+  pbns.push_back(std::pair<double, size_t>(0.73071, 18));
+  pbns.push_back(std::pair<double, size_t>(0.758355, 17));
+  pbns.push_back(std::pair<double, size_t>(0.770913, 18));
+  pbns.push_back(std::pair<double, size_t>(0.790833, 17));
+  pbns.push_back(std::pair<double, size_t>(0.821211, 16));
+  pbns.push_back(std::pair<double, size_t>(0.849305, 17));
+  pbns.push_back(std::pair<double, size_t>(0.853669, 16));
+  pbns.push_back(std::pair<double, size_t>(0.866659, 15));
+  pbns.push_back(std::pair<double, size_t>(0.872896, 16));
+  pbns.push_back(std::pair<double, size_t>(0.889597, 15));
+  pbns.push_back(std::pair<double, size_t>(0.900231, 14));
+  pbns.push_back(std::pair<double, size_t>(0.903847, 13));
+  pbns.push_back(std::pair<double, size_t>(0.906299, 12));
+  pbns.push_back(std::pair<double, size_t>(0.910852, 11));
+  pbns.push_back(std::pair<double, size_t>(0.93453, 10));
+  pbns.push_back(std::pair<double, size_t>(0.944757, 9));
+  pbns.push_back(std::pair<double, size_t>(0.947812, 8));
+  pbns.push_back(std::pair<double, size_t>(0.959154, 7));
+  pbns.push_back(std::pair<double, size_t>(0.975654, 6));
+  pbns.push_back(std::pair<double, size_t>(0.976719, 5));
+  pbns.push_back(std::pair<double, size_t>(0.977343, 4));
+  pbns.push_back(std::pair<double, size_t>(0.980129, 3));
+  pbns.push_back(std::pair<double, size_t>(0.987842, 2));
+  pbns.push_back(std::pair<double, size_t>(0.990127, 1));
+  pbns.push_back(std::pair<double, size_t>(0.994537, 0));
 
   std::vector<std::pair<double, size_t> > pbns_new = p.compute_persistent_betti_numbers();
   for (size_t i = 0; i != pbns.size(); ++i) {
-    // cout << pbns_new[i].first << "," << pbns_new[i].second << std::endl;
-    BOOST_CHECK(fabs(pbns[i].first - pbns_new[i].first) <= epsilon);
-    BOOST_CHECK(fabs(pbns[i].second - pbns_new[i].second) <= epsilon);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(pbns[i].first, pbns_new[i].first,
+                                    Gudhi::Persistence_representations::epsi);
+    BOOST_CHECK(pbns[i].second == pbns_new[i].second);
   }
 }
 
@@ -297,7 +288,7 @@ BOOST_AUTO_TEST_CASE(check_k_n_n) {
   knn_template.push_back(0.786945);
 
   for (size_t i = 0; i != knn.size(); ++i) {
-    // cout << knn[i] << std::endl;
-    BOOST_CHECK(fabs(knn[i] - knn_template[i]) <= 0.000005);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(knn[i], knn_template[i],
+                                    Gudhi::Persistence_representations::epsi);
   }
 }
diff --git a/src/Persistence_representations/test/persistence_intervals_with_distances_test.cpp b/src/Persistence_representations/test/persistence_intervals_with_distances_test.cpp
index 7b70eee3..631e4d70 100644
--- a/src/Persistence_representations/test/persistence_intervals_with_distances_test.cpp
+++ b/src/Persistence_representations/test/persistence_intervals_with_distances_test.cpp
@@ -24,8 +24,9 @@
 #define BOOST_TEST_MODULE "Persistence_intervals_with_distances_test"
 #include <boost/test/unit_test.hpp>
 #include <gudhi/reader_utils.h>
-#include "gudhi/Persistence_intervals_with_distances.h"
-#include "gudhi/common_persistence_representations.h"
+#include <gudhi/Persistence_intervals_with_distances.h>
+#include <gudhi/common_persistence_representations.h>
+#include <gudhi/Unitary_tests_utils.h>
 
 #include <iostream>
 
@@ -38,9 +39,7 @@ BOOST_AUTO_TEST_CASE(check_bottleneck_distances_computation) {
 
   double dist = p.distance(q);
 
-  // std::cout << "dist : " << dist << std::endl;
-
-  BOOST_CHECK(almost_equal(dist, 0.389043));
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(dist, 0.389043, Gudhi::Persistence_representations::epsi);
 }
 
 BOOST_AUTO_TEST_CASE(check_default_parameters_in_distance) {
@@ -51,11 +50,7 @@ BOOST_AUTO_TEST_CASE(check_default_parameters_in_distance) {
   double max_parameter_distance = p.distance(q, std::numeric_limits<double>::max());
   double inf_parameter_distance = p.distance(q, std::numeric_limits<double>::infinity());
 
-  // std::cout << "default_parameter_distance : " << default_parameter_distance << std::endl;
-  // std::cout << "max_parameter_distance : " << max_parameter_distance << std::endl;
-  // std::cout << "inf_parameter_distance : " << inf_parameter_distance << std::endl;
-
-  BOOST_CHECK(default_parameter_distance == max_parameter_distance);
-  BOOST_CHECK(inf_parameter_distance == max_parameter_distance);
-  BOOST_CHECK(inf_parameter_distance == max_parameter_distance);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(default_parameter_distance, max_parameter_distance);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(inf_parameter_distance, max_parameter_distance);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(inf_parameter_distance, max_parameter_distance);
 }
diff --git a/src/Persistence_representations/test/persistence_lanscapes_on_grid_test.cpp b/src/Persistence_representations/test/persistence_lanscapes_on_grid_test.cpp
index 6b1608fe..8e2808d0 100644
--- a/src/Persistence_representations/test/persistence_lanscapes_on_grid_test.cpp
+++ b/src/Persistence_representations/test/persistence_lanscapes_on_grid_test.cpp
@@ -25,12 +25,15 @@
 #include <boost/test/unit_test.hpp>
 #include <gudhi/reader_utils.h>
 #include <gudhi/Persistence_landscape_on_grid.h>
+#include <gudhi/Unitary_tests_utils.h>
 
 #include <iostream>
 
 using namespace Gudhi;
 using namespace Gudhi::Persistence_representations;
 
+double epsilon = 0.0005;
+
 BOOST_AUTO_TEST_CASE(check_construction_of_landscape) {
   Persistence_landscape_on_grid l("data/file_with_diagram_1", 100, std::numeric_limits<unsigned short>::max());
   l.print_to_file("landscape_from_file_with_diagram_1");
@@ -53,16 +56,14 @@ BOOST_AUTO_TEST_CASE(check_construction_of_landscape_using_only_ten_levels) {
     std::vector<double> v2 = g.vectorize(level);
     BOOST_CHECK(v1.size() == v2.size());
     for (size_t i = 0; i != v1.size(); ++i) {
-      BOOST_CHECK(v1[i] == v2[i]);
+      GUDHI_TEST_FLOAT_EQUALITY_CHECK(v1[i], v2[i]);
     }
   }
 }
 
 BOOST_AUTO_TEST_CASE(check_computations_of_integrals) {
   Persistence_landscape_on_grid p("data/file_with_diagram_1", 100, std::numeric_limits<unsigned short>::max());
-  double integral = p.compute_integral_of_landscape();
-  // cerr << "integral : " << integral << endl;getchar();
-  BOOST_CHECK(fabs(integral - 27.343) <= 0.00005);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_integral_of_landscape(), 27.343, epsilon);
 }
 
 BOOST_AUTO_TEST_CASE(check_computations_of_integrals_for_each_level_separatelly) {
@@ -92,9 +93,8 @@ BOOST_AUTO_TEST_CASE(check_computations_of_integrals_for_each_level_separatelly)
   integrals_fir_different_levels.push_back(0.202633);
 
   for (size_t level = 0; level != integrals_fir_different_levels.size(); ++level) {
-    double integral = p.compute_integral_of_landscape(level);
-    // cerr << integral << endl;
-    BOOST_CHECK(fabs(integral - integrals_fir_different_levels[level]) <= 0.00005);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_integral_of_landscape(level), integrals_fir_different_levels[level],
+                                    epsilon);
   }
 }
 
@@ -109,9 +109,8 @@ BOOST_AUTO_TEST_CASE(check_computations_of_integrals_of_powers_of_landscape) {
   integrals_fir_different_powers.push_back(0.23011);
 
   for (size_t power = 0; power != 5; ++power) {
-    double integral = p.compute_integral_of_landscape(power);
-    // cerr << integral << endl;
-    BOOST_CHECK(fabs(integral - integrals_fir_different_powers[power]) <= 0.00001);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_integral_of_landscape(power), integrals_fir_different_powers[power],
+                                    epsilon);
   }
 }
 
@@ -145,8 +144,8 @@ BOOST_AUTO_TEST_CASE(check_computations_of_values_on_different_points) {
   double x = 0.0012321;
   double dx = 0.05212;
   for (size_t i = 0; i != 10; ++i) {
-    BOOST_CHECK(almost_equal(p.compute_value_at_a_given_point(0, x), results_level_0[i]));
-    BOOST_CHECK(almost_equal(p.compute_value_at_a_given_point(10, x), results_level_10[i]));
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_value_at_a_given_point(0, x), results_level_0[i], epsilon);
+    GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_value_at_a_given_point(10, x), results_level_10[i], epsilon);
     x += dx;
   }
 }
@@ -179,22 +178,14 @@ BOOST_AUTO_TEST_CASE(check_computations_of_maxima_and_norms) {
   Persistence_landscape_on_grid second("data/file_with_diagram_2", 0., 1., 100);
   Persistence_landscape_on_grid sum = p + second;
 
-  // cerr << p.compute_maximum() << endl;
-  // cerr <<  p.compute_norm_of_landscape(1) << endl;
-  // cerr << p.compute_norm_of_landscape(2) << endl;
-  // cerr <<  p.compute_norm_of_landscape(3) << endl;
-  // cerr <<  compute_distance_of_landscapes_on_grid(p,sum,1) << endl;
-  // cerr <<  compute_distance_of_landscapes_on_grid(p,sum,2) << endl;
-  // cerr <<  compute_distance_of_landscapes_on_grid(p,sum,std::numeric_limits<double>::max())  << endl;
-
-  BOOST_CHECK(fabs(p.compute_maximum() - 0.46) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_norm_of_landscape(1) - 27.3373) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_norm_of_landscape(2) - 1.84143) <= 0.00001);
-  BOOST_CHECK(fabs(p.compute_norm_of_landscape(3) - 0.927067) <= 0.00001);
-  BOOST_CHECK(fabs(compute_distance_of_landscapes_on_grid(p, sum, 1) - 16.8519) <= 0.00005);
-  BOOST_CHECK(fabs(compute_distance_of_landscapes_on_grid(p, sum, 2) - 1.44542) <= 0.00001);
-  BOOST_CHECK(fabs(compute_distance_of_landscapes_on_grid(p, sum, std::numeric_limits<double>::max()) - 0.45) <=
-              0.00001);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_maximum(), 0.46, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_norm_of_landscape(1), 27.3373 , epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_norm_of_landscape(2), 1.84143 , epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_norm_of_landscape(3), 0.927067, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(compute_distance_of_landscapes_on_grid(p, sum, 1), 16.8519, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(compute_distance_of_landscapes_on_grid(p, sum, 2), 1.44542, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(compute_distance_of_landscapes_on_grid(p, sum, std::numeric_limits<double>::max()),
+                                  0.45, epsilon);
 }
 
 BOOST_AUTO_TEST_CASE(check_default_parameters_of_distances) {
@@ -209,7 +200,7 @@ BOOST_AUTO_TEST_CASE(check_default_parameters_of_distances) {
   double dist_numeric_limit_max = p.distance(q, std::numeric_limits<double>::max());
   double dist_infinity = p.distance(q, std::numeric_limits<double>::infinity());
 
-  BOOST_CHECK(dist_numeric_limit_max == dist_infinity);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(dist_numeric_limit_max, dist_infinity);
 }
 
 BOOST_AUTO_TEST_CASE(check_computations_of_averages) {
@@ -226,16 +217,15 @@ BOOST_AUTO_TEST_CASE(check_computations_of_averages) {
 BOOST_AUTO_TEST_CASE(check_computations_of_distances) {
   Persistence_landscape_on_grid p("data/file_with_diagram", 0., 1., 10000);
   Persistence_landscape_on_grid q("data/file_with_diagram_1", 0., 1., 10000);
-  BOOST_CHECK(fabs(p.distance(q) - 25.5779) <= 0.00005);
-  BOOST_CHECK(fabs(p.distance(q, 2) - 2.04891) <= 0.00001);
-  BOOST_CHECK(fabs(p.distance(q, std::numeric_limits<double>::max()) - 0.359) <= 0.00001);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.distance(q), 25.5779, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.distance(q, 2), 2.04891, epsilon);
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.distance(q, std::numeric_limits<double>::max()), 0.359, epsilon);
 }
 
 BOOST_AUTO_TEST_CASE(check_computations_of_scalar_product) {
   Persistence_landscape_on_grid p("data/file_with_diagram", 0., 1., 10000);
   Persistence_landscape_on_grid q("data/file_with_diagram_1", 0., 1., 10000);
-  // std::cerr << p.compute_scalar_product( q ) << std::endl;
-  BOOST_CHECK(almost_equal(p.compute_scalar_product(q), 0.754367));
+  GUDHI_TEST_FLOAT_EQUALITY_CHECK(p.compute_scalar_product(q), 0.754367, epsilon);
 }
 
 // Below I am storing the code used to generate tests for that functionality.
diff --git a/src/Persistence_representations/test/read_persistence_from_file_test.cpp b/src/Persistence_representations/test/read_persistence_from_file_test.cpp
index 76d7cdb0..afdc822c 100644
--- a/src/Persistence_representations/test/read_persistence_from_file_test.cpp
+++ b/src/Persistence_representations/test/read_persistence_from_file_test.cpp
@@ -21,7 +21,7 @@
  */
 
 #define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE "Persistence_representations"
+#define BOOST_TEST_MODULE "read_persistence_from_file_test"
 #include <boost/test/unit_test.hpp>
 #include <gudhi/read_persistence_from_file.h>
 
diff --git a/src/Persistence_representations/test/vector_representation_test.cpp b/src/Persistence_representations/test/vector_representation_test.cpp
index 3f3e2abe..7e4ce3ee 100644
--- a/src/Persistence_representations/test/vector_representation_test.cpp
+++ b/src/Persistence_representations/test/vector_representation_test.cpp
@@ -26,7 +26,7 @@
 #include <iostream>
 
 #define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE "Persistence_representations"
+#define BOOST_TEST_MODULE "vector_representation_test"
 #include <boost/test/unit_test.hpp>
 #include <gudhi/reader_utils.h>
 #include <vector>