1 // Boost.GIL (Generic Image Library)
2 //
3 // Copyright (c) 2015, Oracle and/or its affiliates.
4 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
5 //
6 // Licensed under the Boost Software License version 1.0.
7 // http://www.boost.org/users/license.html
8 //
9 // Source: Boost.Geometry (aka GGL, Generic Geometry Library)
10 // Modifications: adapted for Boost.GIL
11 // - Rename namespace boost::geometry to boost::gil
12 // - Rename define BOOST_GEOMETRY_TEST_DEBUG to BOOST_GIL_TEST_DEBUG
13 // - Remove use of macro BOOST_GEOMETRY_CONDITION
14 // - Remove support for boost::multiprecision types
15 // - Remove support for 128-bit integer types
16 // - Update and sort includes
17 // - Add explicit conversions to avoid warnings due to implicit integral promotions
18 //
19 // Uncomment to enable debugging output
20 //#define BOOST_GIL_TEST_DEBUG 1
21
22 #include <boost/gil/promote_integral.hpp>
23
24 #include <algorithm>
25 #include <climits>
26 #include <cstddef>
27 #ifdef BOOST_GIL_TEST_DEBUG
28 #include <iostream>
29 #endif
30 #include <limits>
31 #include <string>
32
33 #ifndef BOOST_TEST_MODULE
34 #define BOOST_TEST_MODULE test_promote_integral
35 #endif
36 #include "unit_test.hpp"
37
38 namespace bg = boost::gil;
39
40 template
41 <
42 typename T,
43 bool Signed = std::is_fundamental<T>::value && !std::is_unsigned<T>::type::value
44 >
45 struct absolute_value
46 {
applyabsolute_value47 static inline T apply(T const& t)
48 {
49 return static_cast<T>(t < 0 ? -t : t);
50 }
51 };
52
53 template <typename T>
54 struct absolute_value<T, false>
55 {
applyabsolute_value56 static inline T apply(T const& t)
57 {
58 return t;
59 }
60 };
61
62 template
63 <
64 typename Integral,
65 typename Promoted,
66 bool Signed = !std::is_unsigned<Promoted>::value
67 >
68 struct test_max_values
69 {
applytest_max_values70 static inline void apply()
71 {
72 // Use >= where value is guaranteed to never be greater than comparator
73 // but to avoid warning: comparing floating point with == is unsafe.
74
75 Promoted min_value = (std::numeric_limits<Integral>::min)();
76 // Explicit casts to avoid warning: conversion to short int from int may alter its value
77 min_value = static_cast<Promoted>(min_value * min_value);
78 BOOST_CHECK(absolute_value<Promoted>::apply(min_value) >= min_value);
79 BOOST_CHECK(absolute_value<Promoted>::apply(min_value) <= min_value);
80 Promoted max_value = (std::numeric_limits<Integral>::max)();
81 max_value = static_cast<Promoted>(max_value * max_value);
82 BOOST_CHECK(absolute_value<Promoted>::apply(max_value) >= max_value);
83 BOOST_CHECK(absolute_value<Promoted>::apply(max_value) <= max_value);
84
85 #ifdef BOOST_GIL_TEST_DEBUG
86 std::cout << "integral min_value^2: " << min_value << std::endl;
87 std::cout << "promoted max_value: "
88 << (std::numeric_limits<Promoted>::max)() << std::endl;
89 #endif
90 }
91 };
92
93 template <typename Integral, typename Promoted>
94 struct test_max_values<Integral, Promoted, false>
95 {
applytest_max_values96 static inline void apply()
97 {
98 Promoted max_value = (std::numeric_limits<Integral>::max)();
99 Promoted max_value_sqr = static_cast<Promoted>(max_value * max_value);
100 BOOST_CHECK(max_value_sqr < (std::numeric_limits<Promoted>::max)()
101 &&
102 max_value_sqr > max_value);
103
104 #ifdef BOOST_GIL_TEST_DEBUG
105 std::cout << "integral max_value^2: " << max_value_sqr << std::endl;
106 std::cout << "promoted max_value: "
107 << (std::numeric_limits<Promoted>::max)() << std::endl;
108 #endif
109 }
110 };
111
112
113 // helper function that returns the bit size of a type
114 template
115 <
116 typename T,
117 bool IsFundamental = std::is_fundamental<T>::value
118 >
119 struct bit_size_impl : std::integral_constant<std::size_t, 0>
120 {};
121
122 template <typename T>
123 struct bit_size_impl<T, true> : bg::detail::promote_integral::bit_size<T>::type
124 {};
125
126 template <typename T>
bit_size()127 std::size_t bit_size()
128 {
129 return bit_size_impl<T>::value;
130 }
131
132 template <bool PromoteUnsignedToUnsigned>
133 struct test_promote_integral
134 {
135 template <typename Type, typename ExpectedPromotedType>
applytest_promote_integral136 static inline void apply(std::string const& case_id)
137 {
138 using promoted_integral_type = typename bg::promote_integral
139 <
140 Type, PromoteUnsignedToUnsigned
141 >::type;
142
143 bool const same_types = std::is_same
144 <
145 promoted_integral_type, ExpectedPromotedType
146 >::value;
147
148 BOOST_CHECK_MESSAGE(same_types,
149 "case ID: " << case_id
150 << "input type: " << typeid(Type).name()
151 << "; detected: "
152 << typeid(promoted_integral_type).name()
153 << "; expected: "
154 << typeid(ExpectedPromotedType).name());
155
156 if (!std::is_same<Type, promoted_integral_type>::value)
157 {
158 test_max_values<Type, promoted_integral_type>::apply();
159 }
160
161 #ifdef BOOST_GIL_TEST_DEBUG
162 std::cout << "case ID: " << case_id << std::endl
163 << "type : " << typeid(Type).name()
164 << ", sizeof (bits): " << bit_size<Type>()
165 << ", min value: "
166 << (std::numeric_limits<Type>::min)()
167 << ", max value: "
168 << (std::numeric_limits<Type>::max)()
169 << std::endl;
170 std::cout << "detected promoted type : "
171 << typeid(promoted_integral_type).name()
172 << ", sizeof (bits): " << bit_size<promoted_integral_type>()
173 << ", min value: "
174 << (std::numeric_limits<promoted_integral_type>::min)()
175 << ", max value: "
176 << (std::numeric_limits<promoted_integral_type>::max)()
177 << std::endl;
178 std::cout << "expected promoted type : "
179 << typeid(ExpectedPromotedType).name()
180 << ", sizeof (bits): " << bit_size<ExpectedPromotedType>()
181 << ", min value: "
182 << (std::numeric_limits<ExpectedPromotedType>::min)()
183 << ", max value: "
184 << (std::numeric_limits<ExpectedPromotedType>::max)()
185 << std::endl;
186 std::cout << std::endl;
187 #endif
188 }
189 };
190
191 template
192 <
193 typename T,
194 bool PromoteUnsignedToUnsigned = false,
195 bool IsSigned = !std::is_unsigned<T>::value
196 >
197 struct test_promotion
198 {
applytest_promotion199 static inline void apply(std::string case_id)
200 {
201 #ifdef BOOST_GIL_TEST_DEBUG
202 std::cout << "*** "
203 << (IsSigned ? "signed" : "unsigned")
204 << " -> signed ***" << std::endl;
205 #endif
206
207 using tester = test_promote_integral<PromoteUnsignedToUnsigned>;
208
209 case_id += (PromoteUnsignedToUnsigned ? "-t" : "-f");
210
211 std::size_t min_size = 2 * bit_size<T>() - 1;
212 if (!IsSigned)
213 {
214 min_size += 2;
215 }
216
217 #ifdef BOOST_GIL_TEST_DEBUG
218 std::cout << "min size: " << min_size << std::endl;
219 #endif
220
221 if (bit_size<short>() >= min_size)
222 {
223 tester::template apply<T, short>(case_id);
224 }
225 else if (bit_size<int>() >= min_size)
226 {
227 tester::template apply<T, int>(case_id);
228 }
229 else if (bit_size<long>() >= min_size)
230 {
231 tester::template apply<T, long>(case_id);
232 }
233 #if defined(BOOST_HAS_LONG_LONG)
234 else if (bit_size<boost::long_long_type>() >= min_size)
235 {
236 tester::template apply<T, boost::long_long_type>(case_id);
237 }
238 #endif
239 else
240 {
241 tester::template apply<T, T>(case_id);
242 }
243 }
244 };
245
246 template <typename T>
247 struct test_promotion<T, true, false>
248 {
applytest_promotion249 static inline void apply(std::string case_id)
250 {
251 #ifdef BOOST_GIL_TEST_DEBUG
252 std::cout << "*** unsigned -> unsigned ***" << std::endl;
253 #endif
254 case_id += "-t";
255
256 using tester = test_promote_integral<true>;
257
258 std::size_t min_size = 2 * bit_size<T>();
259
260 #ifdef BOOST_GIL_TEST_DEBUG
261 std::cout << "min size: " << min_size << std::endl;
262 #endif
263
264 if (bit_size<unsigned short>() >= min_size)
265 {
266 tester::apply<T, unsigned short>(case_id);
267 }
268 else if (bit_size<unsigned int>() >= min_size)
269 {
270 tester::apply<T, unsigned int>(case_id);
271 }
272 else if (bit_size<unsigned long>() >= min_size)
273 {
274 tester::apply<T, unsigned long>(case_id);
275 }
276 else if (bit_size<std::size_t>() >= min_size)
277 {
278 tester::apply<T, std::size_t>(case_id);
279 }
280 #if defined(BOOST_HAS_LONG_LONG)
281 else if (bit_size<boost::ulong_long_type>() >= min_size)
282 {
283 tester::template apply<T, boost::ulong_long_type>(case_id);
284 }
285 #endif
286 else
287 {
288 tester::apply<T, T>(case_id);
289 }
290 }
291 };
292
BOOST_AUTO_TEST_CASE(test_char)293 BOOST_AUTO_TEST_CASE( test_char )
294 {
295 test_promotion<char>::apply("char");
296 test_promotion<char, true>::apply("char");
297 test_promotion<signed char>::apply("schar");
298 test_promotion<signed char, true>::apply("schar");
299 test_promotion<unsigned char>::apply("uchar");
300 test_promotion<unsigned char, true>::apply("uchar");
301 }
302
BOOST_AUTO_TEST_CASE(test_short)303 BOOST_AUTO_TEST_CASE( test_short )
304 {
305 test_promotion<short>::apply("short");
306 test_promotion<short, true>::apply("short");
307 test_promotion<unsigned short>::apply("ushort");
308 test_promotion<unsigned short, true>::apply("ushort");
309 }
310
BOOST_AUTO_TEST_CASE(test_int)311 BOOST_AUTO_TEST_CASE( test_int )
312 {
313 test_promotion<int>::apply("int");
314 test_promotion<int, true>::apply("int");
315 test_promotion<unsigned int>::apply("uint");
316 test_promotion<unsigned int, true>::apply("uint");
317 }
318
BOOST_AUTO_TEST_CASE(test_long)319 BOOST_AUTO_TEST_CASE( test_long )
320 {
321 test_promotion<long>::apply("long");
322 test_promotion<long, true>::apply("long");
323 test_promotion<unsigned long>::apply("ulong");
324 test_promotion<unsigned long, true>::apply("ulong");
325 }
326
BOOST_AUTO_TEST_CASE(test_std_size_t)327 BOOST_AUTO_TEST_CASE( test_std_size_t )
328 {
329 test_promotion<std::size_t>::apply("size_t");
330 test_promotion<std::size_t, true>::apply("size_t");
331 }
332
333 #ifdef BOOST_HAS_LONG_LONG
BOOST_AUTO_TEST_CASE(test_long_long)334 BOOST_AUTO_TEST_CASE( test_long_long )
335 {
336 test_promotion<boost::long_long_type>::apply("long long");
337 test_promotion<boost::long_long_type, true>::apply("long long");
338 test_promotion<boost::ulong_long_type>::apply("ulong long");
339 test_promotion<boost::ulong_long_type, true>::apply("ulong long");
340 }
341 #endif
342
BOOST_AUTO_TEST_CASE(test_floating_point)343 BOOST_AUTO_TEST_CASE( test_floating_point )
344 {
345 using tester1 = test_promote_integral<true>;
346 using tester2 = test_promote_integral<false>;
347
348 // for floating-point types we do not do any promotion
349 tester1::apply<float, float>("fp-f");
350 tester1::apply<double, double>("fp-d");
351 tester1::apply<long double, long double>("fp-ld");
352
353 tester2::apply<float, float>("fp-f");
354 tester2::apply<double, double>("fp-d");
355 tester2::apply<long double, long double>("fp-ld");
356 }
357