]> git.proxmox.com Git - ceph.git/blobdiff - ceph/src/boost/libs/polygon/test/polygon_interval_test.cpp
projects / ceph.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
import new upstream nautilus stable release 14.2.8
[ceph.git] / ceph / src / boost / libs / polygon / test / polygon_interval_test.cpp
diff --git a/ceph/src/boost/libs/polygon/test/polygon_interval_test.cpp b/ceph/src/boost/libs/polygon/test/polygon_interval_test.cpp
index 55fc3cf9d2c35636e714b87eb093ae664197e6dc..070d34f76d0343cbd2c55bd71676a21575bc248d 100644 (file)
--- a/ceph/src/boost/libs/polygon/test/polygon_interval_test.cpp
+++ b/ceph/src/boost/libs/polygon/test/polygon_interval_test.cpp
@@ -7,57 +7,55 @@
 
 // See http://www.boost.org for updates, documentation, and revision history.
 
-#define BOOST_TEST_MODULE POLYGON_INTERVAL_TEST
-#include <boost/mpl/list.hpp>
-#include <boost/test/test_case_template.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/polygon/interval_concept.hpp>
+#include <boost/polygon/interval_data.hpp>
+#include <boost/polygon/interval_traits.hpp>
 
-#include "boost/polygon/interval_concept.hpp"
-#include "boost/polygon/interval_data.hpp"
-#include "boost/polygon/interval_traits.hpp"
 using namespace boost::polygon;
 
-typedef boost::mpl::list<int> test_types;
-
-BOOST_AUTO_TEST_CASE_TEMPLATE(interval_data_test, T, test_types) {
-  typedef interval_data<T> interval_type;
+void interval_data_test()
+{
+  typedef interval_data<int> interval_type;
   interval_type interval1(1, 2);
   interval_type interval2;
   interval2 = interval1;
 
-  BOOST_CHECK_EQUAL(interval1.low(), 1);
-  BOOST_CHECK_EQUAL(interval1.high(), 2);
-  BOOST_CHECK_EQUAL(interval1.get(LOW), 1);
-  BOOST_CHECK_EQUAL(interval1.get(HIGH), 2);
-  BOOST_CHECK(interval1 == interval2);
-  BOOST_CHECK(!(interval1 != interval2));
-  BOOST_CHECK(!(interval1 < interval2));
-  BOOST_CHECK(!(interval1 > interval2));
-  BOOST_CHECK(interval1 <= interval2);
-  BOOST_CHECK(interval1 >= interval2);
+  BOOST_TEST_EQ(interval1.low(), 1);
+  BOOST_TEST_EQ(interval1.high(), 2);
+  BOOST_TEST_EQ(interval1.get(LOW), 1);
+  BOOST_TEST_EQ(interval1.get(HIGH), 2);
+  BOOST_TEST(interval1 == interval2);
+  BOOST_TEST(!(interval1 != interval2));
+  BOOST_TEST(!(interval1 < interval2));
+  BOOST_TEST(!(interval1 > interval2));
+  BOOST_TEST(interval1 <= interval2);
+  BOOST_TEST(interval1 >= interval2);
 
   interval1.low(2);
   interval1.high(1);
-  BOOST_CHECK_EQUAL(interval1.low(), 2);
-  BOOST_CHECK_EQUAL(interval1.high(), 1);
-  BOOST_CHECK(!(interval1 == interval2));
-  BOOST_CHECK(interval1 != interval2);
+  BOOST_TEST_EQ(interval1.low(), 2);
+  BOOST_TEST_EQ(interval1.high(), 1);
+  BOOST_TEST(!(interval1 == interval2));
+  BOOST_TEST(interval1 != interval2);
 
   interval2.set(LOW, 2);
   interval2.set(HIGH, 1);
-  BOOST_CHECK(interval1 == interval2);
+  BOOST_TEST(interval1 == interval2);
 }
 
-BOOST_AUTO_TEST_CASE_TEMPLATE(interval_traits_test, T, test_types) {
-  typedef interval_data<T> interval_type;
+void interval_traits_test()
+{
+  typedef interval_data<int> interval_type;
 
   interval_type interval = interval_mutable_traits<interval_type>::construct(1, 2);
-  BOOST_CHECK_EQUAL(interval_traits<interval_type>::get(interval, LOW), 1);
-  BOOST_CHECK_EQUAL(interval_traits<interval_type>::get(interval, HIGH), 2);
+  BOOST_TEST_EQ(interval_traits<interval_type>::get(interval, LOW), 1);
+  BOOST_TEST_EQ(interval_traits<interval_type>::get(interval, HIGH), 2);
 
   interval_mutable_traits<interval_type>::set(interval, LOW, 3);
   interval_mutable_traits<interval_type>::set(interval, HIGH, 4);
-  BOOST_CHECK_EQUAL(interval_traits<interval_type>::get(interval, LOW), 3);
-  BOOST_CHECK_EQUAL(interval_traits<interval_type>::get(interval, HIGH), 4);
+  BOOST_TEST_EQ(interval_traits<interval_type>::get(interval, LOW), 3);
+  BOOST_TEST_EQ(interval_traits<interval_type>::get(interval, HIGH), 4);
 }
 
 template <typename T>
@@ -100,159 +98,174 @@ namespace polygon {
 }  // polygon
 }  // boost
 
-BOOST_AUTO_TEST_CASE_TEMPLATE(interval_concept_test1, T, test_types) {
-  typedef Interval<T> interval_type;
+void interval_concept_test1()
+{
+  typedef Interval<int> interval_type;
 
   interval_type interval1 = construct<interval_type>(2, 1);
-  BOOST_CHECK_EQUAL(interval1.left, 1);
-  BOOST_CHECK_EQUAL(interval1.right, 2);
+  BOOST_TEST_EQ(interval1.left, 1);
+  BOOST_TEST_EQ(interval1.right, 2);
 
   set(interval1, LOW, 3);
   set(interval1, HIGH, 4);
-  BOOST_CHECK_EQUAL(get(interval1, LOW), 3);
-  BOOST_CHECK_EQUAL(get(interval1, HIGH), 4);
+  BOOST_TEST_EQ(get(interval1, LOW), 3);
+  BOOST_TEST_EQ(get(interval1, HIGH), 4);
 
   interval_type interval2 = copy_construct<interval_type>(interval1);
-  BOOST_CHECK(equivalence(interval1, interval2));
+  BOOST_TEST(equivalence(interval1, interval2));
 
   low(interval2, 1);
   high(interval2, 2);
-  BOOST_CHECK_EQUAL(low(interval2), 1);
-  BOOST_CHECK_EQUAL(high(interval2), 2);
+  BOOST_TEST_EQ(low(interval2), 1);
+  BOOST_TEST_EQ(high(interval2), 2);
 
   assign(interval1, interval2);
-  BOOST_CHECK(equivalence(interval1, interval2));
+  BOOST_TEST(equivalence(interval1, interval2));
 }
 
-BOOST_AUTO_TEST_CASE_TEMPLATE(interval_concept_test2, T, test_types) {
-  typedef Interval<T> interval_type;
+void interval_concept_test2()
+{
+  typedef Interval<int> interval_type;
 
   interval_type interval1 = construct<interval_type>(1, 3);
-  BOOST_CHECK_EQUAL(center(interval1), 2);
-  BOOST_CHECK_EQUAL(delta(interval1), 2);
+  BOOST_TEST_EQ(center(interval1), 2);
+  BOOST_TEST_EQ(delta(interval1), 2);
 
   flip(interval1, -1);
-  BOOST_CHECK_EQUAL(low(interval1), -5);
-  BOOST_CHECK_EQUAL(high(interval1), -3);
+  BOOST_TEST_EQ(low(interval1), -5);
+  BOOST_TEST_EQ(high(interval1), -3);
 
   scale_up(interval1, 2);
-  BOOST_CHECK_EQUAL(low(interval1), -10);
-  BOOST_CHECK_EQUAL(high(interval1), -6);
+  BOOST_TEST_EQ(low(interval1), -10);
+  BOOST_TEST_EQ(high(interval1), -6);
 
   scale_down(interval1, 2);
-  BOOST_CHECK_EQUAL(low(interval1), -5);
-  BOOST_CHECK_EQUAL(high(interval1), -3);
+  BOOST_TEST_EQ(low(interval1), -5);
+  BOOST_TEST_EQ(high(interval1), -3);
 
   move(interval1, 5);
-  BOOST_CHECK_EQUAL(low(interval1), 0);
-  BOOST_CHECK_EQUAL(high(interval1), 2);
+  BOOST_TEST_EQ(low(interval1), 0);
+  BOOST_TEST_EQ(high(interval1), 2);
 
   convolve(interval1, 1);
-  BOOST_CHECK_EQUAL(low(interval1), 1);
-  BOOST_CHECK_EQUAL(high(interval1), 3);
+  BOOST_TEST_EQ(low(interval1), 1);
+  BOOST_TEST_EQ(high(interval1), 3);
 
   deconvolve(interval1, 2);
-  BOOST_CHECK_EQUAL(low(interval1), -1);
-  BOOST_CHECK_EQUAL(high(interval1), 1);
+  BOOST_TEST_EQ(low(interval1), -1);
+  BOOST_TEST_EQ(high(interval1), 1);
 
   interval_type interval2 = construct<interval_type>(-1, 2);
   convolve(interval1, interval2);
-  BOOST_CHECK_EQUAL(low(interval1), -2);
-  BOOST_CHECK_EQUAL(high(interval1), 3);
+  BOOST_TEST_EQ(low(interval1), -2);
+  BOOST_TEST_EQ(high(interval1), 3);
 
   deconvolve(interval1, interval2);
-  BOOST_CHECK_EQUAL(low(interval1), -1);
-  BOOST_CHECK_EQUAL(high(interval1), 1);
+  BOOST_TEST_EQ(low(interval1), -1);
+  BOOST_TEST_EQ(high(interval1), 1);
 
   reflected_convolve(interval1, interval2);
-  BOOST_CHECK_EQUAL(low(interval1), -3);
-  BOOST_CHECK_EQUAL(high(interval1), 2);
+  BOOST_TEST_EQ(low(interval1), -3);
+  BOOST_TEST_EQ(high(interval1), 2);
 
   reflected_deconvolve(interval1, interval2);
-  BOOST_CHECK_EQUAL(low(interval1), -1);
-  BOOST_CHECK_EQUAL(high(interval1), 1);
+  BOOST_TEST_EQ(low(interval1), -1);
+  BOOST_TEST_EQ(high(interval1), 1);
 }
 
-BOOST_AUTO_TEST_CASE_TEMPLATE(interval_concept_test3, T, test_types) {
-  typedef Interval<T> interval_type;
+void interval_concept_test3()
+{
+  typedef Interval<int> interval_type;
 
   interval_type interval1 = construct<interval_type>(1, 3);
-  BOOST_CHECK_EQUAL(euclidean_distance(interval1, -2), 3);
-  BOOST_CHECK_EQUAL(euclidean_distance(interval1, 2), 0);
-  BOOST_CHECK_EQUAL(euclidean_distance(interval1, 4), 1);
+  BOOST_TEST_EQ(euclidean_distance(interval1, -2), 3);
+  BOOST_TEST_EQ(euclidean_distance(interval1, 2), 0);
+  BOOST_TEST_EQ(euclidean_distance(interval1, 4), 1);
 
   interval_type interval2 = construct<interval_type>(-1, 0);
-  BOOST_CHECK_EQUAL(euclidean_distance(interval1, interval2), 1);
-  BOOST_CHECK(!intersects(interval1, interval2));
-  BOOST_CHECK(!boundaries_intersect(interval1, interval2));
-  BOOST_CHECK(!intersect(interval2, interval1));
-  BOOST_CHECK_EQUAL(low(interval2), -1);
-  BOOST_CHECK_EQUAL(high(interval2), 0);
+  BOOST_TEST_EQ(euclidean_distance(interval1, interval2), 1);
+  BOOST_TEST(!intersects(interval1, interval2));
+  BOOST_TEST(!boundaries_intersect(interval1, interval2));
+  BOOST_TEST(!intersect(interval2, interval1));
+  BOOST_TEST_EQ(low(interval2), -1);
+  BOOST_TEST_EQ(high(interval2), 0);
 
   interval_type interval3 = construct<interval_type>(-1, 6);
-  BOOST_CHECK_EQUAL(euclidean_distance(interval1, interval3), 0);
-  BOOST_CHECK(intersects(interval1, interval3));
-  BOOST_CHECK(!boundaries_intersect(interval1, interval3));
-  BOOST_CHECK(intersect(interval3, interval1));
-  BOOST_CHECK_EQUAL(low(interval3), 1);
-  BOOST_CHECK_EQUAL(high(interval3), 3);
+  BOOST_TEST_EQ(euclidean_distance(interval1, interval3), 0);
+  BOOST_TEST(intersects(interval1, interval3));
+  BOOST_TEST(!boundaries_intersect(interval1, interval3));
+  BOOST_TEST(intersect(interval3, interval1));
+  BOOST_TEST_EQ(low(interval3), 1);
+  BOOST_TEST_EQ(high(interval3), 3);
 
   interval_type interval4 = construct<interval_type>(5, 6);
-  BOOST_CHECK_EQUAL(euclidean_distance(interval1, interval4), 2);
-  BOOST_CHECK(!intersects(interval1, interval4));
-  BOOST_CHECK(!boundaries_intersect(interval1, interval4));
-  BOOST_CHECK(!intersect(interval4, interval1));
-  BOOST_CHECK_EQUAL(low(interval4), 5);
-  BOOST_CHECK_EQUAL(high(interval4), 6);
+  BOOST_TEST_EQ(euclidean_distance(interval1, interval4), 2);
+  BOOST_TEST(!intersects(interval1, interval4));
+  BOOST_TEST(!boundaries_intersect(interval1, interval4));
+  BOOST_TEST(!intersect(interval4, interval1));
+  BOOST_TEST_EQ(low(interval4), 5);
+  BOOST_TEST_EQ(high(interval4), 6);
 
   interval_type interval5 = construct<interval_type>(3, 5);
-  BOOST_CHECK_EQUAL(euclidean_distance(interval1, interval5), 0);
-  BOOST_CHECK(!intersects(interval1, interval5, false));
-  BOOST_CHECK(boundaries_intersect(interval1, interval5));
-  BOOST_CHECK(intersect(interval5, interval1));
-  BOOST_CHECK_EQUAL(low(interval5), 3);
-  BOOST_CHECK_EQUAL(high(interval5), 3);
+  BOOST_TEST_EQ(euclidean_distance(interval1, interval5), 0);
+  BOOST_TEST(!intersects(interval1, interval5, false));
+  BOOST_TEST(boundaries_intersect(interval1, interval5));
+  BOOST_TEST(intersect(interval5, interval1));
+  BOOST_TEST_EQ(low(interval5), 3);
+  BOOST_TEST_EQ(high(interval5), 3);
 }
 
-BOOST_AUTO_TEST_CASE_TEMPLATE(interval_concept_test4, T, test_types) {
-  typedef Interval<T> interval_type;
+void interval_concept_test4()
+{
+  typedef Interval<int> interval_type;
 
   interval_type interval1 = construct<interval_type>(1, 3);
   interval_type interval2 = construct<interval_type>(3, 5);
-  BOOST_CHECK(!abuts(interval1, interval2, LOW));
-  BOOST_CHECK(abuts(interval1, interval2, HIGH));
-  BOOST_CHECK(abuts(interval1, interval2));
+  BOOST_TEST(!abuts(interval1, interval2, LOW));
+  BOOST_TEST(abuts(interval1, interval2, HIGH));
+  BOOST_TEST(abuts(interval1, interval2));
 
   bloat(interval1, 1);
-  BOOST_CHECK_EQUAL(low(interval1), 0);
-  BOOST_CHECK_EQUAL(high(interval1), 4);
-  BOOST_CHECK(!abuts(interval1, interval2));
+  BOOST_TEST_EQ(low(interval1), 0);
+  BOOST_TEST_EQ(high(interval1), 4);
+  BOOST_TEST(!abuts(interval1, interval2));
 
   bloat(interval1, LOW, 1);
-  BOOST_CHECK_EQUAL(low(interval1), -1);
-  BOOST_CHECK_EQUAL(high(interval1), 4);
+  BOOST_TEST_EQ(low(interval1), -1);
+  BOOST_TEST_EQ(high(interval1), 4);
 
   shrink(interval1, LOW, 1);
-  BOOST_CHECK_EQUAL(low(interval1), 0);
-  BOOST_CHECK_EQUAL(high(interval1), 4);
+  BOOST_TEST_EQ(low(interval1), 0);
+  BOOST_TEST_EQ(high(interval1), 4);
 
   shrink(interval1, 1);
-  BOOST_CHECK_EQUAL(low(interval1), 1);
-  BOOST_CHECK_EQUAL(high(interval1), 3);
+  BOOST_TEST_EQ(low(interval1), 1);
+  BOOST_TEST_EQ(high(interval1), 3);
 
-  BOOST_CHECK(encompass(interval1, 4));
-  BOOST_CHECK_EQUAL(low(interval1), 1);
-  BOOST_CHECK_EQUAL(high(interval1), 4);
+  BOOST_TEST(encompass(interval1, 4));
+  BOOST_TEST_EQ(low(interval1), 1);
+  BOOST_TEST_EQ(high(interval1), 4);
 
-  BOOST_CHECK(encompass(interval1, interval2));
-  BOOST_CHECK_EQUAL(low(interval1), 1);
-  BOOST_CHECK_EQUAL(high(interval1), 5);
+  BOOST_TEST(encompass(interval1, interval2));
+  BOOST_TEST_EQ(low(interval1), 1);
+  BOOST_TEST_EQ(high(interval1), 5);
 
   interval1 = get_half(interval1, LOW);
-  BOOST_CHECK_EQUAL(low(interval1), 1);
-  BOOST_CHECK_EQUAL(high(interval1), 3);
+  BOOST_TEST_EQ(low(interval1), 1);
+  BOOST_TEST_EQ(high(interval1), 3);
+
+  BOOST_TEST(join_with(interval1, interval2));
+  BOOST_TEST_EQ(low(interval1), 1);
+  BOOST_TEST_EQ(high(interval1), 5);
+}
 
-  BOOST_CHECK(join_with(interval1, interval2));
-  BOOST_CHECK_EQUAL(low(interval1), 1);
-  BOOST_CHECK_EQUAL(high(interval1), 5);
+int main()
+{
+    interval_data_test();
+    interval_traits_test();
+    interval_concept_test1();
+    interval_concept_test2();
+    interval_concept_test3();
+    interval_concept_test4();
+    return boost::report_errors();
 }
Ceph