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