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