ChimeraTK-DeviceAccess 03.25.00
Loading...
Searching...
No Matches
testFixedPointConverter.cpp
Go to the documentation of this file.
1// SPDX-FileCopyrightText: Deutsches Elektronen-Synchrotron DESY, MSK, ChimeraTK Project <chimeratk-support@desy.de>
2// SPDX-License-Identifier: LGPL-3.0-or-later
3
4#define BOOST_TEST_DYN_LINK
5#define BOOST_TEST_MODULE FixedPointConverterTest
6#include <boost/test/unit_test.hpp>
7using namespace boost::unit_test_framework;
8
9/* Test requirements:
10 * Test to and from double for the follwing cases:
11 * int32, uint32, int16, uint16, int8, uint8. No fractional bits (standard data
12 * types) 32 bits with -12 (negative), -1 (test rounding), 1 (test rounding), 7
13 * (somewhere in the middle), 31, 32 (resolution edge) and 43 (larger than 32
14 * bits), fractional bits, signed and unsigned 18 bits with -12, 0, 7, 17, 18,
15 * 43 fractional bits, signed and unsigned
16 *
17 * All tests are run with the bit sequence 0xAAAAAAAA (negative when signed)
18 * and 0x55555555 (positive when signed) to float,
19 * and with +-0.25, +-0.75, +-3.25 +-5.75 to fixed
20 * to test correct rounding.
21 *
22 */
23
24#define HEX_TO_DOUBLE(INPUT) static_cast<double>(INPUT)
25#define SIGNED_HEX_TO_DOUBLE(INPUT) static_cast<double>(static_cast<int32_t>(INPUT))
26#define SIGNED_HEX_TO_INT64(INPUT) static_cast<int64_t>(static_cast<int32_t>(INPUT))
27
28#define CHECK_SIGNED_FIXED_POINT_NO_FRACTIONAL \
29 checkToFixedPoint(converter, 0.25, 0); \
30 checkToFixedPoint(converter, -0.25, 0); \
31 checkToFixedPoint(converter, 0.75, 1); \
32 checkToFixedPoint(converter, -0.75, -1); \
33 checkToFixedPoint(converter, 3.25, 3); \
34 checkToFixedPoint(converter, -3.25, -3); \
35 checkToFixedPoint(converter, 5.75, 6); \
36 checkToFixedPoint(converter, -5.75, -6);
37
38#include "Exception.h"
39#include "FixedPointConverter.h"
40
41#include <sstream>
42namespace ChimeraTK {
43 using namespace ChimeraTK;
44}
45using namespace ChimeraTK;
46
47// get name of a type for better readible error messages
48template<typename T>
49inline const char* typeName(void) {
50 return "unknown";
51}
52#define DEF_TYPENAME(name) \
53 template<> \
54 inline const char* typeName<name>(void) { \
55 return #name; \
56 }
57DEF_TYPENAME(int32_t)
58DEF_TYPENAME(uint32_t)
59DEF_TYPENAME(int16_t)
60DEF_TYPENAME(uint16_t)
61DEF_TYPENAME(int8_t)
62DEF_TYPENAME(uint8_t)
63DEF_TYPENAME(int64_t)
64DEF_TYPENAME(uint64_t)
65DEF_TYPENAME(float)
66DEF_TYPENAME(double)
67DEF_TYPENAME(std::string)
68DEF_TYPENAME(Boolean)
69
70template<typename T>
71void checkToCookedOverflowNeg(FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> const& converter, uint32_t input) {
72 BOOST_CHECK_EQUAL(converter.scalarToCooked<T>(input), std::numeric_limits<T>::min());
73}
74
75template<typename T>
76void checkToCookedOverflowPos(FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> const& converter, uint32_t input) {
77 BOOST_CHECK_EQUAL(converter.scalarToCooked<T>(input), std::numeric_limits<T>::max());
78}
79
80template<typename T>
81void checkToCooked(FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> const& converter, uint32_t input, T expectedValue,
82 const std::string& msg = std::string("")) {
83 std::stringstream message;
84 message << "testToCooked failed for type " << typeName<T>() << " with input " << std::hex << "0x" << input << std::hex
85 << ", expected 0x" << expectedValue << std::dec;
86
87 BOOST_TEST_CHECKPOINT(message.str());
88
89 T output = converter.scalarToCooked<T>(input);
90 if(msg.empty()) {
91 message << std::hex << ", output 0x" << output << std::dec;
92 }
93 else {
94 message << std::hex << ", output 0x" << output << std::dec << ", " << msg;
95 }
96
97 BOOST_CHECK_MESSAGE(output == expectedValue, message.str());
98}
99
100template<typename T>
101void checkToRaw(FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> const& converter, T input, uint32_t expectedValue,
102 const std::string& msg = std::string("")) {
103 std::stringstream message;
104 message << "testToRaw failed for type " << typeName<T>() << " with input 0x" << std::hex << input << ", expected 0x"
105 << expectedValue << std::dec;
106
107 BOOST_TEST_CHECKPOINT(message.str());
108
109 uint32_t result = converter.toRaw(input);
110 if(msg.empty()) {
111 message << std::hex << ", output 0x" << result << std::dec;
112 }
113 else {
114 message << std::hex << ", output 0x" << result << std::dec << ", " << msg;
115 }
116
117 BOOST_CHECK_MESSAGE(result == expectedValue, message.str());
118}
119
120BOOST_AUTO_TEST_SUITE(FixedPointConverterTestSuite)
121
122BOOST_AUTO_TEST_CASE(testConstructor) {
123 BOOST_CHECK_NO_THROW(FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT>("UnknownVariable"));
124 BOOST_CHECK_NO_THROW(FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT>("UnknownVariable", 16, 42, false));
125
126 // number of significant bits - lowest number where exception should be thrown
127 BOOST_CHECK_THROW(FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT>("UnknownVariable", 33), ChimeraTK::logic_error);
128 // number of significant bits - highest number where exception should NOT be thrown
129 BOOST_CHECK_NO_THROW(FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT>("UnknownVariable", 32));
130 // dynamic range of sufficient for bit shift
131 BOOST_CHECK_THROW(
132 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT>("UnknownVariable", 2, 1021 - 1), ChimeraTK::logic_error);
133 BOOST_CHECK_THROW(
134 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT>("UnknownVariable", 2, -1024 + 1), ChimeraTK::logic_error);
135 BOOST_CHECK_NO_THROW(FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT>("UnknownVariable", 2, 1021 - 2));
136 BOOST_CHECK_NO_THROW(FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT>("UnknownVariable", 2, -1024 + 2));
137}
138
139BOOST_AUTO_TEST_CASE(testInt32) {
140 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter(
141 "Variable32signed"); // default parameters are signed 32 bit
142 checkToCooked(converter, 0xAAAAAAAA, SIGNED_HEX_TO_DOUBLE(0xAAAAAAAA));
143 checkToCooked(converter, 0x55555555, HEX_TO_DOUBLE(0x55555555));
144 checkToCooked(converter, 0xAAAAAAAA, (int)0xAAAAAAAA);
145 checkToCooked(converter, 0x55555555, (int)0x55555555);
146 checkToCooked(converter, 0xAAAAAAAA, SIGNED_HEX_TO_INT64(0xAAAAAAAA));
147 checkToCooked(converter, 0x55555555, (uint64_t)0x55555555);
148
149 checkToCookedOverflowNeg<unsigned int>(converter, 0xAAAAAAAA);
150 checkToCooked(converter, 0x55555555, (unsigned int)0x55555555);
151 checkToCookedOverflowNeg<short>(converter, 0xAAAAAAAA);
152 checkToCookedOverflowPos<short>(converter, 0x55555555);
153 checkToCookedOverflowNeg<unsigned short>(converter, 0xAAAAAAAA);
154 checkToCookedOverflowPos<unsigned short>(converter, 0x55555555);
155
156 checkToRaw(converter, 0.25, 0);
157 checkToRaw(converter, -0.25, 0);
158 checkToRaw(converter, 0.75, 1);
159 checkToRaw(converter, -0.75, -1);
160 checkToRaw(converter, 3.25, 3);
161 checkToRaw(converter, -3.25, -3);
162 checkToRaw(converter, 5.75, 6);
163 checkToRaw(converter, -5.75, -6);
164
165 checkToRaw(converter, (int)0x55555555, 0x55555555);
166 checkToRaw(converter, (int)0xAAAAAAAA, 0xAAAAAAAA);
167 checkToRaw(converter, (unsigned int)0x55555555, 0x55555555);
168 checkToRaw(converter, (unsigned int)0xAAAAAAAA, 0x7FFFFFFF);
169 checkToRaw(converter, (short)0x5555, 0x5555);
170 checkToRaw(converter, (short)0xAAAA, 0xFFFFAAAA);
171 checkToRaw(converter, (unsigned short)0x5555, 0x5555);
172 checkToRaw(converter, (unsigned short)0xAAAA, 0xAAAA);
173 checkToRaw(converter, (int64_t)0x5555, 0x5555);
174 checkToRaw(converter, (int64_t)0xFFFFFFFFFFFFAAAA, 0xFFFFAAAA);
175 checkToRaw(converter, (int64_t)0xFFFFFFFAAAAAAAAA,
176 0x80000000); // Smallest signed representation possible
177 checkToRaw(converter, (int64_t)0xFFFFFFFFF, 0x7FFFFFFF);
178 checkToRaw(converter, (uint64_t)0xFFFFFFFFF,
179 0x7FFFFFFF); // max signed representation possible
180
181 checkToCooked(converter, 0x55555555, std::string("1431655765"));
182 checkToRaw(converter, std::string("1431655765"), 0x55555555);
183
184 // Boolean check
185 checkToCooked(converter, 0x55555555, Boolean(true));
186}
187
188BOOST_AUTO_TEST_CASE(testUInt32) {
189 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable32unsigned", 32, 0,
190 false); // 32 bits, 0 fractional bits, not signed
191
192 checkToCooked(converter, 0xAAAAAAAA, HEX_TO_DOUBLE(0xAAAAAAAA));
193 checkToCooked(converter, 0x55555555, HEX_TO_DOUBLE(0x55555555));
194 checkToCookedOverflowPos<int>(converter, 0xAAAAAAAA);
195 checkToCooked(converter, 0x55555555, (int)0x55555555);
196 checkToCooked(converter, 0xAAAAAAAA, (unsigned int)0xAAAAAAAA);
197 checkToCooked(converter, 0x55555555, (unsigned int)0x55555555);
198 checkToCookedOverflowPos<short>(converter, 0xAAAAAAAA);
199 checkToCookedOverflowPos<unsigned short>(converter, 0x55555555);
200 checkToCooked(converter, 0xAAAAAAAA, (int64_t)0xAAAAAAAA);
201 checkToCooked(converter, 0x55555555, (uint64_t)0x55555555);
202
203 checkToRaw(converter, 0.25, 0);
204 checkToRaw(converter, -0.25, 0);
205 checkToRaw(converter, 0.75, 1);
206 checkToRaw(converter, -0.75, 0);
207 checkToRaw(converter, 3.25, 3);
208 checkToRaw(converter, -3.25, 0);
209 checkToRaw(converter, 5.75, 6);
210 checkToRaw(converter, -5.75, 0);
211
212 checkToRaw(converter, (int)0x55555555, 0x55555555);
213 checkToRaw(converter, (int)0xAAAAAAAA, 0);
214 checkToRaw(converter, (unsigned int)0x55555555, 0x55555555);
215 checkToRaw(converter, (unsigned int)0xAAAAAAAA, 0xAAAAAAAA);
216 checkToRaw(converter, (short)0x5555, 0x5555);
217 checkToRaw(converter, (short)0xAAAA, 0);
218 checkToRaw(converter, (unsigned short)0x5555, 0x5555);
219 checkToRaw(converter, (unsigned short)0xAAAA, 0xAAAA);
220 checkToRaw(converter, (int64_t)0x5555, 0x5555);
221 checkToRaw(converter, SIGNED_HEX_TO_INT64(0xAAAAAAAA),
222 0x0); // Lowest range of 32 bit wide unsigned register
223 checkToRaw(converter, (int64_t)0x100000000, 0xFFFFFFFF);
224 checkToRaw(converter, (uint64_t)0x100000000,
225 0xFFFFFFFF); // max signed representation possible
226
227 checkToCooked(converter, 0x55555555, std::string("1431655765"));
228 checkToRaw(converter, std::string("1431655765"), 0x55555555);
229
230 checkToCooked(converter, 0xAAAAAAAA, std::string("2863311530"));
231 checkToRaw(converter, std::string("2863311530"), 0xAAAAAAAA);
232
233 checkToCooked(converter, 0xAAAAAAAA, Boolean(true));
234}
235
236BOOST_AUTO_TEST_CASE(testInt16) {
237 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable16signed",
238 16); // 16 bits, 0 fractional bits, signed
239
240 checkToCooked(converter, 0xAAAA, SIGNED_HEX_TO_DOUBLE(0xFFFFAAAA));
241 checkToCooked(converter, 0x5555, HEX_TO_DOUBLE(0x5555));
242 checkToCooked(converter, 0xAAAA, (int)0xFFFFAAAA);
243 checkToCooked(converter, 0x5555, (int)0x5555);
244 checkToCookedOverflowNeg<unsigned int>(converter, 0xAAAA);
245 checkToCooked(converter, 0x5555, (unsigned int)0x5555);
246 checkToCooked(converter, 0xAAAA, (short)0xAAAA);
247 checkToCooked(converter, 0x5555, (short)0x5555);
248 checkToCookedOverflowNeg<unsigned short>(converter, 0xAAAA);
249 checkToCooked(converter, 0x5555, (unsigned short)0x5555);
250 checkToCooked(converter, 0x5555, (int64_t)0x5555);
251 checkToCooked(converter, 0xAAAA, static_cast<int64_t>(static_cast<int16_t>(0xAAAA)));
252
253 checkToCooked(converter, 0x5555, (uint64_t)0x5555);
254 checkToCookedOverflowNeg<uint64_t>(converter, 0xAAAA);
255
256 checkToRaw(converter, 0.25, 0);
257 checkToRaw(converter, -0.25, 0);
258 checkToRaw(converter, 0.75, 1);
259 checkToRaw(converter, -0.75, 0xFFFF);
260 checkToRaw(converter, 3.25, 3);
261 checkToRaw(converter, -3.25, 0xFFFD);
262 checkToRaw(converter, 5.75, 6);
263 checkToRaw(converter, -5.75, 0xFFFA);
264
265 checkToRaw(converter, (int)0x55555555, 0x7FFF);
266 checkToRaw(converter, (int)0xAAAAAAAA, 0x8000);
267 checkToRaw(converter, (unsigned int)0x55555555, 0x7FFF);
268 checkToRaw(converter, (unsigned int)0xAAAAAAAA, 0x7FFF);
269 checkToRaw(converter, (short)0x5555, 0x5555);
270 checkToRaw(converter, (short)0xAAAA, 0xAAAA);
271 checkToRaw(converter, (unsigned short)0x5555, 0x5555);
272 checkToRaw(converter, (unsigned short)0xAAAA, 0x7FFF);
273 checkToRaw(converter, (int64_t)0x5555, 0x5555);
274 checkToRaw(converter, static_cast<int64_t>(static_cast<int16_t>(0xAAAA)), 0xAAAA);
275 checkToRaw(converter, (int64_t)0x555555, 0x7FFF);
276 checkToRaw(converter, static_cast<int64_t>(static_cast<int32_t>(0xAAAAAAAA)), 0x8000);
277 checkToRaw(converter, (uint64_t)0x5555, 0x5555);
278 checkToRaw(converter, (uint64_t)0x0, 0x0);
279 checkToRaw(converter, (uint64_t)0xF555, 0x7FFF);
280}
281
282BOOST_AUTO_TEST_CASE(testUInt16) {
283 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable16unsigned", 16, 0,
284 false); // 16 bits, 0 fractional bits, not signed
285
286 checkToCooked(converter, 0xAAAA, HEX_TO_DOUBLE(0xAAAA));
287 checkToCooked(converter, 0x5555, HEX_TO_DOUBLE(0x5555));
288 checkToCooked(converter, 0xAAAA, (int)0xAAAA);
289 checkToCooked(converter, 0x5555, (int)0x5555);
290 checkToCooked(converter, 0xAAAA, (unsigned int)0xAAAA);
291 checkToCooked(converter, 0x5555, (unsigned int)0x5555);
292 checkToCookedOverflowPos<short>(converter, 0xAAAA);
293 checkToCooked(converter, 0x5555, (short)0x5555);
294 checkToCooked(converter, 0xAAAA, (unsigned short)0xAAAA);
295 checkToCooked(converter, 0x5555, (unsigned short)0x5555);
296 checkToCooked(converter, 0x5555, (int64_t)0x5555);
297 checkToCooked(converter, 0xAAAA, (int64_t)0xAAAA);
298 checkToCooked(converter, 0x5555, (uint64_t)0x5555);
299 checkToCooked(converter, 0xAAAA, (uint64_t)0xAAAA);
300
301 checkToRaw(converter, 0.25, 0);
302 checkToRaw(converter, -0.25, 0);
303 checkToRaw(converter, 0.75, 1);
304 checkToRaw(converter, -0.75, 0);
305 checkToRaw(converter, 3.25, 3);
306 checkToRaw(converter, -3.25, 0);
307 checkToRaw(converter, 5.75, 6);
308 checkToRaw(converter, -5.75, 0);
309
310 checkToRaw(converter, (int)0x55555555, 0xFFFF);
311 checkToRaw(converter, (int)0xAAAAAAAA, 0);
312 checkToRaw(converter, (unsigned int)0x55555555, 0xFFFF);
313 checkToRaw(converter, (unsigned int)0xAAAAAAAA, 0xFFFF);
314 checkToRaw(converter, (short)0x5555, 0x5555);
315 checkToRaw(converter, (short)0xAAAA, 0);
316 checkToRaw(converter, (unsigned short)0x5555, 0x5555);
317 checkToRaw(converter, (unsigned short)0xAAAA, 0xAAAA);
318 checkToRaw(converter, (int64_t)0x5555, 0x5555);
319 checkToRaw(converter, static_cast<int64_t>(static_cast<int16_t>(0xAAAA)), 0);
320 checkToRaw(converter, (int64_t)0x555555, 0xFFFF);
321 checkToRaw(converter, (uint64_t)0x5555, 0x5555);
322 checkToRaw(converter, (uint64_t)0x0, 0x0);
323 checkToRaw(converter, (uint64_t)0xFF555, 0xFFFF);
324}
325
326BOOST_AUTO_TEST_CASE(testInt8) {
327 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable8signed",
328 8); // 8 bits, 0 fractional bits, signed
329
330 checkToCooked(converter, 0xAA, SIGNED_HEX_TO_DOUBLE(0xFFFFFFAA));
331 checkToCooked(converter, 0x55, HEX_TO_DOUBLE(0x55));
332 checkToCooked(converter, 0xAA, (int)0xFFFFFFAA);
333 checkToCooked(converter, 0x55, (int)0x55);
334 checkToCookedOverflowNeg<unsigned int>(converter, 0xAA);
335 checkToCooked(converter, 0x55, (unsigned int)0x55);
336 checkToCooked(converter, 0xAA, (short)0xFFAA);
337 checkToCooked(converter, 0x55, (short)0x55);
338 checkToCookedOverflowNeg<unsigned short>(converter, 0xAA);
339 checkToCooked(converter, 0x55, (unsigned short)0x55);
340 checkToCooked(converter, 0x55, (int64_t)0x55);
341 checkToCooked(converter, 0xAA, static_cast<int64_t>(static_cast<int8_t>(0xAA)));
342 checkToCooked(converter, 0x55, (uint64_t)0x55);
343 checkToCookedOverflowNeg<uint64_t>(converter, 0xAA);
344
345 checkToRaw(converter, 0.25, 0);
346 checkToRaw(converter, -0.25, 0);
347 checkToRaw(converter, 0.75, 1);
348 checkToRaw(converter, -0.75, 0xFF);
349 checkToRaw(converter, 3.25, 3);
350 checkToRaw(converter, -3.25, 0xFD);
351 checkToRaw(converter, 5.75, 6);
352 checkToRaw(converter, -5.75, 0xFA);
353
354 checkToRaw(converter, (int)0x55555555, 0x7F);
355 checkToRaw(converter, (int)0xAAAAAAAA, 0x80);
356 checkToRaw(converter, (unsigned int)0x55555555, 0x7F);
357 checkToRaw(converter, (unsigned int)0xAAAAAAAA, 0x7F);
358 checkToRaw(converter, (short)0x5555, 0x7F);
359 checkToRaw(converter, (short)0xAAAA, 0x80);
360 checkToRaw(converter, (unsigned short)0x5555, 0x7F);
361 checkToRaw(converter, (unsigned short)0xAAAA, 0x7F);
362
363 checkToRaw(converter, (int64_t)0x55, 0x55);
364 checkToRaw(converter, static_cast<int64_t>(static_cast<int8_t>(0xAA)), 0xAA);
365 checkToRaw(converter, (int64_t)0x5555, 0x7F);
366 checkToRaw(converter, static_cast<int64_t>(static_cast<int32_t>(0xAAAAAAAA)), 0x80);
367 checkToRaw(converter, (uint64_t)0x55, 0x55);
368 checkToRaw(converter, (uint64_t)0xF5, 0x7F);
369}
370
371BOOST_AUTO_TEST_CASE(testUInt8) {
372 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable8unsigned", 8, 0,
373 false); // 8 bits, 0 fractional bits, not signed
374
375 checkToCooked(converter, 0xAA, HEX_TO_DOUBLE(0xAA));
376 checkToCooked(converter, 0x55, HEX_TO_DOUBLE(0x55));
377 checkToCooked(converter, 0xAA, (int)0xAA);
378 checkToCooked(converter, 0x55, (int)0x55);
379 checkToCooked(converter, 0xAA, (unsigned int)0xAA);
380 checkToCooked(converter, 0x55, (unsigned int)0x55);
381 checkToCooked(converter, 0xAA, (short)0xAA);
382 checkToCooked(converter, 0x55, (short)0x55);
383 checkToCooked(converter, 0xAA, (unsigned short)0xAA);
384 checkToCooked(converter, 0x55, (unsigned short)0x55);
385 checkToCooked(converter, 0x55, (int64_t)0x55);
386 checkToCooked(converter, 0xAA, (int64_t)0xAA);
387 checkToCooked(converter, 0x55, (uint64_t)0x55);
388 checkToCooked(converter, 0xAA, (uint64_t)0xAA);
389
390 checkToRaw(converter, 0.25, 0);
391 checkToRaw(converter, -0.25, 0);
392 checkToRaw(converter, 0.75, 1);
393 checkToRaw(converter, -0.75, 0);
394 checkToRaw(converter, 3.25, 3);
395 checkToRaw(converter, -3.25, 0);
396 checkToRaw(converter, 5.75, 6);
397 checkToRaw(converter, -5.75, 0);
398
399 checkToRaw(converter, (int)0x55555555, 0xFF);
400 checkToRaw(converter, (int)0xAAAAAAAA, 0);
401 checkToRaw(converter, (unsigned int)0x55555555, 0xFF);
402 checkToRaw(converter, (unsigned int)0xAAAAAAAA, 0xFF);
403 checkToRaw(converter, (short)0x5555, 0xFF);
404 checkToRaw(converter, (short)0xAAAA, 0);
405 checkToRaw(converter, (unsigned short)0x5555, 0xFF);
406 checkToRaw(converter, (unsigned short)0xAAAA, 0xFF);
407 checkToRaw(converter, (int64_t)0x55, 0x55);
408 checkToRaw(converter, static_cast<int64_t>(static_cast<int16_t>(0xAAAA)), 0);
409 checkToRaw(converter, (int64_t)0x555555, 0xFF);
410 checkToRaw(converter, (uint64_t)0x55, 0x55);
411 checkToRaw(converter, (uint64_t)0x0, 0x0);
412 checkToRaw(converter, (uint64_t)0xFF555, 0xFF);
413}
414
415BOOST_AUTO_TEST_CASE(testInt32_fractionMinus12) {
416 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable32minus12signed", 32,
417 -12); // 32 bits, -12 fractional bits, signed
418
419 checkToCooked(converter, 0xAAAAAAAA, SIGNED_HEX_TO_DOUBLE(0xAAAAAAAA) * pow(2, 12)); // Basically a left shift 12
420 // places
421 checkToCooked(converter, 0x55555555, SIGNED_HEX_TO_DOUBLE(0x55555555) * pow(2, 12));
422 checkToCookedOverflowPos<int>(converter, 0x000AAAAA);
423 checkToCooked(converter, 0xFFFAAAAA, (int)0xAAAAA000);
424 checkToCooked(converter, 0x00055555, (int)0x55555000);
425 checkToCookedOverflowNeg<unsigned int>(converter, 0xFFFAAAAA);
426 checkToCooked(converter, 0x00055555, (unsigned int)0x55555000);
427 checkToCooked(converter, 0x000AAAAA, (unsigned int)0xAAAAA000);
428 checkToCooked(converter, 0xAAAAAAAA, (int64_t)0xFFFFFAAAAAAAA000);
429 checkToCooked(converter, 0x55555555, (int64_t)0x55555555000);
430 checkToCooked(converter, 0x55555555, (uint64_t)0x55555555000);
431 checkToCookedOverflowNeg<uint64_t>(converter, 0xAAAAAAAA);
432
433 checkToRaw(converter, 0.25, 0);
434 checkToRaw(converter, -0.25, 0);
435 checkToRaw(converter, 0.75, 0);
436 checkToRaw(converter, -0.75, 0);
437 checkToRaw(converter, 3.25, 0);
438 checkToRaw(converter, -3.25, 0);
439 checkToRaw(converter, 5.75, 0);
440 checkToRaw(converter, -5.75, 0);
441
442 checkToRaw(converter, (int)0x55555555, 0x00055555);
443 checkToRaw(converter, (int)0xAAAAAAAA, 0xFFFAAAAB);
444 checkToRaw(converter, (unsigned int)0x55555555, 0x00055555);
445 checkToRaw(converter, (unsigned int)0xAAAAAAAA, 0x000AAAAB);
446 checkToRaw(converter, (short)0x5555, 0x00000005);
447 checkToRaw(converter, (short)0xAAAA, 0xFFFFFFFB);
448 checkToRaw(converter, (unsigned short)0x5555, 0x00000005);
449 checkToRaw(converter, (unsigned short)0xAAAA, 0x0000000B);
450 checkToRaw(converter, (int64_t)0x55555555, 0x00055555);
451 checkToRaw(converter, static_cast<int64_t>(static_cast<int32_t>(0xAAAAAAAA)), 0XFFFAAAAB);
452 checkToRaw(converter, (int64_t)0x5555555555555, 0x7fffffff); // full range
453 checkToRaw(converter, (int64_t)0xFFFFA55555555555, 0x80000000);
454 checkToRaw(converter, (uint64_t)0x55555, 0x00000055);
455 checkToRaw(converter, (uint64_t)0x5555555555555, 0X7FFFFFFF);
456}
457
458BOOST_AUTO_TEST_CASE(testUInt32_fractionMinus12) {
459 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable32minus12unsigned", 32, -12,
460 false); // 32 bits, -12 fractional bits, not
461 // signed
462
463 checkToCooked(converter, 0xAAAAAAAA, HEX_TO_DOUBLE(0xAAAAAAAA) * pow(2, 12));
464 checkToCooked(converter, 0x55555555, HEX_TO_DOUBLE(0x55555555) * pow(2, 12));
465 checkToCookedOverflowPos<int>(converter, 0x000AAAAA);
466 checkToCooked(converter, 0x00055555, (int)0x55555000);
467 checkToCooked(converter, 0x00055555, (unsigned int)0x55555000);
468 checkToCooked(converter, 0x000AAAAA, (unsigned int)0xAAAAA000);
469 checkToCookedOverflowPos<unsigned short>(converter, 0x000AAAAA);
470 checkToCooked(converter, 0x00055555, (int64_t)0x55555000);
471 checkToCooked(converter, 0x000AAAAA, (int64_t)0xAAAAA000);
472 checkToCooked(converter, 0xAAAAAAAA, (int64_t)0xAAAAAAAA000);
473 checkToCooked(converter, 0x00055555, (uint64_t)0x55555000);
474 checkToCooked(converter, 0xAAAAAAAA, (uint64_t)0xAAAAAAAA000);
475
476 checkToRaw(converter, 0.25, 0);
477 checkToRaw(converter, -0.25, 0);
478 checkToRaw(converter, 0.75, 0);
479 checkToRaw(converter, -0.75, 0);
480 checkToRaw(converter, 3.25, 0);
481 checkToRaw(converter, -3.25, 0);
482 checkToRaw(converter, 5.75, 0);
483 checkToRaw(converter, -5.75, 0);
484
485 checkToRaw(converter, (int)0x55555555, 0x00055555);
486 checkToRaw(converter, (int)0xAAAAAAAA, 0);
487 checkToRaw(converter, (unsigned int)0x55555555, 0x00055555);
488 checkToRaw(converter, (unsigned int)0xAAAAAAAA, 0x000AAAAB);
489 checkToRaw(converter, (short)0x5555, 0x00000005);
490 checkToRaw(converter, (short)0xAAAA, 0);
491 checkToRaw(converter, (unsigned short)0x5555, 0x00000005);
492 checkToRaw(converter, (unsigned short)0xAAAA, 0x0000000B);
493 checkToRaw(converter, (int64_t)0x55555555, 0x00055555);
494 checkToRaw(converter, static_cast<int64_t>(static_cast<int32_t>(0xAAAAAAAA)), 0x0);
495 checkToRaw(converter, (int64_t)0x5555555555555, 0xFFFFFFFF); // full range
496 checkToRaw(converter, (uint64_t)0x55555, 0x00000055);
497 checkToRaw(converter, (uint64_t)0x5555555555555, 0XFFFFFFFF);
498}
499
500BOOST_AUTO_TEST_CASE(testInt32_fractionMinus1) {
501 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable32minus1signed", 32,
502 -1); // 32 bits, -1 fractional bits, signed
503
504 checkToCooked(converter, 0xAAAAAAAA, SIGNED_HEX_TO_DOUBLE(0xAAAAAAAA) * 2);
505 checkToCooked(converter, 0x55555555, SIGNED_HEX_TO_DOUBLE(0x55555555) * 2);
506 checkToCookedOverflowNeg<int>(converter, 0xAAAAAAAA);
507 checkToCookedOverflowPos<int>(converter, 0x55555555);
508 checkToCooked(converter, 0x22222202, (int)0x44444404);
509 checkToCookedOverflowNeg<unsigned int>(converter, 0xAAAAAAAA);
510 checkToCooked(converter, 0x55555555, (unsigned int)0xAAAAAAAA);
511 checkToCooked(converter, 0x22222202, (unsigned int)0x44444404);
512 checkToCooked(converter, 0x7FFFFFFF, (unsigned int)0xFFFFFFFE);
513 checkToCooked(converter, 0xAAAAAAAA, (int64_t)0xFFFFFFFF55555554);
514
515 checkToRaw(converter, 0.25, 0);
516 checkToRaw(converter, -0.25, 0);
517 checkToRaw(converter, 0.75, 0);
518 checkToRaw(converter, -0.75, 0);
519
520 // bit pattern of 3 is 11, where the last digit is rounded up, and afterwards
521 // one bit is shifted. So the actual value is 4
522 checkToRaw(converter, 3.25, 0x2);
523 checkToRaw(converter, -3.25, 0xFFFFFFFE); // (-2)
524 checkToRaw(converter, 5.75, 0x3);
525 checkToRaw(converter, -5.75, 0xFFFFFFFD); // (-3)
526
527 checkToRaw(converter, (int)0x55555554, 0x2AAAAAAA);
528 checkToRaw(converter, (int)0x55555555, 0x2AAAAAAB);
529 checkToRaw(converter, (int)0x55555556, 0x2AAAAAAB);
530 checkToRaw(converter, (int)0xAAAAAAAA, 0xD5555555);
531 checkToRaw(converter, (unsigned int)0x55555555, 0x2AAAAAAB);
532 checkToRaw(converter, (unsigned int)0xAAAAAAAA, 0x55555555);
533 checkToRaw(converter, (short)0x5555, 0x00002AAB);
534 checkToRaw(converter, (short)0xAAAA, 0xFFFFD555);
535 checkToRaw(converter, (unsigned short)0x5555, 0x00002AAB);
536 checkToRaw(converter, (unsigned short)0xAAAA, 0x00005555);
537 checkToRaw(converter, static_cast<int64_t>(static_cast<int32_t>(0xAAAAAAAA)), 0xD5555555);
538 checkToRaw(converter, static_cast<uint64_t>(0xAAAAAAAA), 0x55555555);
539}
540
541BOOST_AUTO_TEST_CASE(testUInt32_fractionMinus1) {
542 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable32minus1unsigned", 32, -1,
543 false); // 32 bits, -1 fractional bits, not signed
544
545 checkToCooked(converter, 0xAAAAAAAA, HEX_TO_DOUBLE(0xAAAAAAAA) * 2);
546 checkToCooked(converter, 0x55555555, HEX_TO_DOUBLE(0x55555555) * 2);
547 checkToCooked(converter, 0x55555555, SIGNED_HEX_TO_DOUBLE(0x55555555) * 2);
548 checkToCooked(converter, 0x22222202, (int)0x44444404);
549 checkToCooked(converter, 0x55555555, (unsigned int)0xAAAAAAAA);
550 checkToCooked(converter, 0x22222202, (unsigned int)0x44444404);
551
552 checkToRaw(converter, 0.25, 0);
553 checkToRaw(converter, -0.25, 0);
554 checkToRaw(converter, 0.75, 0);
555 checkToRaw(converter, -0.75, 0);
556
557 // bit pattern of 3 is 11, where the last digit is rounded up, and afterwards
558 // one bit is shifted. So the actual value is 4
559 checkToRaw(converter, 3.25, 0x2);
560 checkToRaw(converter, -3.25, 0);
561 checkToRaw(converter, 5.75, 0x3);
562 checkToRaw(converter, -5.75, 0);
563
564 checkToRaw(converter, (int)0x55555555, 0x2AAAAAAB);
565 checkToRaw(converter, (int)0xAAAAAAAA, 0);
566 checkToRaw(converter, (unsigned int)0x55555555, 0x2AAAAAAB);
567 checkToRaw(converter, (unsigned int)0xAAAAAAAA, 0x55555555);
568 checkToRaw(converter, (short)0x5555, 0x00002AAB);
569 checkToRaw(converter, (short)0xAAAA, 0);
570 checkToRaw(converter, (unsigned short)0x5555, 0x00002AAB);
571 checkToRaw(converter, (unsigned short)0xAAAA, 0x00005555);
572}
573
574BOOST_AUTO_TEST_CASE(testInt16_fractionMinus1) {
575 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter(
576 "Variable16minus1signed", 16, -1); // 16 bits, -1 fractional bits, signed
577
578 checkToCooked(converter, 0xAAAAAAAA, SIGNED_HEX_TO_DOUBLE(0xFFFFAAAA) * 2);
579 checkToCooked(converter, 0x55555555, SIGNED_HEX_TO_DOUBLE(0x5555) * 2);
580 checkToCookedOverflowNeg<int16_t>(converter, 0xAAAAAAAA);
581 checkToCookedOverflowPos<int16_t>(converter, 0x55555555);
582 checkToCooked(converter, 0x22222202, (int)0x4404);
583 checkToCookedOverflowNeg<unsigned int>(converter, 0xAAAA);
584 checkToCooked(converter, 0x55555555, (unsigned int)0xAAAA);
585 checkToCooked(converter, 0x22222202, (unsigned int)0x4404);
586 checkToCooked(converter, 0x00007FFF, (unsigned int)0xFFFE);
587 checkToCooked(converter, 0xAAAAAAAA, (int64_t)0xFFFFFFFFFFFF5554);
588
589 checkToRaw(converter, 0.25, 0);
590 checkToRaw(converter, -0.25, 0);
591 checkToRaw(converter, 0.75, 0);
592 checkToRaw(converter, -0.75, 0);
593
594 // bit pattern of 3 is 11, where the last digit is rounded up, and afterwards
595 // one bit is shifted. So the actual value is 4
596 checkToRaw(converter, 3.25, 0x2);
597 checkToRaw(converter, -3.25, 0xFFFE); // (-2)
598 checkToRaw(converter, 5.75, 0x3);
599 checkToRaw(converter, -5.75, 0xFFFD); // (-3)
600
601 checkToRaw(converter, (int)0x5554, 0x2AAA);
602 checkToRaw(converter, (int)0x5555, 0x2AAB);
603 checkToRaw(converter, (int)0x5556, 0x2AAB);
604 checkToRaw(converter, (int)0xFFFFAAAA, 0xD555);
605 checkToRaw(converter, (unsigned int)0x5555, 0x2AAB);
606 checkToRaw(converter, (unsigned int)0xAAAA, 0x5555);
607 checkToRaw(converter, (short)0x5555, 0x00002AAB);
608 checkToRaw(converter, (short)0xAAAA, 0xD555);
609 checkToRaw(converter, (unsigned short)0x5555, 0x00002AAB);
610 checkToRaw(converter, (unsigned short)0xAAAA, 0x00005555);
611 checkToRaw(converter, static_cast<int64_t>(static_cast<int32_t>(0xFFFFAAAA)), 0xD555);
612 checkToRaw(converter, static_cast<uint64_t>(0xAAAA), 0x5555);
613}
614
615BOOST_AUTO_TEST_CASE(testUInt16_fractionMinus1) {
616 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter(
617 "Variable16minus1unsigned", 16, -1, false); // 16 bits, -1 fractional bits, not signed
618
619 checkToCooked(converter, 0xAAAAAAAA, HEX_TO_DOUBLE(0xAAAA) * 2);
620 checkToCooked(converter, 0x55555555, HEX_TO_DOUBLE(0x5555) * 2);
621 checkToCooked(converter, 0x55555555, SIGNED_HEX_TO_DOUBLE(0x5555) * 2);
622 checkToCooked(converter, 0x22222202, (int)0x4404);
623 checkToCooked(converter, 0x55555555, (unsigned int)0xAAAA);
624 checkToCooked(converter, 0x22222202, (unsigned int)0x4404);
625
626 checkToRaw(converter, 0.25, 0);
627 checkToRaw(converter, -0.25, 0);
628 checkToRaw(converter, 0.75, 0);
629 checkToRaw(converter, -0.75, 0);
630
631 // bit pattern of 3 is 11, where the last digit is rounded up, and afterwards
632 // one bit is shifted. So the actual value is 4
633 checkToRaw(converter, 3.25, 0x2);
634 checkToRaw(converter, -3.25, 0);
635 checkToRaw(converter, 5.75, 0x3);
636 checkToRaw(converter, -5.75, 0);
637
638 checkToRaw(converter, (int)0x5555, 0x2AAB);
639 checkToRaw(converter, (int)0xFFFFAAAA, 0);
640 checkToRaw(converter, (unsigned int)0x5555, 0x2AAB);
641 checkToRaw(converter, (unsigned int)0xAAAA, 0x5555);
642 checkToRaw(converter, (short)0x5555, 0x00002AAB);
643 checkToRaw(converter, (short)0xAAAA, 0);
644 checkToRaw(converter, (unsigned short)0x5555, 0x00002AAB);
645 checkToRaw(converter, (unsigned short)0xAAAA, 0x00005555);
646}
647
648BOOST_AUTO_TEST_CASE(testInt32_fraction1) {
649 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable32plus1signed", 32,
650 1); // 32 bits, 1 fractional bit, signed
651
652 checkToCooked(converter, 0xAAAAAAAA, SIGNED_HEX_TO_DOUBLE(0xAAAAAAAA) * 0.5);
653 checkToCooked(converter, 0x55555555, SIGNED_HEX_TO_DOUBLE(0x55555555) * 0.5);
654 checkToCooked(converter, 0xAAAAAAA9, (int)0xD5555554);
655 checkToCooked(converter, 0xAAAAAAAA, (int)0xD5555555);
656 checkToCooked(converter, 0xAAAAAAAB, (int)0xD5555555);
657 checkToCooked(converter, 0xFFFFFE11, (int)0xFFFFFF08);
658 checkToCooked(converter, 0x55555554, (int)0x2AAAAAAA);
659 checkToCooked(converter, 0x55555555, (int)0x2AAAAAAB);
660 checkToCooked(converter, 0x55555556, (int)0x2AAAAAAB);
661 checkToCooked(converter, 0x22222202, (int)0x11111101);
662 checkToCooked(converter, 0x55555555, (unsigned int)0x2AAAAAAB);
663 checkToCooked(converter, 0x22222202, (unsigned int)0x11111101);
664 checkToCooked(converter, 0xAAAAAAAA, (int64_t)0xFFFFFFFFD5555555);
665 checkToCooked(converter, 0x55555555, (int64_t)0x2AAAAAAB);
666
667 checkToRaw(converter, 0.25, 0x1);
668 checkToRaw(converter, -0.25, 0xFFFFFFFF);
669 checkToRaw(converter, 0.75, 0x2);
670 checkToRaw(converter, -0.75, 0xFFFFFFFE);
671
672 checkToRaw(converter, 3.25, 0x7);
673 checkToRaw(converter, -3.25, 0xFFFFFFF9); // (-7)
674 checkToRaw(converter, 5.75, 0xC);
675 checkToRaw(converter, -5.75, 0xFFFFFFF4); // (-12)
676
677 checkToRaw(converter, (int)0x55555555, 0x7FFFFFFF);
678 checkToRaw(converter, (int)0xAAAAAAAA, 0x80000000);
679 checkToRaw(converter, (int)0x22222202, 0x44444404);
680 checkToRaw(converter, (int)0xE2222202, 0xC4444404);
681 checkToRaw(converter, (unsigned int)0x55555555, 0x7FFFFFFF);
682 checkToRaw(converter, (unsigned int)0xAAAAAAAA, 0x7FFFFFFF);
683 checkToRaw(converter, (unsigned int)0x22222202, 0x44444404);
684 checkToRaw(converter, (unsigned int)0xE2222202, 0x7FFFFFFF);
685 checkToRaw(converter, (short)0x5555, 0x0000AAAA);
686 checkToRaw(converter, (short)0xAAAA, 0xFFFF5554);
687 checkToRaw(converter, (unsigned short)0x5555, 0x0000AAAA);
688 checkToRaw(converter, (unsigned short)0xAAAA, 0x00015554);
689 checkToRaw(converter, static_cast<int64_t>(static_cast<int32_t>(0xFAAAAAAA)), 0XF5555554);
690 checkToRaw(converter, static_cast<uint64_t>(0xAAAAAAA), 0X15555554);
691}
692
693BOOST_AUTO_TEST_CASE(testUInt32_fraction1) {
694 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable32plus1unsigned", 32, 1,
695 false); // 32 bits, 1 fractional bit, not signed
696
697 checkToCooked(converter, 0xAAAAAAAA, HEX_TO_DOUBLE(0xAAAAAAAA) * 0.5);
698 checkToCooked(converter, 0x55555555, HEX_TO_DOUBLE(0x55555555) * 0.5);
699 checkToCooked(converter, 0xAAAAAAAA, (int)0x55555555);
700 checkToCooked(converter, 0x55555555, (int)0x2AAAAAAB);
701 checkToCooked(converter, 0x22222202, (int)0x11111101);
702 checkToCooked(converter, 0xAAAAAAAA, (unsigned int)0x55555555);
703 checkToCooked(converter, 0x55555555, (unsigned int)0x2AAAAAAB);
704 checkToCooked(converter, 0x22222202, (unsigned int)0x11111101);
705 checkToCooked(converter, 0xAAAAAAAA, (int64_t)0x55555555);
706 checkToCooked(converter, 0x55555555, (int64_t)0x2AAAAAAB);
707
708 checkToRaw(converter, 0.25, 0x1);
709 checkToRaw(converter, -0.25, 0x0);
710 checkToRaw(converter, 0.75, 0x2);
711 checkToRaw(converter, -0.75, 0x0);
712
713 checkToRaw(converter, 3.25, 0x7);
714 checkToRaw(converter, -3.25, 0x0);
715 checkToRaw(converter, 5.75, 0xC);
716 checkToRaw(converter, -5.75, 0x0);
717
718 checkToRaw(converter, (int)0x55555555, 0xAAAAAAAA);
719 checkToRaw(converter, (int)0xAAAAAAAA, 0);
720 checkToRaw(converter, (int)0x22222202, 0x44444404);
721 checkToRaw(converter, (int)0xE2222202, 0);
722 checkToRaw(converter, (unsigned int)0x55555555, 0xAAAAAAAA);
723 checkToRaw(converter, (unsigned int)0xAAAAAAAA, 0xFFFFFFFF);
724 checkToRaw(converter, (unsigned int)0x22222202, 0x44444404);
725 checkToRaw(converter, (unsigned int)0xE2222202, 0xFFFFFFFF);
726 checkToRaw(converter, (short)0x5555, 0x0000AAAA);
727 checkToRaw(converter, (short)0xAAAA, 0);
728 checkToRaw(converter, (unsigned short)0x5555, 0x0000AAAA);
729 checkToRaw(converter, (unsigned short)0xAAAA, 0x00015554);
730 checkToRaw(converter, static_cast<int64_t>(static_cast<int32_t>(0xFAAAAAAA)), 0x0);
731 checkToRaw(converter, static_cast<uint64_t>(0xFAAAAAAA), 0XFFFFFFFF);
732}
733
734BOOST_AUTO_TEST_CASE(testInt32_fraction7) {
735 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable32plus7signed", 32,
736 7); // 32 bits, 7 fractional bits, signed
737
738 checkToCooked(converter, 0xAAAAAAAA, SIGNED_HEX_TO_DOUBLE(0xAAAAAAAA) * pow(2, -7));
739 checkToCooked(converter, 0x55555555, SIGNED_HEX_TO_DOUBLE(0x55555555) * pow(2, -7));
740 checkToCooked(converter, 0xAAAAAA20, (int)0xFF555554);
741 checkToCooked(converter, 0xAAAAAA60, (int)0xFF555555);
742 checkToCooked(converter, 0xAAAAAA80, (int)0xFF555555);
743 checkToCooked(converter, 0xAAAAAAAA, (int)0xFF555555);
744 checkToCooked(converter, 0xAAAAAAC0, (int)0xFF555555);
745 checkToCooked(converter, 0xAAAAAAD0, (int)0xFF555556);
746 checkToCooked(converter, 0xAAAAAAFF, (int)0xFF555556);
747 checkToCooked(converter, 0x5555553F, (int)0x00AAAAAA);
748 checkToCooked(converter, 0x55555540, (int)0x00AAAAAB);
749 checkToCooked(converter, 0x555555BF, (int)0x00AAAAAB);
750 checkToCooked(converter, 0x555555C0, (int)0x00AAAAAC);
751 checkToCooked(converter, 0x22220222, (int)0x00444404);
752 checkToCooked(converter, 0x55555555, (unsigned int)0x00AAAAAB);
753 checkToCooked(converter, 0x22220222, (unsigned int)0x00444404);
754
755 checkToRaw(converter, 0.25, 0x20);
756 checkToRaw(converter, -0.25, 0xFFFFFFE0);
757 checkToRaw(converter, 0.75, 0x60);
758 checkToRaw(converter, -0.75, 0xFFFFFFA0);
759
760 checkToRaw(converter, 3.25, 0x1A0);
761 checkToRaw(converter, -3.25, 0xFFFFFE60);
762 checkToRaw(converter, 5.75, 0x2E0);
763 checkToRaw(converter, -5.75, 0xFFFFFD20);
764
765 checkToRaw(converter, (int)0x55555555, 0x7FFFFFFF);
766 checkToRaw(converter, (int)0xAAAAAAAA, 0x80000000);
767 checkToRaw(converter, (int)0x00888808, 0x44440400);
768 checkToRaw(converter, (int)0xFF888808, 0xC4440400);
769 checkToRaw(converter, (unsigned int)0x55555555, 0x7FFFFFFF);
770 checkToRaw(converter, (unsigned int)0xAAAAAAAA, 0x7FFFFFFF);
771 checkToRaw(converter, (unsigned int)0x00888808, 0x44440400);
772 checkToRaw(converter, (unsigned int)0xFF888808, 0x7FFFFFFF);
773 checkToRaw(converter, (short)0x5555, 0x002AAA80);
774 checkToRaw(converter, (short)0xAAAA, 0xFFD55500);
775 checkToRaw(converter, (unsigned short)0x5555, 0x002AAA80);
776 checkToRaw(converter, (unsigned short)0xAAAA, 0x00555500);
777
778 checkToCooked(converter, 0x20, std::string("0.250000"));
779 checkToRaw(converter, std::string("0.25"), 0x20);
780}
781
782BOOST_AUTO_TEST_CASE(testUInt32_fraction7) {
783 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable32plus7unsigned", 32, 7,
784 false); // 32 bits, -7 fractional bits, not signed
785
786 checkToCooked(converter, 0xAAAAAAAA, HEX_TO_DOUBLE(0xAAAAAAAA) * pow(2, -7));
787 checkToCooked(converter, 0x55555555, HEX_TO_DOUBLE(0x55555555) * pow(2, -7));
788 checkToCooked(converter, 0xAAAAAAAA, (int)0x01555555);
789 checkToCooked(converter, 0x55555555, (int)0x00AAAAAB);
790 checkToCooked(converter, 0x22220222, (int)0x00444404);
791 checkToCooked(converter, 0xAAAAAAAA, (unsigned int)0x01555555);
792 checkToCooked(converter, 0x55555555, (unsigned int)0x00AAAAAB);
793 checkToCooked(converter, 0x22220222, (unsigned int)0x00444404);
794
795 checkToRaw(converter, 0.25, 0x20);
796 checkToRaw(converter, -0.25, 0x0);
797 checkToRaw(converter, 0.75, 0x60);
798 checkToRaw(converter, -0.75, 0x0);
799
800 checkToRaw(converter, 3.25, 0x1A0);
801 checkToRaw(converter, -3.25, 0x0);
802 checkToRaw(converter, 5.75, 0x2E0);
803 checkToRaw(converter, -5.75, 0x0);
804
805 checkToRaw(converter, (int)0x55555555, 0xFFFFFFFF);
806 checkToRaw(converter, (int)0xAAAAAAAA, 0);
807 checkToRaw(converter, (int)0x00888808, 0x44440400);
808 checkToRaw(converter, (int)0xFF888808, 0);
809 checkToRaw(converter, (unsigned int)0x55555555, 0xFFFFFFFF);
810 checkToRaw(converter, (unsigned int)0xAAAAAAAA, 0xFFFFFFFF);
811 checkToRaw(converter, (unsigned int)0x00888808, 0x44440400);
812 checkToRaw(converter, (unsigned int)0xFF888808, 0xFFFFFFFF);
813 checkToRaw(converter, (short)0x5555, 0x002AAA80);
814 checkToRaw(converter, (short)0xAAAA, 0);
815 checkToRaw(converter, (unsigned short)0x5555, 0x002AAA80);
816 checkToRaw(converter, (unsigned short)0xAAAA, 0x00555500);
817}
818
819BOOST_AUTO_TEST_CASE(testInt32_fraction31) {
820 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable32plus31signed", 32,
821 31); // 32 bits, 31 fractional bits, signed
822
823 checkToCooked(converter, 0xAAAAAAAA, SIGNED_HEX_TO_DOUBLE(0xAAAAAAAA) * pow(2, -31));
824 checkToCooked(converter, 0x55555555, SIGNED_HEX_TO_DOUBLE(0x55555555) * pow(2, -31));
825 checkToCooked(converter, 0xAAAAAAAA, (int)-1);
826 checkToCooked(converter, 0x55555555, (int)1);
827 checkToCooked(converter, 0x22220222, (int)0);
828 checkToCookedOverflowNeg<unsigned int>(converter, 0xAAAAAAAA);
829 checkToCooked(converter, 0x55555555, (unsigned int)1);
830 checkToCooked(converter, 0x22220222, (unsigned int)0);
831 checkToCooked(converter, 0xAAAAAAAA, (short)-1);
832 checkToCooked(converter, 0x55555555, (short)1);
833 checkToCookedOverflowNeg<unsigned short>(converter, 0xAAAAAAAA);
834 checkToCooked(converter, 0x55555555, (unsigned short)1);
835
836 checkToRaw(converter, 0.25, 0x20000000);
837 checkToRaw(converter, -0.25, 0xE0000000);
838 checkToRaw(converter, 0.75, 0x60000000);
839 checkToRaw(converter, -0.75, 0xA0000000);
840
841 // these values are out of range
842 checkToRaw(converter, 3.25, 0x7FFFFFFF);
843 checkToRaw(converter, -3.25, 0x80000000);
844 checkToRaw(converter, 5.75, 0x7FFFFFFF);
845 checkToRaw(converter, -5.75, 0x80000000);
846
847 checkToCooked(converter, 0xA0000000, -0.75);
848 checkToCooked(converter, 0x60000000, 0.75);
849 checkToCooked(converter, 0xE0000000, -0.25);
850 checkToCooked(converter, 0x20000000, 0.25);
851
852 checkToRaw(converter, (int)0x55555555, 0x7FFFFFFF);
853 checkToRaw(converter, (int)0xAAAAAAAA, 0x80000000);
854 checkToRaw(converter, (int)0, 0);
855 checkToRaw(converter, (int)-1, 0x80000000);
856 checkToRaw(converter, (unsigned int)0x55555555, 0x7FFFFFFF);
857 checkToRaw(converter, (short)0x5555, 0x7FFFFFFF);
858 checkToRaw(converter, (short)0xAAAA, 0x80000000);
859 checkToRaw(converter, (short)-1, 0x80000000);
860 checkToRaw(converter, (unsigned short)0x5555, 0x7FFFFFFF);
861}
862
863BOOST_AUTO_TEST_CASE(testUInt32_fraction31) {
864 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable32plus31unsigned", 32, 31,
865 false); // 32 bits, 31 fractional bits, not signed
866
867 checkToCooked(converter, 0xAAAAAAAA, HEX_TO_DOUBLE(0xAAAAAAAA) * pow(2, -31));
868 checkToCooked(converter, 0x55555555, HEX_TO_DOUBLE(0x55555555) * pow(2, -31));
869 checkToCooked(converter, 0xAAAAAAAA, (int)1);
870 checkToCooked(converter, 0x55555555, (int)1);
871 checkToCooked(converter, 0x22220222, (int)0);
872 checkToCooked(converter, 0xAAAAAAAA, (unsigned int)1);
873 checkToCooked(converter, 0x55555555, (unsigned int)1);
874 checkToCooked(converter, 0x22220222, (unsigned int)0);
875 checkToCooked(converter, 0xAAAAAAAA, (short)1);
876 checkToCooked(converter, 0x55555555, (short)1);
877 checkToCooked(converter, 0xAAAAAAAA, (unsigned short)1);
878 checkToCooked(converter, 0x55555555, (unsigned short)1);
879
880 checkToRaw(converter, 0.25, 0x20000000);
881 checkToRaw(converter, -0.25, 0x0);
882 checkToRaw(converter, 0.75, 0x60000000);
883 checkToRaw(converter, -0.75, 0x0);
884
885 // these values are out of range
886 checkToRaw(converter, 3.25, 0xFFFFFFFF);
887 checkToRaw(converter, -3.25, 0x0);
888 checkToRaw(converter, 5.75, 0xFFFFFFFF);
889 checkToRaw(converter, -5.75, 0x0);
890
891 checkToCooked(converter, 0xA0000000, 1.25);
892 checkToCooked(converter, 0x60000000, 0.75);
893 checkToCooked(converter, 0xE0000000, 1.75);
894 checkToCooked(converter, 0x20000000, 0.25);
895
896 checkToRaw(converter, (int)0x55555555, 0xFFFFFFFF);
897 checkToRaw(converter, (int)0xAAAAAAAA, 0);
898 checkToRaw(converter, (int)1, 0x80000000);
899 checkToRaw(converter, (unsigned int)0x55555555, 0xFFFFFFFF);
900 checkToRaw(converter, (unsigned int)1, 0x80000000);
901 checkToRaw(converter, (short)0x5555, 0xFFFFFFFF);
902 checkToRaw(converter, (short)0xAAAA, 0);
903 checkToRaw(converter, (short)1, 0x80000000);
904 checkToRaw(converter, (unsigned short)0x5555, 0xFFFFFFFF);
905 checkToRaw(converter, (unsigned short)1, 0x80000000);
906}
907
908BOOST_AUTO_TEST_CASE(testInt32_fraction32) {
909 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable32plus32signed", 32,
910 32); // 32 bits, 32 fractional bits, signed
911
912 checkToCooked(converter, 0xAAAAAAAA, SIGNED_HEX_TO_DOUBLE(0xAAAAAAAA) * pow(2, -32));
913 checkToCooked(converter, 0x55555555, SIGNED_HEX_TO_DOUBLE(0x55555555) * pow(2, -32));
914 checkToCooked(converter, 0xAAAAAAAA, (int)0);
915 checkToCooked(converter, 0x55555555, (int)0);
916 checkToCooked(converter, 0xAAAAAAAA, (unsigned int)0);
917 checkToCooked(converter, 0x55555555, (unsigned int)0);
918 checkToCooked(converter, 0xAAAAAAAA, (short)0);
919 checkToCooked(converter, 0x55555555, (short)0);
920 checkToCooked(converter, 0xAAAAAAAA, (unsigned short)0);
921 checkToCooked(converter, 0x55555555, (unsigned short)0);
922
923 checkToRaw(converter, 0.25, 0x40000000, "ToRaw1");
924 checkToRaw(converter, -0.25, 0xC0000000, "ToRaw2");
925
926 // these values are out of range
927 checkToRaw(converter, 0.75, 0x7FFFFFFF, "ToRaw3");
928 checkToRaw(converter, -0.75, 0x80000000, "ToRaw4");
929 checkToRaw(converter, 3.25, 0x7FFFFFFF, "ToRaw5");
930 checkToRaw(converter, -3.25, 0x80000000, "ToRaw6");
931 checkToRaw(converter, 5.75, 0x7FFFFFFF, "ToRaw7");
932 checkToRaw(converter, -5.75, 0x80000000, "ToRaw8");
933
934 checkToCooked(converter, 0x40000000, 0.25);
935 checkToCooked(converter, 0xC0000000, -0.25);
936
937 checkToRaw(converter, (int)0x55555555, 0x7FFFFFFF, "ToRaw9");
938 checkToRaw(converter, (int)0xAAAAAAAA, 0x80000000, "ToRaw10");
939 checkToRaw(converter, (int)0, 0, "ToRaw11");
940 checkToRaw(converter, (int)1, 0x7FFFFFFF, "ToRaw12");
941 checkToRaw(converter, (int)-1, 0x80000000, "ToRaw13");
942 // checkToRaw( converter, (unsigned int)0x55555555, 0x7FFFFFFF );
943 checkToRaw(converter, (short)0x5555, 0x7FFFFFFF);
944 checkToRaw(converter, (short)0xAAAA, 0x80000000, "ToRaw14");
945 checkToRaw(converter, (short)-1, 0x80000000, "ToRaw15");
946 // checkToRaw( converter, (unsigned short)0x5555, 0x7FFFFFFF );
947}
948
949BOOST_AUTO_TEST_CASE(testUInt32_fraction32) {
950 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable32plus32unsigned", 32, 32,
951 false); // 32 bits, 32 fractional bits, not signed
952
953 checkToCooked(converter, 0xAAAAAAAA, HEX_TO_DOUBLE(0xAAAAAAAA) * pow(2, -32));
954 checkToCooked(converter, 0x55555555, HEX_TO_DOUBLE(0x55555555) * pow(2, -32));
955 checkToCooked(converter, 0xAAAAAAAA, (int)1);
956 checkToCooked(converter, 0x55555555, (int)0);
957 checkToCooked(converter, 0xAAAAAAAA, (unsigned int)1);
958 checkToCooked(converter, 0x55555555, (unsigned int)0);
959 checkToCooked(converter, 0xAAAAAAAA, (short)1);
960 checkToCooked(converter, 0x55555555, (short)0);
961 checkToCooked(converter, 0xAAAAAAAA, (unsigned short)1);
962 checkToCooked(converter, 0x55555555, (unsigned short)0);
963
964 checkToRaw(converter, 0.25, 0x40000000);
965 checkToRaw(converter, -0.25, 0x0);
966 checkToRaw(converter, 0.75, 0xC0000000);
967 checkToRaw(converter, -0.75, 0x0);
968
969 // these values are out of range
970 checkToRaw(converter, 3.25, 0xFFFFFFFF);
971 checkToRaw(converter, -3.25, 0x0);
972 checkToRaw(converter, 5.75, 0xFFFFFFFF);
973 checkToRaw(converter, -5.75, 0x0);
974
975 checkToCooked(converter, 0x40000000, 0.25);
976 checkToCooked(converter, 0xC0000000, 0.75);
977
978 checkToRaw(converter, (int)0x55555555, 0xFFFFFFFF);
979 checkToRaw(converter, (int)0xAAAAAAAA, 0);
980 checkToRaw(converter, (int)0, 0);
981 checkToRaw(converter, (int)-1, 0);
982 checkToRaw(converter, (unsigned int)0x55555555, 0xFFFFFFFF);
983 checkToRaw(converter, (short)0x5555, 0xFFFFFFFF);
984 checkToRaw(converter, (short)0xAAAA, 0);
985 checkToRaw(converter, (short)-1, 0);
986 checkToRaw(converter, (unsigned short)0x5555, 0xFFFFFFFF);
987}
988
989BOOST_AUTO_TEST_CASE(testInt32_fraction43) {
990 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable32plus43signed", 32,
991 43); // 32 bits, 43 fractional bits, signed
992
993 checkToCooked(converter, 0xAAAAAAAA, SIGNED_HEX_TO_DOUBLE(0xAAAAAAAA) * pow(2, -43));
994 checkToCooked(converter, 0x55555555, SIGNED_HEX_TO_DOUBLE(0x55555555) * pow(2, -43));
995 checkToCooked(converter, 0xAAAAAAAA, (int)0);
996 checkToCooked(converter, 0x55555555, (int)0);
997 checkToCooked(converter, 0xAAAAAAAA, (unsigned int)0);
998 checkToCooked(converter, 0x55555555, (unsigned int)0);
999 checkToCooked(converter, 0xAAAAAAAA, (short)0);
1000 checkToCooked(converter, 0x55555555, (short)0);
1001 checkToCooked(converter, 0xAAAAAAAA, (unsigned short)0);
1002 checkToCooked(converter, 0x55555555, (unsigned short)0);
1003 checkToCooked(converter, 0x555, (int64_t)0);
1004 checkToCooked(converter, 0x555, (uint64_t)0);
1005
1006 // all out of range
1007 checkToRaw(converter, 0.25, 0x7FFFFFFF);
1008 checkToRaw(converter, -0.25, 0x80000000);
1009 checkToRaw(converter, 0.75, 0x7FFFFFFF);
1010 checkToRaw(converter, -0.75, 0x80000000);
1011
1012 checkToRaw(converter, 3.25, 0x7FFFFFFF);
1013 checkToRaw(converter, -3.25, 0x80000000);
1014 checkToRaw(converter, 5.75, 0x7FFFFFFF);
1015 checkToRaw(converter, -5.75, 0x80000000);
1016
1017 checkToRaw(converter, (int)0x55555555, 0x7FFFFFFF);
1018 checkToRaw(converter, (int)0xAAAAAAAA, 0x80000000);
1019 checkToRaw(converter, (int)0, 0);
1020 checkToRaw(converter, (int)-1, 0x80000000);
1021 checkToRaw(converter, (unsigned int)0x55555555, 0x7FFFFFFF);
1022 checkToRaw(converter, (short)0x5555, 0x7FFFFFFF);
1023 checkToRaw(converter, (short)0xAAAA, 0x80000000);
1024 checkToRaw(converter, (short)-1, 0x80000000);
1025 checkToRaw(converter, (unsigned short)0x5555, 0x7FFFFFFF);
1026 checkToRaw(converter, (int64_t)0xFFFFFFFAAAAAAAAA, 0x80000000);
1027 checkToRaw(converter, (uint64_t)0xAAAAAAAAA, 0x7FFFFFFF);
1028}
1029
1030BOOST_AUTO_TEST_CASE(testUInt32_fraction43) {
1031 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable32plus43unsigned", 32, 43,
1032 false); // 32 bits, 43 fractional bits, not signed
1033
1034 checkToCooked(converter, 0xAAAAAAAA, HEX_TO_DOUBLE(0xAAAAAAAA) * pow(2, -43));
1035 checkToCooked(converter, 0x55555555, HEX_TO_DOUBLE(0x55555555) * pow(2, -43));
1036 checkToCooked(converter, 0xAAAAAAAA, (int)0);
1037 checkToCooked(converter, 0x55555555, (int)0);
1038 checkToCooked(converter, 0xAAAAAAAA, (unsigned int)0);
1039 checkToCooked(converter, 0x55555555, (unsigned int)0);
1040 checkToCooked(converter, 0xAAAAAAAA, (short)0);
1041 checkToCooked(converter, 0x55555555, (short)0);
1042 checkToCooked(converter, 0xAAAAAAAA, (unsigned short)0);
1043 checkToCooked(converter, 0x55555555, (unsigned short)0);
1044
1045 // all out of range
1046 checkToRaw(converter, 0.25, 0xFFFFFFFF);
1047 checkToRaw(converter, -0.25, 0x0);
1048 checkToRaw(converter, 0.75, 0xFFFFFFFF);
1049 checkToRaw(converter, -0.75, 0x0);
1050
1051 checkToRaw(converter, 3.25, 0xFFFFFFFF);
1052 checkToRaw(converter, -3.25, 0x0);
1053 checkToRaw(converter, 5.75, 0xFFFFFFFF);
1054 checkToRaw(converter, -5.75, 0x0);
1055
1056 checkToRaw(converter, (int)0x55555555, 0xFFFFFFFF);
1057 checkToRaw(converter, (int)0xAAAAAAAA, 0);
1058 checkToRaw(converter, (int)0, 0);
1059 checkToRaw(converter, (int)-1, 0);
1060 checkToRaw(converter, (unsigned int)0x55555555, 0xFFFFFFFF);
1061 checkToRaw(converter, (short)0x5555, 0xFFFFFFFF);
1062 checkToRaw(converter, (short)0xAAAA, 0);
1063 checkToRaw(converter, (short)-1, 0);
1064 checkToRaw(converter, (unsigned short)0x5555, 0xFFFFFFFF);
1065}
1066
1067BOOST_AUTO_TEST_CASE(testInt18_fractionMinus12) {
1068 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("int18_fractionMinus12", 18,
1069 -12); // 10 bits, -12 fractional bits, signed
1070
1071 checkToCooked(converter, 0x2AAAA, SIGNED_HEX_TO_DOUBLE(0xFFFEAAAA) * pow(2, 12));
1072 checkToCooked(converter, 0x15555, SIGNED_HEX_TO_DOUBLE(0x15555) * pow(2, 12));
1073
1074 // the converter should ignore bits which are not in the spec
1075 checkToCooked(converter, 0xAAAAAAAA, SIGNED_HEX_TO_DOUBLE(0xFFFEAAAA) * pow(2, 12));
1076 checkToCooked(converter, 0x55555555, SIGNED_HEX_TO_DOUBLE(0x15555) * pow(2, 12));
1077
1078 checkToCooked(converter, 0x2AAAA, (int)0xEAAAA000);
1079 checkToCooked(converter, 0x15555, (int)0x15555000);
1080 checkToCooked(converter, 0x15555, (unsigned int)0x15555000);
1081
1082 checkToRaw(converter, 0.25, 0);
1083 checkToRaw(converter, -0.25, 0);
1084 checkToRaw(converter, 0.75, 0);
1085 checkToRaw(converter, -0.75, 0);
1086
1087 checkToRaw(converter, 3.25, 0);
1088 checkToRaw(converter, -3.25, 0);
1089 checkToRaw(converter, 5.75, 0);
1090 checkToRaw(converter, -5.75, 0);
1091
1092 checkToRaw(converter, (int)0xEAAAA000, 0x2AAAA);
1093 checkToRaw(converter, (int)0x15555000, 0x15555);
1094 checkToRaw(converter, (unsigned int)0x15555000, 0x15555);
1095 checkToRaw(converter, (short)0xA000, 0x3FFFA);
1096 checkToRaw(converter, (short)0x5000, 0x00005);
1097 checkToRaw(converter, (unsigned short)0xA000, 0x0000A);
1098}
1099
1100BOOST_AUTO_TEST_CASE(testUInt18_fractionMinus12) {
1101 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable18minus12unsigned", 18, -12,
1102 false); // 10 bits, -12 fractional bits, not
1103 // signed
1104
1105 checkToCooked(converter, 0x2AAAA, HEX_TO_DOUBLE(0x2AAAA) * pow(2, 12));
1106 checkToCooked(converter, 0x15555, HEX_TO_DOUBLE(0x15555) * pow(2, 12));
1107
1108 // the converter should ignore bits which are not in the spec
1109 checkToCooked(converter, 0xAAAAAAAA, HEX_TO_DOUBLE(0x2AAAA) * pow(2, 12));
1110 checkToCooked(converter, 0x55555555, HEX_TO_DOUBLE(0x15555) * pow(2, 12));
1111
1112 checkToCooked(converter, 0x2AAAA, (int)0x2AAAA000);
1113 checkToCooked(converter, 0x15555, (int)0x15555000);
1114 checkToCooked(converter, 0x2AAAA, (unsigned int)0x2AAAA000);
1115 checkToCooked(converter, 0x15555, (unsigned int)0x15555000);
1116
1117 checkToRaw(converter, 0.25, 0);
1118 checkToRaw(converter, -0.25, 0);
1119 checkToRaw(converter, 0.75, 0);
1120 checkToRaw(converter, -0.75, 0);
1121
1122 checkToRaw(converter, 3.25, 0);
1123 checkToRaw(converter, -3.25, 0);
1124 checkToRaw(converter, 5.75, 0);
1125 checkToRaw(converter, -5.75, 0);
1126
1127 checkToRaw(converter, (int)0xEAAAA000, 0);
1128 checkToRaw(converter, (int)0x15555000, 0x15555);
1129 checkToRaw(converter, (unsigned int)0x15555000, 0x15555);
1130 checkToRaw(converter, (short)0xA000, 0);
1131 checkToRaw(converter, (short)0x5000, 0x00005);
1132 checkToRaw(converter, (unsigned short)0xA000, 0x0000A);
1133}
1134
1135BOOST_AUTO_TEST_CASE(testInt18_fraction0) {
1136 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable18minus12signed",
1137 18); // 18 bits, 0 fractional bits, signed
1138
1139 checkToCooked(converter, 0x2AAAA, SIGNED_HEX_TO_DOUBLE(0xFFFEAAAA));
1140 checkToCooked(converter, 0x15555, SIGNED_HEX_TO_DOUBLE(0x15555));
1141
1142 // the converter should ignore bits which are not in the spec
1143 checkToCooked(converter, 0xAAAAAAAA, SIGNED_HEX_TO_DOUBLE(0xFFFEAAAA));
1144 checkToCooked(converter, 0x55555555, SIGNED_HEX_TO_DOUBLE(0x15555));
1145
1146 checkToCooked(converter, 0x2AAAA, (int)0xFFFEAAAA);
1147 checkToCooked(converter, 0x15555, (int)0x15555);
1148 checkToCooked(converter, 0x15555, (unsigned int)0x15555);
1149
1150 checkToCooked(converter, 0x2AAAA, (int64_t)0xFFFFFFFFFFFEAAAA);
1151 checkToCooked(converter, 0x15555, (int64_t)0x15555);
1152 checkToCooked(converter, 0x15555, (uint64_t)0x15555);
1153
1154 checkToRaw(converter, 0.25, 0);
1155 checkToRaw(converter, -0.25, 0);
1156 checkToRaw(converter, 0.75, 1);
1157 checkToRaw(converter, -0.75, 0x3FFFF);
1158
1159 checkToRaw(converter, 3.25, 3);
1160 checkToRaw(converter, -3.25, 0x3FFFD);
1161 checkToRaw(converter, 5.75, 6);
1162 checkToRaw(converter, -5.75, 0x3FFFA);
1163
1164 checkToRaw(converter, (int)0xFFFEAAAA, 0x2AAAA);
1165 checkToRaw(converter, (int)0x00015555, 0x15555);
1166 checkToRaw(converter, (unsigned int)0x00015555, 0x15555);
1167 checkToRaw(converter, (short)0xA000, 0x3A000);
1168 checkToRaw(converter, (short)0x5000, 0x05000);
1169 checkToRaw(converter, (unsigned short)0xA000, 0x0A000);
1170
1171 checkToRaw(converter, (int64_t)0xFFFFFFFFFFFFA000, 0x3A000);
1172 checkToRaw(converter, (int64_t)0xA000, 0xA000);
1173 checkToRaw(converter, (uint64_t)0xA000, 0x0A000);
1174}
1175
1176BOOST_AUTO_TEST_CASE(testUInt18_fraction0) {
1177 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable18unsigned", 18, 0,
1178 false); // 10 bits, -12 fractional bits, not signed
1179
1180 checkToCooked(converter, 0x2AAAA, HEX_TO_DOUBLE(0x2AAAA));
1181 checkToCooked(converter, 0x15555, HEX_TO_DOUBLE(0x15555));
1182
1183 // the converter should ignore bits which are not in the spec
1184 checkToCooked(converter, 0xAAAAAAAA, HEX_TO_DOUBLE(0x2AAAA));
1185 checkToCooked(converter, 0x55555555, HEX_TO_DOUBLE(0x15555));
1186
1187 checkToCooked(converter, 0x2AAAA, (int)0x2AAAA);
1188 checkToCooked(converter, 0x15555, (int)0x15555);
1189 checkToCooked(converter, 0x2AAAA, (unsigned int)0x2AAAA);
1190 checkToCooked(converter, 0x15555, (unsigned int)0x15555);
1191
1192 checkToRaw(converter, 0.25, 0);
1193 checkToRaw(converter, -0.25, 0);
1194 checkToRaw(converter, 0.75, 1);
1195 checkToRaw(converter, -0.75, 0x0);
1196
1197 checkToRaw(converter, 3.25, 3);
1198 checkToRaw(converter, -3.25, 0x0);
1199 checkToRaw(converter, 5.75, 6);
1200 checkToRaw(converter, -5.75, 0x0);
1201
1202 checkToRaw(converter, (int)0xFFFEAAAA, 0);
1203 checkToRaw(converter, (int)0x00015555, 0x15555);
1204 checkToRaw(converter, (unsigned int)0x00015555, 0x15555);
1205 checkToRaw(converter, (short)0xA000, 0);
1206 checkToRaw(converter, (short)0x5000, 0x05000);
1207 checkToRaw(converter, (unsigned short)0xA000, 0x0A000);
1208}
1209
1210BOOST_AUTO_TEST_CASE(testInt18_fraction7) {
1211 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable18plus7signed", 18,
1212 7); // 18 bits, 7 fractional bits, signed
1213
1214 checkToCooked(converter, 0x2AAAA, SIGNED_HEX_TO_DOUBLE(0xFFFEAAAA) * pow(2, -7));
1215 checkToCooked(converter, 0x15555, SIGNED_HEX_TO_DOUBLE(0x15555) * pow(2, -7));
1216
1217 checkToCooked(converter, 0xAAAAAAAA, SIGNED_HEX_TO_DOUBLE(0xFFFEAAAA) * pow(2, -7));
1218 checkToCooked(converter, 0x55555555, SIGNED_HEX_TO_DOUBLE(0x15555) * pow(2, -7));
1219
1220 checkToCooked(converter, 0x2AAAA, (int)0xFFFFFD55);
1221 checkToCooked(converter, 0x15555, (int)0x02AB);
1222 checkToCooked(converter, 0x15555, (unsigned int)0x2AB);
1223
1224 checkToRaw(converter, 0.25, 0x20);
1225 checkToRaw(converter, -0.25, 0x3FFE0);
1226 checkToRaw(converter, 0.75, 0x60);
1227 checkToRaw(converter, -0.75, 0x3FFA0);
1228
1229 checkToRaw(converter, 3.25, 0x1A0);
1230 checkToRaw(converter, -3.25, 0x3FE60);
1231 checkToRaw(converter, 5.75, 0x2E0);
1232 checkToRaw(converter, -5.75, 0x3FD20);
1233
1234 checkToRaw(converter, (int)0xFFFFFD55, 0x2AA80);
1235 checkToRaw(converter, (int)0x02AA, 0x15500);
1236 checkToRaw(converter, (unsigned int)0x2AA, 0x15500);
1237 checkToRaw(converter, (short)0xFFAA, 0x3D500);
1238 checkToRaw(converter, (short)0x0055, 0x02A80);
1239 checkToRaw(converter, (unsigned short)0x0055, 0x02A80);
1240}
1241
1242BOOST_AUTO_TEST_CASE(testUInt18_fraction7) {
1243 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable18plus7unsigned", 18, 7,
1244 false); // 10 bits, -12 fractional bits, not signed
1245
1246 checkToCooked(converter, 0x2AAAA, HEX_TO_DOUBLE(0x2AAAA) * pow(2, -7));
1247 checkToCooked(converter, 0x15555, HEX_TO_DOUBLE(0x15555) * pow(2, -7));
1248
1249 checkToCooked(converter, 0xAAAAAAAA, HEX_TO_DOUBLE(0x2AAAA) * pow(2, -7));
1250 checkToCooked(converter, 0x55555555, HEX_TO_DOUBLE(0x15555) * pow(2, -7));
1251
1252 checkToCooked(converter, 0x2AAAA, (int)0x0555);
1253 checkToCooked(converter, 0x15555, (int)0x02AB);
1254 checkToCooked(converter, 0x2AAAA, (unsigned int)0x0555);
1255 checkToCooked(converter, 0x15555, (unsigned int)0x02AB);
1256 checkToCooked(converter, 0x2AAAA, (short)0x0555);
1257 checkToCooked(converter, 0x15555, (short)0x02AB);
1258 checkToCooked(converter, 0x2AAAA, (unsigned short)0x0555);
1259 checkToCooked(converter, 0x15555, (unsigned short)0x02AB);
1260
1261 checkToRaw(converter, 0.25, 0x20);
1262 checkToRaw(converter, -0.25, 0x0);
1263 checkToRaw(converter, 0.75, 0x60);
1264 checkToRaw(converter, -0.75, 0x0);
1265
1266 checkToRaw(converter, 3.25, 0x1A0);
1267 checkToRaw(converter, -3.25, 0x0);
1268 checkToRaw(converter, 5.75, 0x2E0);
1269 checkToRaw(converter, -5.75, 0x0);
1270
1271 checkToRaw(converter, (int)0x0555, 0x2AA80);
1272 checkToRaw(converter, (int)0x02AA, 0x15500);
1273 checkToRaw(converter, (unsigned int)0x02AA, 0x15500);
1274 checkToRaw(converter, (short)0xFFAA, 0);
1275 checkToRaw(converter, (short)0x0055, 0x02A80);
1276 checkToRaw(converter, (unsigned short)0x0055, 0x02A80);
1277}
1278
1279BOOST_AUTO_TEST_CASE(testInt18_fraction17) {
1280 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable18plus17signed", 18,
1281 17); // 18 bits, 17 fractional bits, signed
1282
1283 checkToCooked(converter, 0x2AAAA, SIGNED_HEX_TO_DOUBLE(0xFFFEAAAA) * pow(2, -17));
1284 checkToCooked(converter, 0x15555, SIGNED_HEX_TO_DOUBLE(0x15555) * pow(2, -17));
1285
1286 checkToCooked(converter, 0xAAAAAAAA, SIGNED_HEX_TO_DOUBLE(0xFFFEAAAA) * pow(2, -17));
1287 checkToCooked(converter, 0x55555555, SIGNED_HEX_TO_DOUBLE(0x15555) * pow(2, -17));
1288
1289 checkToRaw(converter, 0.25, 0x8000);
1290 checkToRaw(converter, -0.25, 0x38000);
1291 checkToRaw(converter, 0.75, 0x18000);
1292 checkToRaw(converter, -0.75, 0x28000);
1293
1294 // these values are out of range
1295 checkToRaw(converter, 3.25, 0x1FFFF);
1296 checkToRaw(converter, -3.25, 0x20000);
1297 checkToRaw(converter, 5.75, 0x1FFFF);
1298 checkToRaw(converter, -5.75, 0x20000);
1299}
1300
1301BOOST_AUTO_TEST_CASE(testUInt18_fraction17) {
1302 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable18plus17unsigned", 18, 17,
1303 false); // 18 bits, 17 fractional bits, not signed
1304
1305 checkToCooked(converter, 0x2AAAA, HEX_TO_DOUBLE(0x2AAAA) * pow(2, -17));
1306 checkToCooked(converter, 0x15555, HEX_TO_DOUBLE(0x15555) * pow(2, -17));
1307
1308 checkToCooked(converter, 0xAAAAAAAA, HEX_TO_DOUBLE(0x2AAAA) * pow(2, -17));
1309 checkToCooked(converter, 0x55555555, HEX_TO_DOUBLE(0x15555) * pow(2, -17));
1310
1311 checkToRaw(converter, 0.25, 0x8000);
1312 checkToRaw(converter, -0.25, 0x0);
1313 checkToRaw(converter, 0.75, 0x18000);
1314 checkToRaw(converter, -0.75, 0x0);
1315
1316 // these values are out of range
1317 checkToRaw(converter, 3.25, 0x3FFFF);
1318 checkToRaw(converter, -3.25, 0x0);
1319 checkToRaw(converter, 5.75, 0x3FFFF);
1320 checkToRaw(converter, -5.75, 0x0);
1321}
1322
1323BOOST_AUTO_TEST_CASE(testInt18_fraction18) {
1324 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable18plus18signed", 18,
1325 18); // 18 bits, 18 fractional bits, signed
1326
1327 checkToCooked(converter, 0x2AAAA, SIGNED_HEX_TO_DOUBLE(0xFFFEAAAA) * pow(2, -18));
1328 checkToCooked(converter, 0x15555, SIGNED_HEX_TO_DOUBLE(0x15555) * pow(2, -18));
1329
1330 checkToCooked(converter, 0xAAAAAAAA, SIGNED_HEX_TO_DOUBLE(0xFFFEAAAA) * pow(2, -18));
1331 checkToCooked(converter, 0x55555555, SIGNED_HEX_TO_DOUBLE(0x15555) * pow(2, -18));
1332
1333 checkToRaw(converter, 0.25, 0x10000);
1334 checkToRaw(converter, -0.25, 0x30000);
1335 // +- 0.75 are out of range
1336 checkToRaw(converter, 0.75,
1337 0x1FFFF); // the largest possible value (0.5 - 1e-18)
1338 checkToRaw(converter, -0.75, 0x20000); // -0.5, the smallest possible value
1339
1340 checkToCooked(converter, 0x10000, 0.25);
1341 checkToCooked(converter, 0x30000, -0.25);
1342
1343 // these values are out of range
1344 checkToRaw(converter, 3.25, 0x1FFFF);
1345 checkToRaw(converter, -3.25, 0x20000);
1346 checkToRaw(converter, 5.75, 0x1FFFF);
1347 checkToRaw(converter, -5.75, 0x20000);
1348}
1349
1350BOOST_AUTO_TEST_CASE(testUInt18_fraction18) {
1351 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable18plus18unsigned", 18, 18,
1352 false); // 10 bits, -12 fractional bits, not signed
1353
1354 checkToCooked(converter, 0x2AAAA, HEX_TO_DOUBLE(0x2AAAA) * pow(2, -18));
1355 checkToCooked(converter, 0x15555, HEX_TO_DOUBLE(0x15555) * pow(2, -18));
1356
1357 checkToCooked(converter, 0xAAAAAAAA, HEX_TO_DOUBLE(0x2AAAA) * pow(2, -18));
1358 checkToCooked(converter, 0x55555555, HEX_TO_DOUBLE(0x15555) * pow(2, -18));
1359
1360 checkToRaw(converter, 0.25, 0x10000);
1361 checkToRaw(converter, -0.25, 0x0);
1362 checkToRaw(converter, 0.75, 0x30000);
1363 checkToRaw(converter, -0.75, 0x0);
1364
1365 checkToCooked(converter, 0x10000, 0.25);
1366 checkToCooked(converter, 0x30000, 0.75);
1367
1368 checkToRaw(converter, 3.25, 0x3FFFF);
1369 checkToRaw(converter, -3.25, 0x0);
1370 checkToRaw(converter, 5.75, 0x3FFFF);
1371 checkToRaw(converter, -5.75, 0x0);
1372}
1373
1374BOOST_AUTO_TEST_CASE(testInt18_fraction43) {
1375 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("int18_fraction43", 18,
1376 43); // 18 bits, 43 fractional bits, signed
1377
1378 checkToCooked(converter, 0x2AAAA, SIGNED_HEX_TO_DOUBLE(0xFFFEAAAA) * pow(2, -43));
1379 checkToCooked(converter, 0x15555, SIGNED_HEX_TO_DOUBLE(0x15555) * pow(2, -43));
1380
1381 checkToCooked(converter, 0xAAAAAAAA, SIGNED_HEX_TO_DOUBLE(0xFFFEAAAA) * pow(2, -43));
1382 checkToCooked(converter, 0x55555555, SIGNED_HEX_TO_DOUBLE(0x15555) * pow(2, -43));
1383
1384 // all out of range
1385 checkToRaw(converter, 0.25, 0x1FFFF);
1386 checkToRaw(converter, -0.25, 0x20000);
1387 checkToRaw(converter, 0.75, 0x1FFFF);
1388 checkToRaw(converter, -0.75, 0x20000);
1389
1390 checkToRaw(converter, 3.25, 0x1FFFF);
1391 checkToRaw(converter, -3.25, 0x20000);
1392 checkToRaw(converter, 5.75, 0x1FFFF);
1393 checkToRaw(converter, -5.75, 0x20000);
1394}
1395
1396BOOST_AUTO_TEST_CASE(testUInt18_fraction43) {
1397 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("Variable18plus43unsigned", 18, 43,
1398 false); // 18 bits, -43 fractional bits, not signed
1399
1400 checkToCooked(converter, 0x2AAAA, HEX_TO_DOUBLE(0x2AAAA) * pow(2, -43));
1401 checkToCooked(converter, 0x15555, HEX_TO_DOUBLE(0x15555) * pow(2, -43));
1402
1403 checkToCooked(converter, 0xAAAAAAAA, HEX_TO_DOUBLE(0x2AAAA) * pow(2, -43));
1404 checkToCooked(converter, 0x55555555, HEX_TO_DOUBLE(0x15555) * pow(2, -43));
1405
1406 // all out of range
1407 checkToRaw(converter, 0.25, 0x3FFFF);
1408 checkToRaw(converter, -0.25, 0x0);
1409 checkToRaw(converter, 0.75, 0x3FFFF);
1410 checkToRaw(converter, -0.75, 0x0);
1411
1412 checkToRaw(converter, 3.25, 0x3FFFF);
1413 checkToRaw(converter, -3.25, 0x0);
1414 checkToRaw(converter, 5.75, 0x3FFFF);
1415 checkToRaw(converter, -5.75, 0x0);
1416}
1417
1418BOOST_AUTO_TEST_CASE(testGetters) {
1419 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> defaultConverter("default");
1420 BOOST_CHECK(defaultConverter.getNBits() == 32);
1421 BOOST_CHECK(defaultConverter.getFractionalBits() == 0);
1422 BOOST_CHECK(defaultConverter.isSigned() == true);
1423
1424 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> customConverter("custom", 13, 7, false);
1425 BOOST_CHECK(customConverter.getNBits() == 13);
1426 BOOST_CHECK(customConverter.getFractionalBits() == 7);
1427 BOOST_CHECK(customConverter.isSigned() == false);
1428}
1429
1430BOOST_AUTO_TEST_CASE(testInt32ToInt32) {
1431 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("int32toInt32"); // default parameters are signed 32 bit
1432
1433 checkToCooked(converter, 0, (int32_t)0);
1434 checkToCooked(converter, 1, (int32_t)1);
1435 checkToCooked(converter, 0xFFFFFFFF, (int32_t)-1);
1436 checkToCooked(converter, 3, (int32_t)3);
1437 checkToCooked(converter, 0xFFFFFFFD, (int32_t)-3);
1438 checkToCooked(converter, 6, (int32_t)6);
1439 checkToCooked(converter, 0xFFFFFFFA, (int32_t)-6);
1440 checkToCooked(converter, 0xAAAAAAAA, (int32_t)0xAAAAAAAA);
1441 checkToCooked(converter, 0x55555555, (int32_t)0x55555555);
1442
1443 checkToRaw(converter, 0, 0);
1444 checkToRaw(converter, 1, 1);
1445 checkToRaw(converter, -1, -1);
1446 checkToRaw(converter, 3, 3);
1447 checkToRaw(converter, -3, -3);
1448 checkToRaw(converter, 6, 6);
1449 checkToRaw(converter, -6, -6);
1450}
1451
1452BOOST_AUTO_TEST_CASE(testInt32ToInt16) {
1453 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("int32ToInt16"); // default constructor is signed 32 bit
1454
1455 checkToCooked(converter, 0, (int16_t)0);
1456 checkToCooked(converter, 1, (int16_t)1);
1457 checkToCooked(converter, 0xFFFFFFFF, (int16_t)-1);
1458 checkToCooked(converter, 3, (int16_t)3);
1459 checkToCooked(converter, 0xFFFFFFFD, (int16_t)-3);
1460 checkToCooked(converter, 6, (int16_t)6);
1461 checkToCooked(converter, 0xFFFFFFFA, (int16_t)-6);
1462 checkToCookedOverflowNeg<int16_t>(converter, 0xAAAAAAAA);
1463 checkToCookedOverflowPos<int16_t>(converter, 0x55555555);
1464
1465 checkToRaw(converter, (int16_t)0, 0);
1466 checkToRaw(converter, (int16_t)1, 1);
1467 checkToRaw(converter, (int16_t)-1, -1);
1468 checkToRaw(converter, (int16_t)3, 3);
1469 checkToRaw(converter, (int16_t)-3, -3);
1470 checkToRaw(converter, (int16_t)6, 6);
1471 checkToRaw(converter, (int16_t)-6, -6);
1472 checkToRaw(converter, (int16_t)0x7FFF, 0x7FFF);
1473 checkToRaw(converter, (int16_t)0x8000, 0xFFFF8000);
1474 checkToRaw(converter, (int16_t)0xFFFF, 0xFFFFFFFF);
1475}
1476
1477BOOST_AUTO_TEST_CASE(testInt18ToInt32) {
1478 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("int18ToInt32", 18, 0, true);
1479
1480 checkToCooked(converter, 0, 0);
1481 checkToCooked(converter, 1, 1);
1482 checkToCooked(converter, 0x3FFFF, -1);
1483 checkToCooked(converter, 3, 3);
1484 checkToCooked(converter, 0x3FFFD, -3);
1485 checkToCooked(converter, 6, 6);
1486 checkToCooked(converter, 0x3FFFA, -6);
1487 checkToCooked(converter, 0xFFFFFFFF, (int32_t)0xFFFFFFFF);
1488 checkToCooked(converter, 0xFFFFFFFE, (int32_t)0xFFFFFFFE);
1489 checkToCooked(converter, 0x55555555, (int32_t)0x15555);
1490
1491 checkToRaw(converter, (int32_t)0, 0);
1492 checkToRaw(converter, (int32_t)1, 1);
1493 checkToRaw(converter, (int32_t)-1, 0x3FFFF);
1494 checkToRaw(converter, (int32_t)3, 3);
1495 checkToRaw(converter, (int32_t)-3, 0x3FFFD);
1496 checkToRaw(converter, (int32_t)6, 6);
1497 checkToRaw(converter, (int32_t)-6, 0x3FFFA);
1498 checkToRaw(converter, (int32_t)0x1FFFF, 0x1FFFF);
1499 checkToRaw(converter, (int32_t)0x20000, 0x1FFFF);
1500 checkToRaw(converter, (int32_t)-1, 0x3FFFF);
1501 checkToRaw(converter, (int32_t)-0x20000, 0x20000);
1502}
1503
1504BOOST_AUTO_TEST_CASE(testIntSignedToUnsigned) {
1505 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter(
1506 "signedToUnsigned"); // default parameters are signed 32 bit
1507
1508 checkToCooked(converter, 0, (uint32_t)0);
1509 checkToCooked(converter, 1, (uint32_t)1);
1510 checkToCooked(converter, 3, (uint32_t)3);
1511 checkToCooked(converter, 6, (uint32_t)6);
1512 checkToCookedOverflowNeg<uint32_t>(converter, 0xFFFFFFFF);
1513 checkToCookedOverflowNeg<uint16_t>(converter, 0xFFFFFFFA);
1514 checkToCookedOverflowNeg<uint16_t>(converter, 0xAAAAAAAA);
1515 checkToCooked(converter, 0x55555555, (uint32_t)0x55555555);
1516
1517 checkToRaw(converter, (uint32_t)0, 0);
1518 checkToRaw(converter, (uint32_t)1, 1);
1519 checkToRaw(converter, (uint32_t)3, 3);
1520 checkToRaw(converter, (uint32_t)6, 6);
1521 checkToRaw(converter, (uint32_t)0x7FFFFFFF, 0x7FFFFFFF);
1522 checkToRaw(converter, (uint32_t)0x80000000, 0x7FFFFFFF);
1523 checkToRaw(converter, (uint32_t)0xFFFFFFFF, 0x7FFFFFFF);
1524}
1525
1526BOOST_AUTO_TEST_CASE(testInt17SignedToInt16Unsigned) {
1527 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("int17SignedToInt16Unsigned", 17, 0, true);
1528
1529 checkToCooked(converter, 0, (uint16_t)0);
1530 checkToCooked(converter, 1, (uint16_t)1);
1531 checkToCookedOverflowNeg<uint16_t>(converter, 0xFFFFFFFF);
1532 checkToCooked(converter, 3, (uint16_t)3);
1533 checkToCooked(converter, 6, (uint16_t)6);
1534 checkToCooked(converter, 0xAAAAAAAA, (uint16_t)0xAAAA);
1535 checkToCookedOverflowNeg<int16_t>(converter, 0x55555555);
1536
1537 checkToRaw(converter, (uint16_t)0, 0);
1538 checkToRaw(converter, (uint16_t)1, 1);
1539 checkToRaw(converter, (uint16_t)3, 3);
1540 checkToRaw(converter, (uint16_t)6, 6);
1541 checkToRaw(converter, (uint16_t)0x7FFF, 0x7FFF);
1542 checkToRaw(converter, (uint16_t)0x8000, 0x8000);
1543 checkToRaw(converter, (uint16_t)0xFFFF, 0xFFFF);
1544}
1545
1546BOOST_AUTO_TEST_CASE(testInt0unsigned) { // test with 0 significant bits
1547 // (unsigned, no fractional bits)
1548 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("int0unsigned", 0, 0, false);
1549
1550 checkToCooked(converter, 0, 0);
1551 checkToCooked(converter, 1, 0);
1552 checkToCooked(converter, 0x0000FFFF, 0);
1553 checkToCooked(converter, 0xFFFF0000, 0);
1554 checkToCooked(converter, 0xFFFFFFFF, 0);
1555
1556 checkToRaw(converter, 0, 0);
1557 checkToRaw(converter, 1, 0);
1558 checkToRaw(converter, 0xFFFF, 0);
1559 checkToRaw(converter, -1, 0);
1560}
1561
1562BOOST_AUTO_TEST_CASE(testInt0signed) { // test with 0 significant bits (signed,
1563 // no fractional bits)
1564 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("int0signed", 0, 0, true);
1565
1566 checkToCooked(converter, 0, 0);
1567 checkToCooked(converter, 1, 0);
1568 checkToCooked(converter, 0x0000FFFF, 0);
1569 checkToCooked(converter, 0xFFFF0000, 0);
1570 checkToCooked(converter, 0xFFFFFFFF, 0);
1571
1572 checkToRaw(converter, 0, 0);
1573 checkToRaw(converter, 1, 0);
1574 checkToRaw(converter, 0xFFFF, 0);
1575 checkToRaw(converter, -1, 0);
1576}
1577
1578BOOST_AUTO_TEST_CASE(testInt0unsignedFractional) { // test with 0 significant bits (unsigned,
1579 // with fractional bits)
1580 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("int0unsignedFractional", 0, 5, false);
1581
1582 checkToCooked(converter, 0, 0);
1583 checkToCooked(converter, 1, 0);
1584 checkToCooked(converter, 0x0000FFFF, 0);
1585 checkToCooked(converter, 0xFFFF0000, 0);
1586 checkToCooked(converter, 0xFFFFFFFF, 0);
1587
1588 checkToRaw(converter, 0, 0);
1589 checkToRaw(converter, 1, 0);
1590 checkToRaw(converter, 0xFFFF, 0);
1591 checkToRaw(converter, -1, 0);
1592}
1593
1594BOOST_AUTO_TEST_CASE(testInt0signedFractional) { // test with 0 significant bits (signed, with
1595 // negative fractional bits)
1596 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("int0signedFractional", 0, -5, true);
1597
1598 checkToCooked(converter, 0, 0);
1599 checkToCooked(converter, 1, 0);
1600 checkToCooked(converter, 0x0000FFFF, 0);
1601 checkToCooked(converter, 0xFFFF0000, 0);
1602 checkToCooked(converter, 0xFFFFFFFF, 0);
1603
1604 checkToRaw(converter, 0, 0);
1605 checkToRaw(converter, 1, 0);
1606 checkToRaw(converter, 0xFFFF, 0);
1607 checkToRaw(converter, -1, 0);
1608}
1609
1610BOOST_AUTO_TEST_CASE(testDynamicRangePos) {
1611 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("dynamicRangePos", 16, 1021 - 16, false);
1612
1613 checkToCooked(converter, 0, 0.);
1614 checkToCooked(converter, 1, pow(2., -(1021 - 16)));
1615 checkToCooked(converter, 0xFFFF, 65535. * pow(2., -(1021 - 16)));
1616
1617 // check that our comparison values are not already exceeding the dynamic
1618 // range
1619 BOOST_CHECK(!std::isinf(65535. * pow(2., -(1021 - 16))));
1620}
1621
1622BOOST_AUTO_TEST_CASE(testDynamicRangeNeg) {
1623 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter("dynamicRangeNeg", 16, -1024 + 16, false);
1624
1625 checkToCooked(converter, 0, 0.);
1626 checkToCooked(converter, 1, pow(2., 1024 - 16));
1627 checkToCooked(converter, 0xFFFF, 65535. * pow(2., 1024 - 16));
1628
1629 // check that our comparison values are not already exceeding the dynamic
1630 // range
1631 BOOST_CHECK(pow(2., -(1024 - 16)) > 0.);
1632}
1633
1634BOOST_AUTO_TEST_CASE(testBoolean0) {
1635 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter(
1636 "Variable32signed"); // default parameters are signed 32 bit
1637
1638 checkToCooked(converter, 0x00000000, Boolean(false));
1639}
1640
1641BOOST_AUTO_TEST_CASE(testVoid) {
1642 FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> converter(
1643 "Variable32signed"); // default parameters are signed 32 bit
1644
1645 Void output = converter.scalarToCooked<Void>(23);
1646 (void)output;
1647}
1648
1649BOOST_AUTO_TEST_SUITE_END()
ChimeraTK::Boolean
Wrapper Class to avoid vector<bool> problems.
Definition SupportedUserTypes.h:22
ChimeraTK::FixedPointConverter
The fixed point converter provides conversion functions between a user type and up to 32 bit fixed po...
Definition FixedPointConverter.h:31
ChimeraTK::FixedPointConverter::getFractionalBits
int getFractionalBits() const
Read back the fractional bits the converter is using.
Definition FixedPointConverter.h:101
ChimeraTK::FixedPointConverter::scalarToCooked
UserType scalarToCooked(RawType const &raw) const
Inefficient convenience function for converting a single value to cooked.
Definition FixedPointConverter.h:91
ChimeraTK::FixedPointConverter::isSigned
bool isSigned() const
Read back wether the conversion is using signed values.
Definition FixedPointConverter.h:104
ChimeraTK::FixedPointConverter::getNBits
unsigned int getNBits() const
Read back the number of bits the converter is using.
Definition FixedPointConverter.h:98
ChimeraTK::FixedPointConverter::toRaw
RawType toRaw(UserType cookedValue) const
Conversion function from type T to fixed point.
Definition FixedPointConverter.h:341
ChimeraTK::Void
Wrapper Class for void.
Definition SupportedUserTypes.h:72
ChimeraTK::logic_error
Exception thrown when a logic error has occured.
Definition Exception.h:51
HEX_TO_DOUBLE
#define HEX_TO_DOUBLE(INPUT)
Definition testFixedPointConverter.cpp:24
DEF_TYPENAME
#define DEF_TYPENAME(name)
Definition testFixedPointConverter.cpp:52
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(testConstructor)
Definition testFixedPointConverter.cpp:122
checkToCooked
void checkToCooked(FixedPointConverter< DEPRECATED_FIXEDPOINT_DEFAULT > const &converter, uint32_t input, T expectedValue, const std::string &msg=std::string(""))
Definition testFixedPointConverter.cpp:81
checkToCookedOverflowNeg
void checkToCookedOverflowNeg(FixedPointConverter< DEPRECATED_FIXEDPOINT_DEFAULT > const &converter, uint32_t input)
Definition testFixedPointConverter.cpp:71
SIGNED_HEX_TO_DOUBLE
#define SIGNED_HEX_TO_DOUBLE(INPUT)
Definition testFixedPointConverter.cpp:25
typeName
const char * typeName(void)
Definition testFixedPointConverter.cpp:49
checkToCookedOverflowPos
void checkToCookedOverflowPos(FixedPointConverter< DEPRECATED_FIXEDPOINT_DEFAULT > const &converter, uint32_t input)
Definition testFixedPointConverter.cpp:76
checkToRaw
void checkToRaw(FixedPointConverter< DEPRECATED_FIXEDPOINT_DEFAULT > const &converter, T input, uint32_t expectedValue, const std::string &msg=std::string(""))
Definition testFixedPointConverter.cpp:101
SIGNED_HEX_TO_INT64
#define SIGNED_HEX_TO_INT64(INPUT)
Definition testFixedPointConverter.cpp:26