1 /********************************************************************
2 * gtest-gnc-numeric.cpp -- unit tests for the GncNumeric class *
3 * Copyright 2017 John Ralls <jralls@ceridwen.us> *
4 * *
5 * This program is free software; you can redistribute it and/or *
6 * modify it under the terms of the GNU General Public License as *
7 * published by the Free Software Foundation; either version 2 of *
8 * the License, or (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License*
16 * along with this program; if not, contact: *
17 * *
18 * Free Software Foundation Voice: +1-617-542-5942 *
19 * 51 Franklin Street, Fifth Floor Fax: +1-617-542-2652 *
20 * Boston, MA 02110-1301, USA gnu@gnu.org *
21 \********************************************************************/
22
23 #include <gtest/gtest.h>
24 #include "../gnc-numeric.hpp"
25 #include "../gnc-rational.hpp"
26
TEST(gncnumeric_constructors,test_default_constructor)27 TEST(gncnumeric_constructors, test_default_constructor)
28 {
29 GncNumeric value;
30 EXPECT_EQ(value.num(), 0);
31 EXPECT_EQ(value.denom(), 1);
32 }
33
TEST(gncnumeric_constructors,test_gnc_rational_constructor)34 TEST(gncnumeric_constructors, test_gnc_rational_constructor)
35 {
36 GncInt128 num128(INT64_C(123456789), INT64_C(567894392130486208));
37 GncInt128 den128(INT64_C(456789123), INT64_C(543210987651234567));
38 GncRational in (num128, den128);
39 GncNumeric out;
40 ASSERT_NO_THROW(out = GncNumeric(in));
41 EXPECT_EQ(INT64_C(1246404345742679464), out.num());
42 EXPECT_EQ(INT64_C(4611686019021985017), out.denom());
43 }
44
TEST(gncnumeric_constructors,test_gnc_numeric_constructor)45 TEST(gncnumeric_constructors, test_gnc_numeric_constructor)
46 {
47 gnc_numeric input = gnc_numeric_create(123, 456);
48 GncNumeric value(input);
49 EXPECT_EQ(input.num, value.num());
50 EXPECT_EQ(input.denom, value.denom());
51
52 input = gnc_numeric_create(123, 0);
53 ASSERT_THROW(GncNumeric throw_val(input), std::invalid_argument);
54 }
55
TEST(gncnumeric_constructors,test_int64_constructor)56 TEST(gncnumeric_constructors, test_int64_constructor)
57 {
58 int64_t num(123), denom(456);
59 GncNumeric value(num, denom);
60 EXPECT_EQ(123, value.num());
61 EXPECT_EQ(456, value.denom());
62 denom = INT64_C(0);
63 ASSERT_THROW(GncNumeric throw_val(num, denom), std::invalid_argument);
64 }
65
TEST(gncnumeric_constructors,test_implicit_int_constructor)66 TEST(gncnumeric_constructors, test_implicit_int_constructor)
67 {
68 int num(123), denom(456);
69 GncNumeric value(num, denom);
70 EXPECT_EQ(123, value.num());
71 EXPECT_EQ(456, value.denom());
72 EXPECT_THROW(GncNumeric throw_val(123, 0), std::invalid_argument);
73
74 }
75
TEST(gncnumeric_constructors,test_double_constructor)76 TEST(gncnumeric_constructors, test_double_constructor)
77 {
78 GncNumeric a(123456.789000);
79 EXPECT_EQ(123456789, a.num());
80 EXPECT_EQ(1000, a.denom());
81 GncNumeric b(-123456.789000);
82 EXPECT_EQ(-123456789, b.num());
83 EXPECT_EQ(1000, b.denom());
84 GncNumeric c(static_cast<double>(0.0000000123456789000));
85 EXPECT_EQ(123456789, c.num());
86 EXPECT_EQ(INT64_C(10000000000000000), c.denom());
87 GncNumeric d(1.23456789e-19);
88 EXPECT_EQ(0, d.num());
89 EXPECT_EQ(1, d.denom());
90 EXPECT_THROW(GncNumeric e(123456789e18), std::invalid_argument);
91 auto f = GncNumeric(1.1234567890123).convert_sigfigs<RoundType::bankers>(6);
92 EXPECT_EQ(112346, f.num());
93 EXPECT_EQ(100000, f.denom());
94 auto g = GncNumeric(0.011234567890123).convert_sigfigs<RoundType::bankers>(6);
95 EXPECT_EQ(112346, g.num());
96 EXPECT_EQ(10000000, g.denom());
97 auto h = GncNumeric(1123.4567890123).convert_sigfigs<RoundType::bankers>(6);
98 EXPECT_EQ(112346, h.num());
99 EXPECT_EQ(100, h.denom());
100 auto i = GncNumeric(1.1234567890123e-5).convert_sigfigs<RoundType::bankers>(6);
101 EXPECT_EQ(112346, i.num());
102 EXPECT_EQ(10000000000, i.denom());
103 }
104
TEST(gncnumeric_constructors,test_string_constructor)105 TEST(gncnumeric_constructors, test_string_constructor)
106 {
107 EXPECT_NO_THROW(GncNumeric simple_num("123/456"));
108 GncNumeric simple_num("123/456");
109 EXPECT_EQ(123, simple_num.num());
110 EXPECT_EQ(456, simple_num.denom());
111 EXPECT_NO_THROW(GncNumeric neg_simple_num("-123/456"));
112 GncNumeric neg_simple_num("-123/456");
113 EXPECT_EQ(-123, neg_simple_num.num());
114 EXPECT_EQ(456, neg_simple_num.denom());
115 ASSERT_NO_THROW(GncNumeric with_spaces("123 / 456"));
116 GncNumeric with_spaces("123 / 456");
117 EXPECT_EQ(123, with_spaces.num());
118 EXPECT_EQ(456, with_spaces.denom());
119 ASSERT_NO_THROW(GncNumeric neg_with_spaces("-123 / 456"));
120 GncNumeric neg_with_spaces("-123 / 456");
121 EXPECT_EQ(-123, neg_with_spaces.num());
122 EXPECT_EQ(456, neg_with_spaces.denom());
123 ASSERT_NO_THROW(GncNumeric simple_int("123456"));
124 GncNumeric simple_int("123456");
125 EXPECT_EQ(123456, simple_int.num());
126 EXPECT_EQ(1, simple_int.denom());
127 ASSERT_NO_THROW(GncNumeric neg_simple_int("-123456"));
128 GncNumeric neg_simple_int("-123456");
129 EXPECT_EQ(-123456, neg_simple_int.num());
130 EXPECT_EQ(1, neg_simple_int.denom());
131 ASSERT_NO_THROW(GncNumeric simple_hex("0x1e240"));
132 GncNumeric simple_hex("0x1e240");
133 EXPECT_EQ(123456, simple_int.num());
134 EXPECT_EQ(1, simple_int.denom());
135 ASSERT_NO_THROW(GncNumeric simple_decimal("123.456"));
136 GncNumeric simple_decimal("123.456");
137 EXPECT_EQ(123456, simple_decimal.num());
138 EXPECT_EQ(1000, simple_decimal.denom());
139 ASSERT_NO_THROW(GncNumeric neg_simple_decimal("-123.456"));
140 GncNumeric neg_simple_decimal("-123.456");
141 EXPECT_EQ(-123456, neg_simple_decimal.num());
142 EXPECT_EQ(1000, neg_simple_decimal.denom());
143 ASSERT_NO_THROW(GncNumeric continental_decimal("123,456"));
144 GncNumeric continental_decimal("123,456");
145 EXPECT_EQ(123456, continental_decimal.num());
146 EXPECT_EQ(1000, continental_decimal.denom());
147 ASSERT_NO_THROW(GncNumeric neg_continental_decimal("-123,456"));
148 GncNumeric neg_continental_decimal("-123,456");
149 EXPECT_EQ(-123456, neg_continental_decimal.num());
150 EXPECT_EQ(1000, neg_continental_decimal.denom());
151 ASSERT_NO_THROW(GncNumeric hex_rational("0x1e240/0x1c8"));
152 GncNumeric hex_rational("0x1e240/0x1c8");
153 EXPECT_EQ(123456, hex_rational.num());
154 EXPECT_EQ(456, hex_rational.denom());
155 ASSERT_NO_THROW(GncNumeric hex_over_num("0x1e240/456"));
156 GncNumeric hex_over_num("0x1e240/456");
157 EXPECT_EQ(123456, hex_over_num.num());
158 EXPECT_EQ(456, hex_over_num.denom());
159 ASSERT_NO_THROW(GncNumeric num_over_hex("123456/0x1c8"));
160 GncNumeric num_over_hex("123456/0x1c8");
161 EXPECT_EQ(123456, num_over_hex.num());
162 EXPECT_EQ(456, num_over_hex.denom());
163 ASSERT_NO_THROW(GncNumeric embedded("The number is 123456/456"));
164 GncNumeric embedded("The number is 123456/456");
165 EXPECT_EQ(123456, embedded.num());
166 EXPECT_EQ(456, embedded.denom());
167 ASSERT_NO_THROW(GncNumeric embedded("The number is -123456/456"));
168 GncNumeric neg_embedded("The number is -123456/456");
169 EXPECT_EQ(-123456, neg_embedded.num());
170 EXPECT_EQ(456, neg_embedded.denom());
171 EXPECT_THROW(GncNumeric throw_zero_denom("123/0"), std::invalid_argument);
172 EXPECT_THROW(GncNumeric overflow("12345678987654321.123456"),
173 std::overflow_error);
174 EXPECT_NO_THROW(GncNumeric overflow("12345678987654321.123456", true));
175 GncNumeric overflow("12345678987654321.123456", true);
176 EXPECT_EQ(6028163568190586486, overflow.num());
177 EXPECT_EQ(488, overflow.denom());
178 EXPECT_THROW(GncNumeric auto_round("12345678987654321234/256", true),
179 std::out_of_range);
180 EXPECT_THROW(GncNumeric bad_string("Four score and seven"),
181 std::invalid_argument);
182 GncNumeric neg_decimal_frac("-0.12345");
183 EXPECT_EQ(-12345, neg_decimal_frac.num());
184 EXPECT_EQ(100000, neg_decimal_frac.denom());
185 GncNumeric neg_decimal_frac_nozero("-.12345");
186 EXPECT_EQ(-12345, neg_decimal_frac_nozero.num());
187 EXPECT_EQ(100000, neg_decimal_frac_nozero.denom());
188 }
189
TEST(gncnumeric_output,string_output)190 TEST(gncnumeric_output, string_output)
191 {
192 GncNumeric simple_int(123456, 1);
193 EXPECT_EQ("123456", simple_int.to_string());
194 GncNumeric neg_simple_int(-123456, 1);
195 EXPECT_EQ("-123456", neg_simple_int.to_string());
196 GncNumeric decimal_string(123456, 1000);
197 EXPECT_EQ("123.456", decimal_string.to_string());
198 GncNumeric neg_decimal_string(-123456, 1000);
199 EXPECT_EQ("-123.456", neg_decimal_string.to_string());
200 GncNumeric rational_string(123, 456);
201 EXPECT_EQ("123/456", rational_string.to_string());
202 GncNumeric neg_rational_string(-123, 456);
203 EXPECT_EQ("-123/456", neg_rational_string.to_string());
204 }
205
TEST(gncnumeric_stream,output_stream)206 TEST(gncnumeric_stream, output_stream)
207 {
208 std::ostringstream output;
209 GncNumeric simple_int(INT64_C(123456));
210 output << simple_int;
211 EXPECT_EQ("123456", output.str());
212 output.str("");
213 GncNumeric decimal_string(123456, 1000);
214 output << decimal_string;
215 EXPECT_EQ("123.456", output.str());
216 output.str("");
217 GncNumeric rational_string(123, 456);
218 output << rational_string;
219 EXPECT_EQ("123/456", output.str());
220 try
221 {
222 auto loc = std::locale("fr_FR.utf8");
223 auto thou_sep = std::use_facet<std::numpunct<wchar_t>>(loc).thousands_sep();
224 output.imbue(loc);
225 output.str("");
226 output << simple_int;
227 if (thou_sep == L' ')
228 EXPECT_EQ("123 456", output.str());
229 else
230 EXPECT_EQ("123\xe2\x80\xaf""456", output.str());
231 }
232 catch (std::runtime_error& err)
233 {
234 output.imbue(std::locale("fr_FR"));
235 output.str("");
236 output << simple_int;
237 EXPECT_EQ("123456", output.str());
238 }
239 output.str("");
240 output << decimal_string;
241 EXPECT_EQ("123,456", output.str());
242 output.str("");
243 output << rational_string;
244 EXPECT_EQ("123/456", output.str());
245 }
246
TEST(gncnumeric_stream,input_stream)247 TEST(gncnumeric_stream, input_stream)
248 {
249 std::istringstream input("123456");
250 GncNumeric numeric;
251 EXPECT_NO_THROW(input >> numeric);
252 EXPECT_EQ(123456, numeric.num());
253 EXPECT_EQ(1, numeric.denom());
254 input.clear();
255 input.str("123456/456");
256 EXPECT_NO_THROW(input >> numeric);
257 EXPECT_EQ(123456, numeric.num());
258 EXPECT_EQ(456, numeric.denom());
259 input.clear();
260 input.str("123456 / 456");
261 EXPECT_NO_THROW(input >> numeric);
262 EXPECT_EQ(123456, numeric.num());
263 EXPECT_EQ(1, numeric.denom());
264 input.clear();
265 input.str("0x1e240/0x1c8");
266 EXPECT_NO_THROW(input >> std::hex >> numeric);
267 EXPECT_EQ(123456, numeric.num());
268 EXPECT_EQ(456, numeric.denom());
269 input.clear();
270 input.str("0x1e240/456");
271 EXPECT_NO_THROW(input >> numeric);
272 EXPECT_EQ(123456, numeric.num());
273 EXPECT_EQ(456, numeric.denom());
274 input.clear();
275 input.str("123456/0x1c8");
276 EXPECT_NO_THROW(input >> numeric);
277 EXPECT_EQ(123456, numeric.num());
278 EXPECT_EQ(456, numeric.denom());
279 input.clear();
280 input.str("123/0");
281 EXPECT_THROW(input >> std::dec >> numeric, std::invalid_argument);
282 input.clear();
283 input.str("12345678987654321.123456");
284 EXPECT_NO_THROW(input >> numeric);
285 EXPECT_EQ(6028163568190586486, numeric.num());
286 EXPECT_EQ(488, numeric.denom());
287 input.clear();
288 input.str("12345678987654321234/256");
289 EXPECT_THROW(input >> numeric, std::out_of_range);
290 input.clear();
291 input.str("Four score and seven");
292 EXPECT_THROW(input >> numeric, std::invalid_argument);
293 }
294
TEST(gncnumeric_operators,gnc_numeric_conversion)295 TEST(gncnumeric_operators, gnc_numeric_conversion)
296 {
297 GncNumeric a(123456789, 9876);
298 gnc_numeric b = static_cast<decltype(b)>(a);
299 EXPECT_EQ(123456789, b.num);
300 EXPECT_EQ(9876, b.denom);
301 }
302
TEST(gncnumeric_operators,double_conversion)303 TEST(gncnumeric_operators, double_conversion)
304 {
305 GncNumeric a(123456789, 9876);
306 double b = static_cast<decltype(b)>(a);
307 EXPECT_DOUBLE_EQ(12500.687424058324, b);
308 }
309
TEST(gncnumeric_operators,test_addition)310 TEST(gncnumeric_operators, test_addition)
311 {
312 GncNumeric a(123456789987654321, 1000000000);
313 GncNumeric b(65432198765432198, 100000000);
314 GncNumeric c = a + b;
315 EXPECT_EQ (777778777641976301, c.num());
316 EXPECT_EQ (1000000000, c.denom());
317 a += b;
318 EXPECT_EQ (777778777641976301, a.num());
319 EXPECT_EQ (1000000000, a.denom());
320 }
321
TEST(gncnumeric_operators,test_subtraction)322 TEST(gncnumeric_operators, test_subtraction)
323 {
324 GncNumeric a(123456789987654321, 1000000000);
325 GncNumeric b(65432198765432198, 100000000);
326 GncNumeric c = a - b;
327 EXPECT_EQ (-530865197666667659, c.num());
328 EXPECT_EQ (1000000000, c.denom());
329 c = b - a;
330 EXPECT_EQ (530865197666667659, c.num());
331 EXPECT_EQ (1000000000, c.denom());
332 a -= b;
333 EXPECT_EQ (-530865197666667659, a.num());
334 EXPECT_EQ (1000000000, a.denom());
335 GncNumeric d(2, 6), e(1, 4);
336 c = d - e;
337 EXPECT_EQ(1, c.num());
338 EXPECT_EQ(12, c.denom());
339 }
340
TEST(gncnumeric_operators,test_multiplication)341 TEST(gncnumeric_operators, test_multiplication)
342 {
343 GncNumeric a(123456789987654321, 1000000000);
344 GncNumeric b(65432198765432198, 100000000);
345 GncNumeric c = a * b;
346 EXPECT_EQ (9208976112412435614, c.num());
347 EXPECT_EQ (114, c.denom());
348 a *= b;
349 EXPECT_EQ (9208976112412435614, a.num());
350 EXPECT_EQ (114, a.denom());
351
352 GncNumeric d(215815575996, 269275978715);
353 GncNumeric e(1002837599929, 1);
354 GncNumeric f, g;
355 EXPECT_NO_THROW(f = d * e);
356 EXPECT_NO_THROW(g = f.convert<RoundType::half_up>(1));
357 GncNumeric h(133499999999, 136499999999);
358 GncNumeric i(60000000003, 100000000);
359 GncNumeric j;
360 EXPECT_NO_THROW(j = gnc_numeric_mul(h, i, 100000000, GNC_HOW_RND_ROUND));
361 EXPECT_EQ(58681318684, j.num());
362
363 }
364
TEST(gncnumeric_operators,test_division)365 TEST(gncnumeric_operators, test_division)
366 {
367 GncNumeric a(123456789987654321, 1000000000);
368 GncNumeric b(65432198765432198, 100000000);
369 GncNumeric c = a / b;
370 EXPECT_EQ (123456789987654321, c.num());
371 EXPECT_EQ (654321987654321980, c.denom());
372
373 a /= b;
374 EXPECT_EQ (123456789987654321, a.num());
375 EXPECT_EQ (654321987654321980, a.denom());
376
377 }
378
TEST(gncnumeric_functions,test_cmp)379 TEST(gncnumeric_functions, test_cmp)
380 {
381 GncNumeric a(123456789, 9876), b(567894321, 6543);
382 auto c = a;
383 EXPECT_EQ(0, a.cmp(c));
384 EXPECT_EQ(-1, a.cmp(b));
385 EXPECT_EQ(1, b.cmp(a));
386 EXPECT_EQ(-1, b.cmp(INT64_C(88888)));
387 EXPECT_EQ(1, a.cmp(INT64_C(12500)));
388 }
389
TEST(gncnumeric_functions,test_invert)390 TEST(gncnumeric_functions, test_invert)
391 {
392 GncNumeric a(123456789, 9876), b, c;
393 ASSERT_NO_THROW(c = b.inv());
394 EXPECT_EQ(0, c.num());
395 EXPECT_EQ(1, c.denom());
396 ASSERT_NO_THROW(b = a.inv());
397 EXPECT_EQ(9876, b.num());
398 EXPECT_EQ(123456789, b.denom());
399 }
400
TEST(gncnumeric_functions,test_reduce)401 TEST(gncnumeric_functions, test_reduce)
402 {
403 GncNumeric a(123456789, 5202504), b;
404 ASSERT_NO_THROW(b = a.reduce());
405 EXPECT_EQ(3607, b.num());
406 EXPECT_EQ(152, b.denom());
407 }
408
TEST(gncnumeric_functions,test_convert)409 TEST(gncnumeric_functions, test_convert)
410 {
411 GncNumeric a(12345678, 456), b(-12345678, 456), c;
412 ASSERT_NO_THROW(c = a.convert<RoundType::never>(456));
413 EXPECT_EQ(12345678, c.num());
414 EXPECT_EQ(456, c.denom());
415 EXPECT_THROW(c = a.convert<RoundType::never>(128), std::domain_error);
416 ASSERT_NO_THROW(c = a.convert<RoundType::floor>(128));
417 EXPECT_EQ(3465453, c.num());
418 EXPECT_EQ(128, c.denom());
419 ASSERT_NO_THROW(c = b.convert<RoundType::floor>(128));
420 EXPECT_EQ(-3465454, c.num());
421 EXPECT_EQ(128, c.denom());
422 ASSERT_NO_THROW(c = a.convert<RoundType::ceiling>(128));
423 EXPECT_EQ(3465454, c.num());
424 EXPECT_EQ(128, c.denom());
425 ASSERT_NO_THROW(c = b.convert<RoundType::ceiling>(128));
426 EXPECT_EQ(-3465453, c.num());
427 EXPECT_EQ(128, c.denom());
428 ASSERT_NO_THROW(c = a.convert<RoundType::truncate>(128));
429 EXPECT_EQ(3465453, c.num());
430 EXPECT_EQ(128, c.denom());
431 ASSERT_NO_THROW(c = b.convert<RoundType::truncate>(128));
432 EXPECT_EQ(-3465453, c.num());
433 EXPECT_EQ(128, c.denom());
434 ASSERT_NO_THROW(c = a.convert<RoundType::promote>(128));
435 EXPECT_EQ(3465454, c.num());
436 EXPECT_EQ(128, c.denom());
437 ASSERT_NO_THROW(c = b.convert<RoundType::promote>(128));
438 EXPECT_EQ(-3465454, c.num());
439 EXPECT_EQ(128, c.denom());
440 ASSERT_NO_THROW(c = a.convert<RoundType::half_down>(128));
441 EXPECT_EQ(3465453, c.num());
442 EXPECT_EQ(128, c.denom());
443 ASSERT_NO_THROW(c = a.convert<RoundType::half_down>(114));
444 EXPECT_EQ(3086419, c.num());
445 EXPECT_EQ(114, c.denom());
446 ASSERT_NO_THROW(c = a.convert<RoundType::half_down>(118));
447 EXPECT_EQ(3194715, c.num());
448 EXPECT_EQ(118, c.denom());
449 ASSERT_NO_THROW(c = b.convert<RoundType::half_down>(128));
450 EXPECT_EQ(-3465453, c.num());
451 EXPECT_EQ(128, c.denom());
452 ASSERT_NO_THROW(c = b.convert<RoundType::half_down>(114));
453 EXPECT_EQ(-3086419, c.num());
454 EXPECT_EQ(114, c.denom());
455 ASSERT_NO_THROW(c = b.convert<RoundType::half_down>(121));
456 EXPECT_EQ(-3275936, c.num());
457 EXPECT_EQ(121, c.denom());
458 ASSERT_NO_THROW(c = a.convert<RoundType::half_up>(128));
459 EXPECT_EQ(3465453, c.num());
460 EXPECT_EQ(128, c.denom());
461 ASSERT_NO_THROW(c = a.convert<RoundType::half_up>(114));
462 EXPECT_EQ(3086420, c.num());
463 EXPECT_EQ(114, c.denom());
464 ASSERT_NO_THROW(c = a.convert<RoundType::half_up>(118));
465 EXPECT_EQ(3194715, c.num());
466 EXPECT_EQ(118, c.denom());
467 ASSERT_NO_THROW(c = b.convert<RoundType::half_up>(128));
468 EXPECT_EQ(-3465453, c.num());
469 EXPECT_EQ(128, c.denom());
470 ASSERT_NO_THROW(c = b.convert<RoundType::half_up>(114));
471 EXPECT_EQ(-3086420, c.num());
472 EXPECT_EQ(114, c.denom());
473 ASSERT_NO_THROW(c = b.convert<RoundType::half_up>(121));
474 EXPECT_EQ(-3275936, c.num());
475 EXPECT_EQ(121, c.denom());
476 ASSERT_NO_THROW(c = a.convert<RoundType::bankers>(128));
477 EXPECT_EQ(3465453, c.num());
478 EXPECT_EQ(128, c.denom());
479 ASSERT_NO_THROW(c = a.convert<RoundType::bankers>(114));
480 EXPECT_EQ(3086420, c.num());
481 EXPECT_EQ(114, c.denom());
482 ASSERT_NO_THROW(c = a.convert<RoundType::bankers>(118));
483 EXPECT_EQ(3194715, c.num());
484 EXPECT_EQ(118, c.denom());
485 ASSERT_NO_THROW(c = b.convert<RoundType::bankers>(127));
486 EXPECT_EQ(-3438380, c.num());
487 EXPECT_EQ(127, c.denom());
488 ASSERT_NO_THROW(c = b.convert<RoundType::bankers>(114));
489 EXPECT_EQ(-3086420, c.num());
490 EXPECT_EQ(114, c.denom());
491 ASSERT_NO_THROW(c = b.convert<RoundType::bankers>(121));
492 EXPECT_EQ(-3275936, c.num());
493 EXPECT_EQ(121, c.denom());
494 GncNumeric o(123456789123456789, 128);
495 EXPECT_THROW(c = o.convert<RoundType::bankers>(54321098),
496 std::overflow_error);
497 GncNumeric d(7, 16);
498 ASSERT_NO_THROW(c = d.convert<RoundType::floor>(100));
499 EXPECT_EQ(43, c.num());
500 EXPECT_EQ(100, c.denom());
501 ASSERT_NO_THROW(c = d.convert<RoundType::ceiling>(100));
502 EXPECT_EQ(44, c.num());
503 EXPECT_EQ(100, c.denom());
504 ASSERT_NO_THROW(c = d.convert<RoundType::truncate>(100));
505 EXPECT_EQ(43, c.num());
506 EXPECT_EQ(100, c.denom());
507 ASSERT_NO_THROW(c = d.convert<RoundType::bankers>(100));
508 EXPECT_EQ(44, c.num());
509 EXPECT_EQ(100, c.denom());
510 ASSERT_NO_THROW(c = GncNumeric(1511, 1000).convert<RoundType::bankers>(100));
511 EXPECT_EQ(151, c.num());
512 EXPECT_EQ(100, c.denom());
513 ASSERT_NO_THROW(c = GncNumeric(1516, 1000).convert<RoundType::bankers>(100));
514 EXPECT_EQ(152, c.num());
515 EXPECT_EQ(100, c.denom());
516 ASSERT_NO_THROW(c = GncNumeric(1515, 1000).convert<RoundType::bankers>(100));
517 EXPECT_EQ(152, c.num());
518 EXPECT_EQ(100, c.denom());
519 ASSERT_NO_THROW(c = GncNumeric(1525, 1000).convert<RoundType::bankers>(100));
520 EXPECT_EQ(152, c.num());
521 EXPECT_EQ(100, c.denom());
522 ASSERT_NO_THROW(c = GncNumeric(1535, 1000).convert<RoundType::bankers>(100));
523 EXPECT_EQ(154, c.num());
524 EXPECT_EQ(100, c.denom());
525 ASSERT_NO_THROW(c = GncNumeric(1545, 1000).convert<RoundType::bankers>(100));
526 EXPECT_EQ(154, c.num());
527 EXPECT_EQ(100, c.denom());
528 }
529
TEST(gnc_numeric_functions,test_is_decimal)530 TEST(gnc_numeric_functions, test_is_decimal)
531 {
532 EXPECT_TRUE(GncNumeric(123, 1).is_decimal());
533 EXPECT_FALSE(GncNumeric(123, 3).is_decimal());
534 EXPECT_TRUE(GncNumeric(123, 1000).is_decimal());
535 EXPECT_FALSE(GncNumeric(123, 3200).is_decimal());
536 }
537
TEST(gnc_numeric_functions,test_conversion_to_decimal)538 TEST(gnc_numeric_functions, test_conversion_to_decimal)
539 {
540 GncNumeric a(123456789, 1000), r;
541 EXPECT_NO_THROW(r = a.to_decimal());
542 EXPECT_EQ(123456789, r.num());
543 EXPECT_EQ(1000, r.denom());
544 EXPECT_THROW(r = a.to_decimal(2), std::range_error);
545 GncNumeric b(123456789, 456);
546 EXPECT_THROW(r = b.to_decimal(), std::domain_error);
547 GncNumeric c(123456789, 450);
548 EXPECT_NO_THROW(r = c.to_decimal());
549 EXPECT_EQ(27434842, r.num());
550 EXPECT_EQ(100, r.denom());
551 GncNumeric d(11900000000, 85000000);
552 EXPECT_NO_THROW(r = d.to_decimal());
553 EXPECT_EQ(140, r.num());
554 EXPECT_EQ(1, r.denom());
555 GncNumeric e(11050000000, 65000000);
556 EXPECT_NO_THROW(r = e.to_decimal());
557 EXPECT_EQ(170, r.num());
558 EXPECT_EQ(1, r.denom());
559 GncNumeric f(5000000000, 50000000 );
560 EXPECT_NO_THROW(r = f.to_decimal());
561 EXPECT_EQ(100, r.num());
562 EXPECT_EQ(1, r.denom());
563 }
564