1 /*-----------------------------------------------------------------------------+
2 Copyright (c) 2008-2009: Joachim Faulhaber
3 +------------------------------------------------------------------------------+
4 Distributed under the Boost Software License, Version 1.0.
5 (See accompanying file LICENCE.txt or copy at
6 http://www.boost.org/LICENSE_1_0.txt)
7 +-----------------------------------------------------------------------------*/
8 #define BOOST_TEST_MODULE icl::misc unit test
10 #define BOOST_ICL_TEST_CHRONO
12 #include <libs/icl/test/disable_test_warnings.hpp>
15 #include <boost/mpl/list.hpp>
16 #include "../unit_test_unwarned.hpp"
19 // interval instance types
20 #include "../test_type_lists.hpp"
21 #include "../test_value_maker.hpp"
23 #include <boost/type_traits/is_same.hpp>
24 #include <boost/icl/rational.hpp>
26 #include <boost/icl/detail/interval_morphism.hpp>
27 #include <boost/icl/interval_map.hpp>
28 #include <boost/icl/split_interval_set.hpp>
29 #include "../test_laws.hpp"
32 using namespace boost
;
33 using namespace unit_test
;
34 using namespace boost::icl
;
37 BOOST_AUTO_TEST_CASE(test_law_complementarity
)
39 //LAW Inner complementarity: x + between(x) == hull(x)
40 //LAW: length(x) + length(between(x)) = length(hull(x))
41 typedef interval_map
<rational
<int>, int> RatioMapT
;
42 typedef interval_set
<rational
<int> > RatioSetT
;
43 typedef RatioSetT::interval_type IntervalT
;
44 typedef RatioSetT::element_type RatT
;
45 typedef RatioSetT::difference_type DiffT
;
48 (((set_a
+= IntervalT(RatT(0), RatT(1) ) )
49 -= IntervalT(RatT(1,9), RatT(2,9)) )
50 -= IntervalT(RatT(3,9), RatT(4,9)) )
51 -= IntervalT(RatT(5,9), RatT(6,9));
53 RatioSetT between_a
= RatioSetT(hull(set_a
)) - set_a
;
55 between(between_a2
, set_a
);
56 BOOST_CHECK_EQUAL( between_a
, between_a2
);
58 DiffT len_set_a
= length(set_a
);
59 DiffT len_between_a
= length(between_a
);
61 //cout << set_a << " length= " << len_set_a << endl;
62 //cout << between_a << " length= " << len_between_a << endl;
64 RatioSetT span_a
= set_a
+ between_a
;
65 RatioSetT hull_a
= RatioSetT(hull(set_a
));
66 //cout << span_a << endl;
68 BOOST_CHECK_EQUAL( span_a
, hull_a
);
69 BOOST_CHECK_EQUAL( len_set_a
+ len_between_a
, length(hull_a
) );
71 BOOST_CHECK((has_inner_complementarity
<RatioSetT
,RatioSetT
>(set_a
)));
72 BOOST_CHECK((has_length_complementarity(set_a
)));
73 BOOST_CHECK((has_length_as_distance
<RatioSetT
,RatioSetT
>(set_a
)));
77 BOOST_AUTO_TEST_CASE(test_between
)
79 //LAW: between(a,b) == between(b,a);
81 typedef interval
<T
>::type IntervalT
;
82 typedef interval_set
<T
> IntervalSetT
;
84 IntervalT itv_a
= I_D(1,3);
85 IntervalT itv_b
= I_D(5,7);
87 IntervalT beween_a_b
= between(itv_a
, itv_b
);
88 IntervalT beween_b_a
= between(itv_b
, itv_a
);
90 //cout << beween_a_b << endl;
91 //cout << beween_b_a << endl;
92 BOOST_CHECK_EQUAL( beween_a_b
, beween_b_a
);
96 BOOST_AUTO_TEST_CASE(element_iteration
)
98 interval_map
<int,int> map_a
;
99 map_a
+= make_pair(interval
<int>::right_open(0,3),1);
100 //cout << map_a << endl;
102 //for(interval_map<int,int>::element_iterator elem = elements_begin(map_a);
103 // elem != elements_end(map_a); elem++)
104 // cout << "(" << elem->first << "," << elem->second << ")";
105 //cout << "\n-------------------------------------\n";
107 std::pair
<const int, int> search_pair(2,1);
109 //interval_map<int,int>::element_const_iterator found
110 interval_map
<int,int>::element_iterator found
111 = std::find(elements_begin(map_a
), elements_end(map_a
), search_pair
);
112 // cout << "(" << found->first << "," << found->second << ")\n";
113 BOOST_CHECK_EQUAL( found
->first
, 2 );
114 BOOST_CHECK_EQUAL( found
->second
, 1 );
116 // Assignment of an associated value via element_iterator
117 const_cast<int&>(found
->second
) = 2;
118 // cout << map_a << endl;
119 BOOST_CHECK_EQUAL( map_a
.begin()->second
, 2 );
123 BOOST_AUTO_TEST_CASE(test_interval_bounds_1
)
125 BOOST_CHECK_EQUAL(left_bracket(interval_bounds::closed()), "[");
126 BOOST_CHECK_EQUAL(left_bracket(interval_bounds::right_open()), "[");
127 BOOST_CHECK_EQUAL(left_bracket(interval_bounds::left_open()), "(");
128 BOOST_CHECK_EQUAL(left_bracket(interval_bounds::open()), "(");
129 BOOST_CHECK_EQUAL(right_bracket(interval_bounds::closed()), "]");
130 BOOST_CHECK_EQUAL(right_bracket(interval_bounds::right_open()), ")");
131 BOOST_CHECK_EQUAL(right_bracket(interval_bounds::left_open()), "]");
132 BOOST_CHECK_EQUAL(right_bracket(interval_bounds::open()), ")");
134 continuous_interval
<double> a_1
= continuous_interval
<double>(-5.0, -2.3, interval_bounds::closed());
135 continuous_interval
<double> b_1
= continuous_interval
<double>(-2.6, 4.0, interval_bounds::closed());
137 split_interval_set
<double> a
, b
, a_o_b
, b_o_a
;
144 BOOST_CHECK_EQUAL(a_o_b
, b_o_a
);
146 continuous_interval
<double> c_1
= continuous_interval
<double>(1.0, 3.0, interval_bounds::closed());
147 continuous_interval
<double> b_2
= right_subtract(b_1
, c_1
);
149 BOOST_CHECK_EQUAL(b_2
.bounds(), interval_bounds::right_open());
150 BOOST_CHECK_EQUAL(icl::bounds(b_2
), interval_bounds::right_open());
152 continuous_interval
<double> L0T
= continuous_interval
<double>(0.0, 0.0, interval_bounds::closed());
153 continuous_interval
<double> C0T
= continuous_interval
<double>(0.0, 0.0, interval_bounds::left_open());
154 continuous_interval
<double> L0D
= continuous_interval
<double>(0.0, 0.0, interval_bounds::right_open());
155 continuous_interval
<double> C0D
= continuous_interval
<double>(0.0, 0.0, interval_bounds::open());
157 BOOST_CHECK_EQUAL(icl::is_empty(L0T
), false);
158 BOOST_CHECK_EQUAL(icl::is_empty(C0T
), true);
159 BOOST_CHECK_EQUAL(icl::is_empty(L0D
), true);
160 BOOST_CHECK_EQUAL(icl::is_empty(C0D
), true);
163 continuous_interval
<double> L0_1T
= continuous_interval
<double>(0.0, 1.0, interval_bounds::closed());
164 continuous_interval
<double> L1_2T
= continuous_interval
<double>(1.0, 2.0, interval_bounds::closed());
165 BOOST_CHECK_EQUAL(icl::exclusive_less(L0_1T
, L1_2T
), false);
166 BOOST_CHECK_EQUAL(icl::inner_bounds(L0_1T
, L1_2T
) == interval_bounds::open(), true);
168 continuous_interval
<double> L0_1D
= continuous_interval
<double>(0.0, 1.0, interval_bounds::right_open());
169 BOOST_CHECK_EQUAL(icl::exclusive_less(L0_1D
, L1_2T
), true);
170 BOOST_CHECK_EQUAL(icl::inner_bounds(L0_1D
, L1_2T
) == interval_bounds::right_open(), true);
172 continuous_interval
<double> C1_2T
= continuous_interval
<double>(1.0, 2.0, interval_bounds::left_open());
173 BOOST_CHECK_EQUAL(icl::exclusive_less(L0_1T
, C1_2T
), true);
174 BOOST_CHECK_EQUAL(icl::inner_bounds(L0_1T
, C1_2T
) == interval_bounds::left_open(), true);
176 BOOST_CHECK_EQUAL(icl::exclusive_less(L0_1D
, C1_2T
), true);
177 BOOST_CHECK_EQUAL(icl::inner_bounds(L0_1D
, C1_2T
) == interval_bounds::closed(), true);
179 BOOST_CHECK_EQUAL(static_cast<int>(icl::right(L0_1T
.bounds()).bits()), 1);
180 BOOST_CHECK_EQUAL(static_cast<int>(icl::right(L0_1D
.bounds()).bits()), 0);
182 BOOST_CHECK_EQUAL(icl::right_bounds(L0_1D
, L0_1T
), interval_bounds::left_open());
186 BOOST_AUTO_TEST_CASE(test_infinities
)
188 BOOST_CHECK(( has_std_infinity
<double>::value
));
189 BOOST_CHECK((!has_std_infinity
<int>::value
));
191 BOOST_CHECK(( has_max_infinity
<int>::value
));
192 BOOST_CHECK((!has_max_infinity
<double>::value
));
194 //--------------------------------------------------------------------------
195 BOOST_CHECK_EQUAL( numeric_infinity
<double>::value(), (std::numeric_limits
<double>::infinity
)() );
196 BOOST_CHECK_EQUAL( numeric_infinity
<int>::value(), (std::numeric_limits
<int>::max
)() );
197 BOOST_CHECK_EQUAL( numeric_infinity
<std::string
>::value(), std::string() );
199 //--------------------------------------------------------------------------
200 BOOST_CHECK_EQUAL( icl::infinity
<double>::value(), (std::numeric_limits
<double>::infinity
)() );
201 BOOST_CHECK_EQUAL( icl::infinity
<int>::value(), (std::numeric_limits
<int>::max
)() );
202 BOOST_CHECK_EQUAL( icl::infinity
<std::string
>::value(), icl::identity_element
<std::string
>::value() );
204 //--------------------------------------------------------------------------
205 BOOST_CHECK_EQUAL( icl::infinity
<boost::chrono::duration
<double> >::value()
206 , boost::chrono::duration
<double>((std::numeric_limits
<double>::infinity
)()) );
207 BOOST_CHECK_EQUAL( icl::infinity
<boost::chrono::duration
<int> >::value()
208 , boost::chrono::duration
<int>((std::numeric_limits
<int>::max
)()) );
212 BOOST_AUTO_TEST_CASE(test_difference_types
)
214 BOOST_CHECK(( boost::is_same
< int, difference_type_of
<int>::type
>::value
));
215 BOOST_CHECK(( boost::is_same
< double, difference_type_of
<double>::type
>::value
));
216 BOOST_CHECK(( boost::is_same
< std::ptrdiff_t, difference_type_of
<int*>::type
>::value
));
218 BOOST_CHECK(( has_difference_type
<std::string
>::value
));
219 BOOST_CHECK(( boost::is_same
< std::string::difference_type
, difference_type_of
<std::string
>::type
>::value
));
220 BOOST_CHECK(( boost::is_same
< std::ptrdiff_t, difference_type_of
<std::string
>::type
>::value
));
222 BOOST_CHECK(( boost::is_same
< boost::chrono::duration
<int>
223 , difference_type_of
<boost::chrono::duration
<int> >::type
>::value
));
224 BOOST_CHECK(( boost::is_same
< boost::chrono::duration
<double>
225 , difference_type_of
<boost::chrono::duration
<double> >::type
>::value
));
227 BOOST_CHECK(( boost::is_same
< Now::time_point::duration
228 , difference_type_of
<Now::time_point
>::type
>::value
));
230 typedef boost::chrono::time_point
<Now
, boost::chrono::duration
<double> > contin_timeT
;
231 BOOST_CHECK(( boost::is_same
< contin_timeT::duration
232 , difference_type_of
<contin_timeT
>::type
>::value
));
234 typedef boost::chrono::time_point
<Now
, boost::chrono::duration
<int> > discr_timeT
;
235 BOOST_CHECK(( boost::is_same
< boost::chrono::duration
<int>
236 , difference_type_of
<discr_timeT
>::type
>::value
));
239 BOOST_AUTO_TEST_CASE(test_size_types
)
241 BOOST_CHECK(( boost::is_same
< std::size_t, size_type_of
<int>::type
>::value
));
242 BOOST_CHECK(( boost::is_same
< std::size_t, size_type_of
<double>::type
>::value
));
243 BOOST_CHECK(( boost::is_same
< std::size_t, size_type_of
<int*>::type
>::value
));
244 BOOST_CHECK(( boost::is_same
< std::size_t, size_type_of
<std::string
>::type
>::value
));
245 BOOST_CHECK(( boost::is_same
< boost::chrono::duration
<int>
246 , size_type_of
<boost::chrono::duration
<int> >::type
>::value
));
247 BOOST_CHECK(( boost::is_same
< boost::chrono::duration
<double>
248 , size_type_of
<boost::chrono::duration
<double> >::type
>::value
));
250 typedef boost::chrono::time_point
<Now
, boost::chrono::duration
<int> > discr_timeT
;
251 BOOST_CHECK(( boost::is_same
< boost::chrono::duration
<int>
252 , size_type_of
<discr_timeT
>::type
>::value
));
254 typedef boost::chrono::time_point
<Now
, boost::chrono::duration
<double> > contin_timeT
;
255 BOOST_CHECK(( boost::is_same
< contin_timeT::duration
256 , size_type_of
<contin_timeT
>::type
>::value
));
259 BOOST_AUTO_TEST_CASE(test_chrono_identity_elements
)
261 //boost::chrono::duration<int> idel_i = icl::identity_element<boost::chrono::duration<int> >::value();
262 //cout << "dur<int>0 = " << idel_i << endl;
263 //boost::chrono::duration<double> idel_d = icl::identity_element<boost::chrono::duration<int> >::value();
264 //cout << "dur<dbl>0 = " << idel_d << endl;
266 BOOST_CHECK(( boost::is_same
< boost::chrono::duration
<int>
267 , size_type_of
<boost::chrono::duration
<int> >::type
>::value
));