ceph/src/boost/libs/polygon/test/polygon_interval_test.cpp

   1 // Boost.Polygon library polygon_interval_test.cpp file
   2
   3 //          Copyright Andrii Sydorchuk 2012.
   4 // Distributed under the Boost Software License, Version 1.0.
   5 //    (See accompanying file LICENSE_1_0.txt or copy at
   6 //          http://www.boost.org/LICENSE_1_0.txt)
   7
   8 // See http://www.boost.org for updates, documentation, and revision history.
   9
  10 #include <boost/core/lightweight_test.hpp>
  11 #include <boost/polygon/interval_concept.hpp>
  12 #include <boost/polygon/interval_data.hpp>
  13 #include <boost/polygon/interval_traits.hpp>
  14
  15 using namespace boost::polygon;
  16
  17 void interval_data_test()
  18 {
  19   typedef interval_data<int> interval_type;
  20   interval_type interval1(1, 2);
  21   interval_type interval2;
  22   interval2 = interval1;
  23
  24   BOOST_TEST_EQ(interval1.low(), 1);
  25   BOOST_TEST_EQ(interval1.high(), 2);
  26   BOOST_TEST_EQ(interval1.get(LOW), 1);
  27   BOOST_TEST_EQ(interval1.get(HIGH), 2);
  28   BOOST_TEST(interval1 == interval2);
  29   BOOST_TEST(!(interval1 != interval2));
  30   BOOST_TEST(!(interval1 < interval2));
  31   BOOST_TEST(!(interval1 > interval2));
  32   BOOST_TEST(interval1 <= interval2);
  33   BOOST_TEST(interval1 >= interval2);
  34
  35   interval1.low(2);
  36   interval1.high(1);
  37   BOOST_TEST_EQ(interval1.low(), 2);
  38   BOOST_TEST_EQ(interval1.high(), 1);
  39   BOOST_TEST(!(interval1 == interval2));
  40   BOOST_TEST(interval1 != interval2);
  41
  42   interval2.set(LOW, 2);
  43   interval2.set(HIGH, 1);
  44   BOOST_TEST(interval1 == interval2);
  45 }
  46
  47 void interval_traits_test()
  48 {
  49   typedef interval_data<int> interval_type;
  50
  51   interval_type interval = interval_mutable_traits<interval_type>::construct(1, 2);
  52   BOOST_TEST_EQ(interval_traits<interval_type>::get(interval, LOW), 1);
  53   BOOST_TEST_EQ(interval_traits<interval_type>::get(interval, HIGH), 2);
  54
  55   interval_mutable_traits<interval_type>::set(interval, LOW, 3);
  56   interval_mutable_traits<interval_type>::set(interval, HIGH, 4);
  57   BOOST_TEST_EQ(interval_traits<interval_type>::get(interval, LOW), 3);
  58   BOOST_TEST_EQ(interval_traits<interval_type>::get(interval, HIGH), 4);
  59 }
  60
  61 template <typename T>
  62 struct Interval {
  63   T left;
  64   T right;
  65 };
  66
  67 namespace boost {
  68 namespace polygon {
  69   template <typename T>
  70   struct geometry_concept< Interval<T> > {
  71     typedef interval_concept type;
  72   };
  73
  74   template <typename T>
  75   struct interval_traits< Interval<T> > {
  76     typedef T coordinate_type;
  77
  78     static coordinate_type get(const Interval<T>& interval, direction_1d dir) {
  79       return (dir == LOW) ? interval.left : interval.right;
  80     }
  81   };
  82
  83   template <typename T>
  84   struct interval_mutable_traits< Interval<T> > {
  85     typedef T coordinate_type;
  86
  87     static void set(Interval<T>& interval, direction_1d dir, T value) {
  88       (dir == LOW) ? interval.left = value : interval.right = value;
  89     }
  90
  91     static Interval<T> construct(coordinate_type left, coordinate_type right) {
  92       Interval<T> interval;
  93       interval.left = left;
  94       interval.right = right;
  95       return interval;
  96     }
  97   };
  98 }  // polygon
  99 }  // boost
 100
 101 void interval_concept_test1()
 102 {
 103   typedef Interval<int> interval_type;
 104
 105   interval_type interval1 = construct<interval_type>(2, 1);
 106   BOOST_TEST_EQ(interval1.left, 1);
 107   BOOST_TEST_EQ(interval1.right, 2);
 108
 109   set(interval1, LOW, 3);
 110   set(interval1, HIGH, 4);
 111   BOOST_TEST_EQ(get(interval1, LOW), 3);
 112   BOOST_TEST_EQ(get(interval1, HIGH), 4);
 113
 114   interval_type interval2 = copy_construct<interval_type>(interval1);
 115   BOOST_TEST(equivalence(interval1, interval2));
 116
 117   low(interval2, 1);
 118   high(interval2, 2);
 119   BOOST_TEST_EQ(low(interval2), 1);
 120   BOOST_TEST_EQ(high(interval2), 2);
 121
 122   assign(interval1, interval2);
 123   BOOST_TEST(equivalence(interval1, interval2));
 124 }
 125
 126 void interval_concept_test2()
 127 {
 128   typedef Interval<int> interval_type;
 129
 130   interval_type interval1 = construct<interval_type>(1, 3);
 131   BOOST_TEST_EQ(center(interval1), 2);
 132   BOOST_TEST_EQ(delta(interval1), 2);
 133
 134   flip(interval1, -1);
 135   BOOST_TEST_EQ(low(interval1), -5);
 136   BOOST_TEST_EQ(high(interval1), -3);
 137
 138   scale_up(interval1, 2);
 139   BOOST_TEST_EQ(low(interval1), -10);
 140   BOOST_TEST_EQ(high(interval1), -6);
 141
 142   scale_down(interval1, 2);
 143   BOOST_TEST_EQ(low(interval1), -5);
 144   BOOST_TEST_EQ(high(interval1), -3);
 145
 146   move(interval1, 5);
 147   BOOST_TEST_EQ(low(interval1), 0);
 148   BOOST_TEST_EQ(high(interval1), 2);
 149
 150   convolve(interval1, 1);
 151   BOOST_TEST_EQ(low(interval1), 1);
 152   BOOST_TEST_EQ(high(interval1), 3);
 153
 154   deconvolve(interval1, 2);
 155   BOOST_TEST_EQ(low(interval1), -1);
 156   BOOST_TEST_EQ(high(interval1), 1);
 157
 158   interval_type interval2 = construct<interval_type>(-1, 2);
 159   convolve(interval1, interval2);
 160   BOOST_TEST_EQ(low(interval1), -2);
 161   BOOST_TEST_EQ(high(interval1), 3);
 162
 163   deconvolve(interval1, interval2);
 164   BOOST_TEST_EQ(low(interval1), -1);
 165   BOOST_TEST_EQ(high(interval1), 1);
 166
 167   reflected_convolve(interval1, interval2);
 168   BOOST_TEST_EQ(low(interval1), -3);
 169   BOOST_TEST_EQ(high(interval1), 2);
 170
 171   reflected_deconvolve(interval1, interval2);
 172   BOOST_TEST_EQ(low(interval1), -1);
 173   BOOST_TEST_EQ(high(interval1), 1);
 174 }
 175
 176 void interval_concept_test3()
 177 {
 178   typedef Interval<int> interval_type;
 179
 180   interval_type interval1 = construct<interval_type>(1, 3);
 181   BOOST_TEST_EQ(euclidean_distance(interval1, -2), 3);
 182   BOOST_TEST_EQ(euclidean_distance(interval1, 2), 0);
 183   BOOST_TEST_EQ(euclidean_distance(interval1, 4), 1);
 184
 185   interval_type interval2 = construct<interval_type>(-1, 0);
 186   BOOST_TEST_EQ(euclidean_distance(interval1, interval2), 1);
 187   BOOST_TEST(!intersects(interval1, interval2));
 188   BOOST_TEST(!boundaries_intersect(interval1, interval2));
 189   BOOST_TEST(!intersect(interval2, interval1));
 190   BOOST_TEST_EQ(low(interval2), -1);
 191   BOOST_TEST_EQ(high(interval2), 0);
 192
 193   interval_type interval3 = construct<interval_type>(-1, 6);
 194   BOOST_TEST_EQ(euclidean_distance(interval1, interval3), 0);
 195   BOOST_TEST(intersects(interval1, interval3));
 196   BOOST_TEST(!boundaries_intersect(interval1, interval3));
 197   BOOST_TEST(intersect(interval3, interval1));
 198   BOOST_TEST_EQ(low(interval3), 1);
 199   BOOST_TEST_EQ(high(interval3), 3);
 200
 201   interval_type interval4 = construct<interval_type>(5, 6);
 202   BOOST_TEST_EQ(euclidean_distance(interval1, interval4), 2);
 203   BOOST_TEST(!intersects(interval1, interval4));
 204   BOOST_TEST(!boundaries_intersect(interval1, interval4));
 205   BOOST_TEST(!intersect(interval4, interval1));
 206   BOOST_TEST_EQ(low(interval4), 5);
 207   BOOST_TEST_EQ(high(interval4), 6);
 208
 209   interval_type interval5 = construct<interval_type>(3, 5);
 210   BOOST_TEST_EQ(euclidean_distance(interval1, interval5), 0);
 211   BOOST_TEST(!intersects(interval1, interval5, false));
 212   BOOST_TEST(boundaries_intersect(interval1, interval5));
 213   BOOST_TEST(intersect(interval5, interval1));
 214   BOOST_TEST_EQ(low(interval5), 3);
 215   BOOST_TEST_EQ(high(interval5), 3);
 216 }
 217
 218 void interval_concept_test4()
 219 {
 220   typedef Interval<int> interval_type;
 221
 222   interval_type interval1 = construct<interval_type>(1, 3);
 223   interval_type interval2 = construct<interval_type>(3, 5);
 224   BOOST_TEST(!abuts(interval1, interval2, LOW));
 225   BOOST_TEST(abuts(interval1, interval2, HIGH));
 226   BOOST_TEST(abuts(interval1, interval2));
 227
 228   bloat(interval1, 1);
 229   BOOST_TEST_EQ(low(interval1), 0);
 230   BOOST_TEST_EQ(high(interval1), 4);
 231   BOOST_TEST(!abuts(interval1, interval2));
 232
 233   bloat(interval1, LOW, 1);
 234   BOOST_TEST_EQ(low(interval1), -1);
 235   BOOST_TEST_EQ(high(interval1), 4);
 236
 237   shrink(interval1, LOW, 1);
 238   BOOST_TEST_EQ(low(interval1), 0);
 239   BOOST_TEST_EQ(high(interval1), 4);
 240
 241   shrink(interval1, 1);
 242   BOOST_TEST_EQ(low(interval1), 1);
 243   BOOST_TEST_EQ(high(interval1), 3);
 244
 245   BOOST_TEST(encompass(interval1, 4));
 246   BOOST_TEST_EQ(low(interval1), 1);
 247   BOOST_TEST_EQ(high(interval1), 4);
 248
 249   BOOST_TEST(encompass(interval1, interval2));
 250   BOOST_TEST_EQ(low(interval1), 1);
 251   BOOST_TEST_EQ(high(interval1), 5);
 252
 253   interval1 = get_half(interval1, LOW);
 254   BOOST_TEST_EQ(low(interval1), 1);
 255   BOOST_TEST_EQ(high(interval1), 3);
 256
 257   BOOST_TEST(join_with(interval1, interval2));
 258   BOOST_TEST_EQ(low(interval1), 1);
 259   BOOST_TEST_EQ(high(interval1), 5);
 260 }
 261
 262 int main()
 263 {
 264     interval_data_test();
 265     interval_traits_test();
 266     interval_concept_test1();
 267     interval_concept_test2();
 268     interval_concept_test3();
 269     interval_concept_test4();
 270     return boost::report_errors();
 271 }