Skip to content

Commit 21d1b14

Browse files
vpiotrvpiotr
committed
#61: test code cleanup
1 parent b68a0b3 commit 21d1b14

File tree

9 files changed

+217
-283
lines changed

9 files changed

+217
-283
lines changed

‎CMakeLists.txt‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ if(BUILD_TESTING)
1515

1616
if(Boost_FOUND)
1717
include_directories(${Boost_INCLUDE_DIRS} include)
18-
add_executable(test_runner include/decimal.h tests/runner.cpp tests/decimalTest.ipp)
18+
add_executable(test_runner include/decimal.h tests/runner.cpp)
1919
target_include_directories(test_runner PRIVATE ${BOOST_INCLUDE_DIRS})
2020
endif()
2121

‎tests/decimalTest.cpp‎

Lines changed: 194 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -7,8 +7,198 @@
77
// Licence: BSD
88
/////////////////////////////////////////////////////////////////////////////
99

10-
#define BOOST_TEST_NO_MAIN
11-
#define BOOST_TEST_MODULE DecimalTest
12-
#include <boost/test/included/unit_test.hpp>
10+
#include "decimal.h"
11+
#include <boost/integer_traits.hpp>
12+
13+
#ifndef DEC_NO_CPP11
14+
#include <type_traits>
15+
#endif
16+
17+
BOOST_AUTO_TEST_CASE(decimalAsInteger)
18+
{
19+
// rounded value
20+
dec::decimal<6> a;
21+
a = dec::decimal<6>("2305843009213.693952");
22+
dec::DEC_INT64 expectedValue = 2305843009214;
23+
BOOST_CHECK_EQUAL(a.getAsInteger(), expectedValue);
24+
25+
// int64 value (>0)
26+
expectedValue = 23058430092136939;
27+
dec::decimal<1> b = dec::decimal<1>(expectedValue);
28+
BOOST_CHECK_EQUAL(b.getAsInteger(), expectedValue);
29+
30+
// int64 value (<0)
31+
expectedValue = -23058430092136939;
32+
dec::decimal<1> c = dec::decimal<1>(expectedValue);
33+
BOOST_CHECK_EQUAL(c.getAsInteger(), expectedValue);
34+
}
35+
36+
// test with values internally > 2^32
37+
BOOST_AUTO_TEST_CASE(decimalMidOverflow)
38+
{
39+
dec::decimal<6> a;
40+
dec::decimal<6> b;
41+
dec::decimal<6> c;
42+
dec::decimal<6> expected;
43+
44+
a = dec::decimal<6>("2305843009213.693952"); // 2^61
45+
b = dec::decimal<6>("2.000001"); // value < 2^32
46+
47+
c = a * b;
48+
expected = dec::decimal<6>("4611688324270.397118");
49+
50+
// overflow, so calculation via floating point, error will be <> 0, but should be small
51+
BOOST_CHECK((c - expected).abs() < dec::decimal<6>("1.0"));
52+
}
53+
54+
BOOST_AUTO_TEST_CASE(decimalUnpack)
55+
{
56+
using namespace dec;
57+
58+
decimal<4> d(-0.5);
59+
int64 before, after;
60+
d.unpack(before, after);
61+
BOOST_CHECK(before == 0);
62+
BOOST_CHECK(after == -5000);
63+
64+
decimal<4> d1(-1.5);
65+
d1.unpack(before, after);
66+
BOOST_CHECK(before == -1);
67+
BOOST_CHECK(after == -5000);
68+
69+
decimal<4> d2(1.5121);
70+
d2.unpack(before, after);
71+
BOOST_CHECK(before == 1);
72+
BOOST_CHECK(after == 5121);
73+
74+
decimal<4> d3(0.5121);
75+
d3.unpack(before, after);
76+
BOOST_CHECK(before == 0);
77+
BOOST_CHECK(after == 5121);
78+
}
79+
80+
BOOST_AUTO_TEST_CASE(decimalPack)
81+
{
82+
using namespace dec;
83+
decimal<4> d;
84+
BOOST_CHECK(decimal<4>().pack(2, 5121) == decimal<4>(2.5121));
85+
BOOST_CHECK(d.pack(1, 1) == decimal<4>("1.0001"));
86+
BOOST_CHECK(d.pack(1, 1000) == decimal<4>("1.1"));
87+
BOOST_CHECK(d.pack(0, 5121) == decimal<4>(0.5121));
88+
BOOST_CHECK(d.pack(0, -5121) == decimal<4>(-0.5121));
89+
BOOST_CHECK(d.pack(1, 5121) == decimal<4>(1.5121));
90+
BOOST_CHECK(d.pack(-1, 0) == decimal<4>(-1.0));
91+
BOOST_CHECK(d.pack(-1, -5121) == decimal<4>(-1.5121));
92+
BOOST_CHECK(d.pack(-1, 5121) != decimal<4>(-1.5121));
93+
BOOST_CHECK(d.pack(1, -5121) != decimal<4>(-1.5121));
94+
// trimming (no rounding) for default pack
95+
BOOST_CHECK(d.pack(1, 51210) != decimal<4>("1.5121"));
96+
BOOST_CHECK(d.pack(1, 51215) != decimal<4>("1.5121"));
97+
// pack with rounding
98+
BOOST_CHECK(decimal_cast<4>(decimal<5>().pack(1, 51215)) == decimal<4>("1.5122"));
99+
BOOST_CHECK(d.pack_rounded<5>(1, 51216) == decimal<4>("1.5122"));
100+
BOOST_CHECK(d.pack_rounded<5>(1, 51215) == decimal<4>("1.5122"));
101+
BOOST_CHECK(d.pack_rounded<5>(1, 51214) == decimal<4>("1.5121"));
102+
BOOST_CHECK(d.pack_rounded<5>(1, 51211) == decimal<4>("1.5121"));
103+
}
104+
105+
BOOST_AUTO_TEST_CASE(decimalZeroPrec)
106+
{
107+
using namespace dec;
108+
decimal<0> d;
109+
110+
// integer values
111+
BOOST_CHECK(decimal<0>().pack(25121, 0) == decimal<0>(25121));
112+
BOOST_CHECK(d.pack(5121, 0) == decimal<0>(5121));
113+
114+
// trimming (no rounding in pack)
115+
BOOST_CHECK(decimal<0>().pack(2, 5121) == decimal<0>(2));
116+
BOOST_CHECK(d.pack(0, 5121) == decimal<0>(0));
117+
BOOST_CHECK(d.pack(0, -5121) == decimal<0>(0));
118+
BOOST_CHECK(d.pack(1, 5121) == decimal<0>(1));
119+
BOOST_CHECK(d.pack(-1, -5121) == decimal<0>(-1));
120+
BOOST_CHECK(d.pack(-1, 5121) == decimal<0>(-1));
121+
122+
// for rounding use decimal_cast from source prec
123+
d = decimal_cast<0>(decimal<4>().pack(-1, -5121));
124+
BOOST_CHECK(d == decimal<0>(-2));
125+
}
126+
127+
BOOST_AUTO_TEST_CASE(decimalComparison)
128+
{
129+
const double pi = 3.1415926;
130+
BOOST_CHECK_EQUAL(dec::decimal<8>(0.), 0);
131+
BOOST_CHECK_EQUAL(dec::decimal<8>(0.), 0u);
132+
#ifdef DEC_HANDLE_LONG
133+
BOOST_CHECK_EQUAL(dec::decimal<8>(0.), 0L);
134+
#endif
135+
BOOST_CHECK_EQUAL(dec::decimal<8>(0.), 0.);
136+
BOOST_CHECK_EQUAL(dec::decimal<8>(pi), pi);
137+
BOOST_CHECK_EQUAL(dec::decimal<8>(pi), dec::decimal<8>(pi));
138+
BOOST_CHECK(dec::decimal<8>(pi) < 5);
139+
BOOST_CHECK(dec::decimal<8>(pi) <= 5);
140+
BOOST_CHECK(dec::decimal<8>(pi) <= pi);
141+
BOOST_CHECK(dec::decimal<8>(pi) > 3);
142+
BOOST_CHECK(dec::decimal<8>(pi) >= 3);
143+
BOOST_CHECK(dec::decimal<8>(pi) >= pi);
144+
BOOST_CHECK(dec::decimal<8>(pi) != 3);
145+
BOOST_CHECK(dec::decimal<8>(pi) != 3.0);
146+
}
147+
148+
BOOST_AUTO_TEST_CASE(decimalSign)
149+
{
150+
dec::decimal<4> d(-4.1234);
151+
BOOST_CHECK(d.sign() < 0);
152+
153+
d *= -1;
154+
BOOST_CHECK(d.sign() > 0);
155+
156+
d = -d;
157+
BOOST_CHECK(d.sign() < 0);
158+
159+
d = d.abs();
160+
BOOST_CHECK(d.sign() > 0);
161+
162+
d -= d;
163+
BOOST_CHECK(d.sign() == 0);
164+
}
165+
166+
BOOST_AUTO_TEST_CASE(decimalFloatConstructorHighPrec) {
167+
dec::decimal<2> d1(3.1549999999999998);
168+
dec::decimal<2> d2("3.1549999999999998");
169+
BOOST_CHECK_EQUAL(d1, d2);
170+
171+
dec::decimal<2> d3(-3.1549999999999998);
172+
dec::decimal<2> d4("-3.1549999999999998");
173+
BOOST_CHECK_EQUAL(d3, d4);
174+
175+
dec::decimal<2> d5;
176+
d5.setAsDouble(3.1549999999999998);
177+
BOOST_CHECK_EQUAL(d5, d2);
178+
179+
dec::decimal<2> d6;
180+
d6 = 3.1549999999999998;
181+
BOOST_CHECK_EQUAL(d6, d2);
182+
}
183+
184+
#ifndef DEC_NO_CPP11
185+
BOOST_AUTO_TEST_CASE(trivialAndNoThrowConstructor) {
186+
BOOST_CHECK_EQUAL(std::is_trivial<dec::decimal<6>>::value, false);
187+
188+
BOOST_CHECK_EQUAL(std::is_trivially_constructible<dec::decimal<6>>::value, false);
189+
BOOST_CHECK_EQUAL(std::is_nothrow_constructible<dec::decimal<6>>::value, true);
190+
191+
BOOST_CHECK_EQUAL(std::is_trivially_default_constructible<dec::decimal<6>>::value, false);
192+
BOOST_CHECK_EQUAL(std::is_nothrow_default_constructible<dec::decimal<6>>::value, true);
193+
194+
BOOST_CHECK_EQUAL(std::is_trivially_copy_constructible<dec::decimal<6>>::value, true);
195+
BOOST_CHECK_EQUAL(std::is_nothrow_copy_constructible<dec::decimal<6>>::value, true);
196+
197+
BOOST_CHECK_EQUAL(std::is_trivially_copy_assignable<dec::decimal<6>>::value, true);
198+
BOOST_CHECK_EQUAL(std::is_nothrow_copy_assignable<dec::decimal<6>>::value, true);
199+
200+
BOOST_CHECK_EQUAL(std::is_trivially_destructible<dec::decimal<6>>::value, true);
201+
BOOST_CHECK_EQUAL(std::is_nothrow_destructible<dec::decimal<6>>::value, true);
202+
}
203+
#endif
13204

14-
#include "decimalTest.ipp"

0 commit comments

Comments
 (0)