rippled
Loading...
Searching...
No Matches
Number_test.cpp
1#include <xrpl/basics/Number.h>
2#include <xrpl/beast/unit_test.h>
3#include <xrpl/protocol/IOUAmount.h>
4#include <xrpl/protocol/STAmount.h>
5
6#include <sstream>
7#include <tuple>
8
9namespace ripple {
10
11class Number_test : public beast::unit_test::suite
12{
13public:
14 void
15 testZero()
16 {
17 testcase("zero");
18
19 Number const z{0, 0};
20
21 BEAST_EXPECT(z.mantissa() == 0);
22 BEAST_EXPECT(z.exponent() == Number{}.exponent());
23
24 BEAST_EXPECT((z + z) == z);
25 BEAST_EXPECT((z - z) == z);
26 BEAST_EXPECT(z == -z);
27 }
28
29 void
30 test_limits()
31 {
32 testcase("test_limits");
33 bool caught = false;
34 try
35 {
36 Number x{10'000'000'000'000'000, 32768};
37 }
38 catch (std::overflow_error const&)
39 {
40 caught = true;
41 }
42 BEAST_EXPECT(caught);
43 Number x{10'000'000'000'000'000, 32767};
44 BEAST_EXPECT((x == Number{1'000'000'000'000'000, 32768}));
45 Number z{1'000'000'000'000'000, -32769};
46 BEAST_EXPECT(z == Number{});
47 Number y{1'000'000'000'000'001'500, 32000};
48 BEAST_EXPECT((y == Number{1'000'000'000'000'002, 32003}));
49 Number m{std::numeric_limits<std::int64_t>::min()};
50 BEAST_EXPECT((m == Number{-9'223'372'036'854'776, 3}));
51 Number M{std::numeric_limits<std::int64_t>::max()};
52 BEAST_EXPECT((M == Number{9'223'372'036'854'776, 3}));
53 caught = false;
54 try
55 {
56 Number q{99'999'999'999'999'999, 32767};
57 }
58 catch (std::overflow_error const&)
59 {
60 caught = true;
61 }
62 BEAST_EXPECT(caught);
63 }
64
65 void
66 test_add()
67 {
68 testcase("test_add");
69 using Case = std::tuple<Number, Number, Number>;
70 Case c[]{
71 {Number{1'000'000'000'000'000, -15},
72 Number{6'555'555'555'555'555, -29},
73 Number{1'000'000'000'000'066, -15}},
74 {Number{-1'000'000'000'000'000, -15},
75 Number{-6'555'555'555'555'555, -29},
76 Number{-1'000'000'000'000'066, -15}},
77 {Number{-1'000'000'000'000'000, -15},
78 Number{6'555'555'555'555'555, -29},
79 Number{-9'999'999'999'999'344, -16}},
80 {Number{-6'555'555'555'555'555, -29},
81 Number{1'000'000'000'000'000, -15},
82 Number{9'999'999'999'999'344, -16}},
83 {Number{}, Number{5}, Number{5}},
84 {Number{5'555'555'555'555'555, -32768},
85 Number{-5'555'555'555'555'554, -32768},
86 Number{0}},
87 {Number{-9'999'999'999'999'999, -31},
88 Number{1'000'000'000'000'000, -15},
89 Number{9'999'999'999'999'990, -16}}};
90 for (auto const& [x, y, z] : c)
91 BEAST_EXPECT(x + y == z);
92 bool caught = false;
93 try
94 {
95 Number{9'999'999'999'999'999, 32768} +
96 Number{5'000'000'000'000'000, 32767};
97 }
98 catch (std::overflow_error const&)
99 {
100 caught = true;
101 }
102 BEAST_EXPECT(caught);
103 }
104
105 void
106 test_sub()
107 {
108 testcase("test_sub");
109 using Case = std::tuple<Number, Number, Number>;
110 Case c[]{
111 {Number{1'000'000'000'000'000, -15},
112 Number{6'555'555'555'555'555, -29},
113 Number{9'999'999'999'999'344, -16}},
114 {Number{6'555'555'555'555'555, -29},
115 Number{1'000'000'000'000'000, -15},
116 Number{-9'999'999'999'999'344, -16}},
117 {Number{1'000'000'000'000'000, -15},
118 Number{1'000'000'000'000'000, -15},
119 Number{0}},
120 {Number{1'000'000'000'000'000, -15},
121 Number{1'000'000'000'000'001, -15},
122 Number{-1'000'000'000'000'000, -30}},
123 {Number{1'000'000'000'000'001, -15},
124 Number{1'000'000'000'000'000, -15},
125 Number{1'000'000'000'000'000, -30}}};
126 for (auto const& [x, y, z] : c)
127 BEAST_EXPECT(x - y == z);
128 }
129
130 void
131 test_mul()
132 {
133 testcase("test_mul");
134 using Case = std::tuple<Number, Number, Number>;
135 saveNumberRoundMode save{Number::setround(Number::to_nearest)};
136 {
137 Case c[]{
138 {Number{7}, Number{8}, Number{56}},
139 {Number{1414213562373095, -15},
140 Number{1414213562373095, -15},
141 Number{2000000000000000, -15}},
142 {Number{-1414213562373095, -15},
143 Number{1414213562373095, -15},
144 Number{-2000000000000000, -15}},
145 {Number{-1414213562373095, -15},
146 Number{-1414213562373095, -15},
147 Number{2000000000000000, -15}},
148 {Number{3214285714285706, -15},
149 Number{3111111111111119, -15},
150 Number{1000000000000000, -14}},
151 {Number{1000000000000000, -32768},
152 Number{1000000000000000, -32768},
153 Number{0}}};
154 for (auto const& [x, y, z] : c)
155 BEAST_EXPECT(x * y == z);
156 }
157 Number::setround(Number::towards_zero);
158 {
159 Case c[]{
160 {Number{7}, Number{8}, Number{56}},
161 {Number{1414213562373095, -15},
162 Number{1414213562373095, -15},
163 Number{1999999999999999, -15}},
164 {Number{-1414213562373095, -15},
165 Number{1414213562373095, -15},
166 Number{-1999999999999999, -15}},
167 {Number{-1414213562373095, -15},
168 Number{-1414213562373095, -15},
169 Number{1999999999999999, -15}},
170 {Number{3214285714285706, -15},
171 Number{3111111111111119, -15},
172 Number{9999999999999999, -15}},
173 {Number{1000000000000000, -32768},
174 Number{1000000000000000, -32768},
175 Number{0}}};
176 for (auto const& [x, y, z] : c)
177 BEAST_EXPECT(x * y == z);
178 }
179 Number::setround(Number::downward);
180 {
181 Case c[]{
182 {Number{7}, Number{8}, Number{56}},
183 {Number{1414213562373095, -15},
184 Number{1414213562373095, -15},
185 Number{1999999999999999, -15}},
186 {Number{-1414213562373095, -15},
187 Number{1414213562373095, -15},
188 Number{-2000000000000000, -15}},
189 {Number{-1414213562373095, -15},
190 Number{-1414213562373095, -15},
191 Number{1999999999999999, -15}},
192 {Number{3214285714285706, -15},
193 Number{3111111111111119, -15},
194 Number{9999999999999999, -15}},
195 {Number{1000000000000000, -32768},
196 Number{1000000000000000, -32768},
197 Number{0}}};
198 for (auto const& [x, y, z] : c)
199 BEAST_EXPECT(x * y == z);
200 }
201 Number::setround(Number::upward);
202 {
203 Case c[]{
204 {Number{7}, Number{8}, Number{56}},
205 {Number{1414213562373095, -15},
206 Number{1414213562373095, -15},
207 Number{2000000000000000, -15}},
208 {Number{-1414213562373095, -15},
209 Number{1414213562373095, -15},
210 Number{-1999999999999999, -15}},
211 {Number{-1414213562373095, -15},
212 Number{-1414213562373095, -15},
213 Number{2000000000000000, -15}},
214 {Number{3214285714285706, -15},
215 Number{3111111111111119, -15},
216 Number{1000000000000000, -14}},
217 {Number{1000000000000000, -32768},
218 Number{1000000000000000, -32768},
219 Number{0}}};
220 for (auto const& [x, y, z] : c)
221 BEAST_EXPECT(x * y == z);
222 }
223 bool caught = false;
224 try
225 {
226 Number{9'999'999'999'999'999, 32768} *
227 Number{5'000'000'000'000'000, 32767};
228 }
229 catch (std::overflow_error const&)
230 {
231 caught = true;
232 }
233 BEAST_EXPECT(caught);
234 }
235
236 void
237 test_div()
238 {
239 testcase("test_div");
240 using Case = std::tuple<Number, Number, Number>;
241 saveNumberRoundMode save{Number::setround(Number::to_nearest)};
242 {
243 Case c[]{
244 {Number{1}, Number{2}, Number{5, -1}},
245 {Number{1}, Number{10}, Number{1, -1}},
246 {Number{1}, Number{-10}, Number{-1, -1}},
247 {Number{0}, Number{100}, Number{0}},
248 {Number{1414213562373095, -10},
249 Number{1414213562373095, -10},
250 Number{1}},
251 {Number{9'999'999'999'999'999},
252 Number{1'000'000'000'000'000},
253 Number{9'999'999'999'999'999, -15}},
254 {Number{2}, Number{3}, Number{6'666'666'666'666'667, -16}},
255 {Number{-2}, Number{3}, Number{-6'666'666'666'666'667, -16}}};
256 for (auto const& [x, y, z] : c)
257 BEAST_EXPECT(x / y == z);
258 }
259 Number::setround(Number::towards_zero);
260 {
261 Case c[]{
262 {Number{1}, Number{2}, Number{5, -1}},
263 {Number{1}, Number{10}, Number{1, -1}},
264 {Number{1}, Number{-10}, Number{-1, -1}},
265 {Number{0}, Number{100}, Number{0}},
266 {Number{1414213562373095, -10},
267 Number{1414213562373095, -10},
268 Number{1}},
269 {Number{9'999'999'999'999'999},
270 Number{1'000'000'000'000'000},
271 Number{9'999'999'999'999'999, -15}},
272 {Number{2}, Number{3}, Number{6'666'666'666'666'666, -16}},
273 {Number{-2}, Number{3}, Number{-6'666'666'666'666'666, -16}}};
274 for (auto const& [x, y, z] : c)
275 BEAST_EXPECT(x / y == z);
276 }
277 Number::setround(Number::downward);
278 {
279 Case c[]{
280 {Number{1}, Number{2}, Number{5, -1}},
281 {Number{1}, Number{10}, Number{1, -1}},
282 {Number{1}, Number{-10}, Number{-1, -1}},
283 {Number{0}, Number{100}, Number{0}},
284 {Number{1414213562373095, -10},
285 Number{1414213562373095, -10},
286 Number{1}},
287 {Number{9'999'999'999'999'999},
288 Number{1'000'000'000'000'000},
289 Number{9'999'999'999'999'999, -15}},
290 {Number{2}, Number{3}, Number{6'666'666'666'666'666, -16}},
291 {Number{-2}, Number{3}, Number{-6'666'666'666'666'667, -16}}};
292 for (auto const& [x, y, z] : c)
293 BEAST_EXPECT(x / y == z);
294 }
295 Number::setround(Number::upward);
296 {
297 Case c[]{
298 {Number{1}, Number{2}, Number{5, -1}},
299 {Number{1}, Number{10}, Number{1, -1}},
300 {Number{1}, Number{-10}, Number{-1, -1}},
301 {Number{0}, Number{100}, Number{0}},
302 {Number{1414213562373095, -10},
303 Number{1414213562373095, -10},
304 Number{1}},
305 {Number{9'999'999'999'999'999},
306 Number{1'000'000'000'000'000},
307 Number{9'999'999'999'999'999, -15}},
308 {Number{2}, Number{3}, Number{6'666'666'666'666'667, -16}},
309 {Number{-2}, Number{3}, Number{-6'666'666'666'666'666, -16}}};
310 for (auto const& [x, y, z] : c)
311 BEAST_EXPECT(x / y == z);
312 }
313 bool caught = false;
314 try
315 {
316 Number{1000000000000000, -15} / Number{0};
317 }
318 catch (std::overflow_error const&)
319 {
320 caught = true;
321 }
322 BEAST_EXPECT(caught);
323 }
324
325 void
326 test_root()
327 {
328 testcase("test_root");
329 using Case = std::tuple<Number, unsigned, Number>;
330 Case c[]{
331 {Number{2}, 2, Number{1414213562373095, -15}},
332 {Number{2'000'000}, 2, Number{1414213562373095, -12}},
333 {Number{2, -30}, 2, Number{1414213562373095, -30}},
334 {Number{-27}, 3, Number{-3}},
335 {Number{1}, 5, Number{1}},
336 {Number{-1}, 0, Number{1}},
337 {Number{5, -1}, 0, Number{0}},
338 {Number{0}, 5, Number{0}},
339 {Number{5625, -4}, 2, Number{75, -2}}};
340 for (auto const& [x, y, z] : c)
341 BEAST_EXPECT((root(x, y) == z));
342 bool caught = false;
343 try
344 {
345 (void)root(Number{-2}, 0);
346 }
347 catch (std::overflow_error const&)
348 {
349 caught = true;
350 }
351 BEAST_EXPECT(caught);
352 caught = false;
353 try
354 {
355 (void)root(Number{-2}, 4);
356 }
357 catch (std::overflow_error const&)
358 {
359 caught = true;
360 }
361 BEAST_EXPECT(caught);
362 }
363
364 void
365 test_power1()
366 {
367 testcase("test_power1");
368 using Case = std::tuple<Number, unsigned, Number>;
369 Case c[]{
370 {Number{64}, 0, Number{1}},
371 {Number{64}, 1, Number{64}},
372 {Number{64}, 2, Number{4096}},
373 {Number{-64}, 2, Number{4096}},
374 {Number{64}, 3, Number{262144}},
375 {Number{-64}, 3, Number{-262144}}};
376 for (auto const& [x, y, z] : c)
377 BEAST_EXPECT((power(x, y) == z));
378 }
379
380 void
381 test_power2()
382 {
383 testcase("test_power2");
384 using Case = std::tuple<Number, unsigned, unsigned, Number>;
385 Case c[]{
386 {Number{1}, 3, 7, Number{1}},
387 {Number{-1}, 1, 0, Number{1}},
388 {Number{-1, -1}, 1, 0, Number{0}},
389 {Number{16}, 0, 5, Number{1}},
390 {Number{34}, 3, 3, Number{34}},
391 {Number{4}, 3, 2, Number{8}}};
392 for (auto const& [x, n, d, z] : c)
393 BEAST_EXPECT((power(x, n, d) == z));
394 bool caught = false;
395 try
396 {
397 (void)power(Number{7}, 0, 0);
398 }
399 catch (std::overflow_error const&)
400 {
401 caught = true;
402 }
403 BEAST_EXPECT(caught);
404 caught = false;
405 try
406 {
407 (void)power(Number{7}, 1, 0);
408 }
409 catch (std::overflow_error const&)
410 {
411 caught = true;
412 }
413 BEAST_EXPECT(caught);
414 caught = false;
415 try
416 {
417 (void)power(Number{-1, -1}, 3, 2);
418 }
419 catch (std::overflow_error const&)
420 {
421 caught = true;
422 }
423 BEAST_EXPECT(caught);
424 }
425
426 void
427 testConversions()
428 {
429 testcase("testConversions");
430
431 IOUAmount x{5, 6};
432 Number y = x;
433 BEAST_EXPECT((y == Number{5, 6}));
434 IOUAmount z{y};
435 BEAST_EXPECT(x == z);
436 XRPAmount xrp{500};
437 STAmount st = xrp;
438 Number n = st;
439 BEAST_EXPECT(XRPAmount{n} == xrp);
440 IOUAmount x0{0, 0};
441 Number y0 = x0;
442 BEAST_EXPECT((y0 == Number{0}));
443 IOUAmount z0{y0};
444 BEAST_EXPECT(x0 == z0);
445 XRPAmount xrp0{0};
446 Number n0 = xrp0;
447 BEAST_EXPECT(n0 == Number{0});
448 XRPAmount xrp1{n0};
449 BEAST_EXPECT(xrp1 == xrp0);
450 }
451
452 void
453 test_to_integer()
454 {
455 testcase("test_to_integer");
456 using Case = std::tuple<Number, std::int64_t>;
457 saveNumberRoundMode save{Number::setround(Number::to_nearest)};
458 {
459 Case c[]{
460 {Number{0}, 0},
461 {Number{1}, 1},
462 {Number{2}, 2},
463 {Number{3}, 3},
464 {Number{-1}, -1},
465 {Number{-2}, -2},
466 {Number{-3}, -3},
467 {Number{10}, 10},
468 {Number{99}, 99},
469 {Number{1155}, 1155},
470 {Number{9'999'999'999'999'999, 0}, 9'999'999'999'999'999},
471 {Number{9'999'999'999'999'999, 1}, 99'999'999'999'999'990},
472 {Number{9'999'999'999'999'999, 2}, 999'999'999'999'999'900},
473 {Number{-9'999'999'999'999'999, 2}, -999'999'999'999'999'900},
474 {Number{15, -1}, 2},
475 {Number{14, -1}, 1},
476 {Number{16, -1}, 2},
477 {Number{25, -1}, 2},
478 {Number{6, -1}, 1},
479 {Number{5, -1}, 0},
480 {Number{4, -1}, 0},
481 {Number{-15, -1}, -2},
482 {Number{-14, -1}, -1},
483 {Number{-16, -1}, -2},
484 {Number{-25, -1}, -2},
485 {Number{-6, -1}, -1},
486 {Number{-5, -1}, 0},
487 {Number{-4, -1}, 0}};
488 for (auto const& [x, y] : c)
489 {
490 auto j = static_cast<std::int64_t>(x);
491 BEAST_EXPECT(j == y);
492 }
493 }
494 auto prev_mode = Number::setround(Number::towards_zero);
495 BEAST_EXPECT(prev_mode == Number::to_nearest);
496 {
497 Case c[]{
498 {Number{0}, 0},
499 {Number{1}, 1},
500 {Number{2}, 2},
501 {Number{3}, 3},
502 {Number{-1}, -1},
503 {Number{-2}, -2},
504 {Number{-3}, -3},
505 {Number{10}, 10},
506 {Number{99}, 99},
507 {Number{1155}, 1155},
508 {Number{9'999'999'999'999'999, 0}, 9'999'999'999'999'999},
509 {Number{9'999'999'999'999'999, 1}, 99'999'999'999'999'990},
510 {Number{9'999'999'999'999'999, 2}, 999'999'999'999'999'900},
511 {Number{-9'999'999'999'999'999, 2}, -999'999'999'999'999'900},
512 {Number{15, -1}, 1},
513 {Number{14, -1}, 1},
514 {Number{16, -1}, 1},
515 {Number{25, -1}, 2},
516 {Number{6, -1}, 0},
517 {Number{5, -1}, 0},
518 {Number{4, -1}, 0},
519 {Number{-15, -1}, -1},
520 {Number{-14, -1}, -1},
521 {Number{-16, -1}, -1},
522 {Number{-25, -1}, -2},
523 {Number{-6, -1}, 0},
524 {Number{-5, -1}, 0},
525 {Number{-4, -1}, 0}};
526 for (auto const& [x, y] : c)
527 {
528 auto j = static_cast<std::int64_t>(x);
529 BEAST_EXPECT(j == y);
530 }
531 }
532 prev_mode = Number::setround(Number::downward);
533 BEAST_EXPECT(prev_mode == Number::towards_zero);
534 {
535 Case c[]{
536 {Number{0}, 0},
537 {Number{1}, 1},
538 {Number{2}, 2},
539 {Number{3}, 3},
540 {Number{-1}, -1},
541 {Number{-2}, -2},
542 {Number{-3}, -3},
543 {Number{10}, 10},
544 {Number{99}, 99},
545 {Number{1155}, 1155},
546 {Number{9'999'999'999'999'999, 0}, 9'999'999'999'999'999},
547 {Number{9'999'999'999'999'999, 1}, 99'999'999'999'999'990},
548 {Number{9'999'999'999'999'999, 2}, 999'999'999'999'999'900},
549 {Number{-9'999'999'999'999'999, 2}, -999'999'999'999'999'900},
550 {Number{15, -1}, 1},
551 {Number{14, -1}, 1},
552 {Number{16, -1}, 1},
553 {Number{25, -1}, 2},
554 {Number{6, -1}, 0},
555 {Number{5, -1}, 0},
556 {Number{4, -1}, 0},
557 {Number{-15, -1}, -2},
558 {Number{-14, -1}, -2},
559 {Number{-16, -1}, -2},
560 {Number{-25, -1}, -3},
561 {Number{-6, -1}, -1},
562 {Number{-5, -1}, -1},
563 {Number{-4, -1}, -1}};
564 for (auto const& [x, y] : c)
565 {
566 auto j = static_cast<std::int64_t>(x);
567 BEAST_EXPECT(j == y);
568 }
569 }
570 prev_mode = Number::setround(Number::upward);
571 BEAST_EXPECT(prev_mode == Number::downward);
572 {
573 Case c[]{
574 {Number{0}, 0},
575 {Number{1}, 1},
576 {Number{2}, 2},
577 {Number{3}, 3},
578 {Number{-1}, -1},
579 {Number{-2}, -2},
580 {Number{-3}, -3},
581 {Number{10}, 10},
582 {Number{99}, 99},
583 {Number{1155}, 1155},
584 {Number{9'999'999'999'999'999, 0}, 9'999'999'999'999'999},
585 {Number{9'999'999'999'999'999, 1}, 99'999'999'999'999'990},
586 {Number{9'999'999'999'999'999, 2}, 999'999'999'999'999'900},
587 {Number{-9'999'999'999'999'999, 2}, -999'999'999'999'999'900},
588 {Number{15, -1}, 2},
589 {Number{14, -1}, 2},
590 {Number{16, -1}, 2},
591 {Number{25, -1}, 3},
592 {Number{6, -1}, 1},
593 {Number{5, -1}, 1},
594 {Number{4, -1}, 1},
595 {Number{-15, -1}, -1},
596 {Number{-14, -1}, -1},
597 {Number{-16, -1}, -1},
598 {Number{-25, -1}, -2},
599 {Number{-6, -1}, 0},
600 {Number{-5, -1}, 0},
601 {Number{-4, -1}, 0}};
602 for (auto const& [x, y] : c)
603 {
604 auto j = static_cast<std::int64_t>(x);
605 BEAST_EXPECT(j == y);
606 }
607 }
608 bool caught = false;
609 try
610 {
611 (void)static_cast<std::int64_t>(Number{9223372036854776, 3});
612 }
613 catch (std::overflow_error const&)
614 {
615 caught = true;
616 }
617 BEAST_EXPECT(caught);
618 }
619
620 void
621 test_squelch()
622 {
623 testcase("test_squelch");
624 Number limit{1, -6};
625 BEAST_EXPECT((squelch(Number{2, -6}, limit) == Number{2, -6}));
626 BEAST_EXPECT((squelch(Number{1, -6}, limit) == Number{1, -6}));
627 BEAST_EXPECT((squelch(Number{9, -7}, limit) == Number{0}));
628 BEAST_EXPECT((squelch(Number{-2, -6}, limit) == Number{-2, -6}));
629 BEAST_EXPECT((squelch(Number{-1, -6}, limit) == Number{-1, -6}));
630 BEAST_EXPECT((squelch(Number{-9, -7}, limit) == Number{0}));
631 }
632
633 void
634 testToString()
635 {
636 testcase("testToString");
637 BEAST_EXPECT(to_string(Number(-2, 0)) == "-2");
638 BEAST_EXPECT(to_string(Number(0, 0)) == "0");
639 BEAST_EXPECT(to_string(Number(2, 0)) == "2");
640 BEAST_EXPECT(to_string(Number(25, -3)) == "0.025");
641 BEAST_EXPECT(to_string(Number(-25, -3)) == "-0.025");
642 BEAST_EXPECT(to_string(Number(25, 1)) == "250");
643 BEAST_EXPECT(to_string(Number(-25, 1)) == "-250");
644 BEAST_EXPECT(to_string(Number(2, 20)) == "2000000000000000e5");
645 BEAST_EXPECT(to_string(Number(-2, -20)) == "-2000000000000000e-35");
646 }
647
648 void
649 test_relationals()
650 {
651 testcase("test_relationals");
652 BEAST_EXPECT(!(Number{100} < Number{10}));
653 BEAST_EXPECT(Number{100} > Number{10});
654 BEAST_EXPECT(Number{100} >= Number{10});
655 BEAST_EXPECT(!(Number{100} <= Number{10}));
656 }
657
658 void
659 test_stream()
660 {
661 testcase("test_stream");
662 Number x{100};
663 std::ostringstream os;
664 os << x;
665 BEAST_EXPECT(os.str() == to_string(x));
666 }
667
668 void
669 test_inc_dec()
670 {
671 testcase("test_inc_dec");
672 Number x{100};
673 Number y = +x;
674 BEAST_EXPECT(x == y);
675 BEAST_EXPECT(x++ == y);
676 BEAST_EXPECT(x == Number{101});
677 BEAST_EXPECT(x-- == Number{101});
678 BEAST_EXPECT(x == y);
679 }
680
681 void
682 test_toSTAmount()
683 {
684 NumberSO stNumberSO{true};
685 Issue const issue;
686 Number const n{7'518'783'80596, -5};
687 saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
688 auto res2 = STAmount{issue, n.mantissa(), n.exponent()};
689 BEAST_EXPECT(res2 == STAmount{7518784});
690
691 Number::setround(Number::towards_zero);
692 res2 = STAmount{issue, n.mantissa(), n.exponent()};
693 BEAST_EXPECT(res2 == STAmount{7518783});
694
695 Number::setround(Number::downward);
696 res2 = STAmount{issue, n.mantissa(), n.exponent()};
697 BEAST_EXPECT(res2 == STAmount{7518783});
698
699 Number::setround(Number::upward);
700 res2 = STAmount{issue, n.mantissa(), n.exponent()};
701 BEAST_EXPECT(res2 == STAmount{7518784});
702 }
703
704 void
705 test_truncate()
706 {
707 BEAST_EXPECT(Number(25, +1).truncate() == Number(250, 0));
708 BEAST_EXPECT(Number(25, 0).truncate() == Number(25, 0));
709 BEAST_EXPECT(Number(25, -1).truncate() == Number(2, 0));
710 BEAST_EXPECT(Number(25, -2).truncate() == Number(0, 0));
711 BEAST_EXPECT(Number(99, -2).truncate() == Number(0, 0));
712
713 BEAST_EXPECT(Number(-25, +1).truncate() == Number(-250, 0));
714 BEAST_EXPECT(Number(-25, 0).truncate() == Number(-25, 0));
715 BEAST_EXPECT(Number(-25, -1).truncate() == Number(-2, 0));
716 BEAST_EXPECT(Number(-25, -2).truncate() == Number(0, 0));
717 BEAST_EXPECT(Number(-99, -2).truncate() == Number(0, 0));
718
719 BEAST_EXPECT(Number(0, 0).truncate() == Number(0, 0));
720 BEAST_EXPECT(Number(0, 30000).truncate() == Number(0, 0));
721 BEAST_EXPECT(Number(0, -30000).truncate() == Number(0, 0));
722 BEAST_EXPECT(Number(100, -30000).truncate() == Number(0, 0));
723 BEAST_EXPECT(Number(100, -30000).truncate() == Number(0, 0));
724 BEAST_EXPECT(Number(-100, -30000).truncate() == Number(0, 0));
725 BEAST_EXPECT(Number(-100, -30000).truncate() == Number(0, 0));
726 }
727
728 void
729 run() override
730 {
731 testZero();
732 test_limits();
733 test_add();
734 test_sub();
735 test_mul();
736 test_div();
737 test_root();
738 test_power1();
739 test_power2();
740 testConversions();
741 test_to_integer();
742 test_squelch();
743 testToString();
744 test_relationals();
745 test_stream();
746 test_inc_dec();
747 test_toSTAmount();
748 test_truncate();
749 }
750};
751
752BEAST_DEFINE_TESTSUITE(Number, basics, ripple);
753
754} // namespace ripple
beast::unit_test::suite
A testsuite class.
Definition suite.h:52
beast::unit_test::suite::testcase
testcase_t testcase
Memberspace for declaring test cases.
Definition suite.h:152
ripple::IOUAmount
Floating point representation of amounts with high dynamic range.
Definition IOUAmount.h:27
ripple::Issue
A currency issued by an account.
Definition Issue.h:14
ripple::NumberSO
RAII class to set and restore the Number switchover.
Definition IOUAmount.h:192
ripple::Number_test
Definition Number_test.cpp:12
ripple::Number_test::test_truncate
void test_truncate()
Definition Number_test.cpp:705
ripple::Number_test::test_squelch
void test_squelch()
Definition Number_test.cpp:621
ripple::Number_test::test_sub
void test_sub()
Definition Number_test.cpp:106
ripple::Number_test::test_add
void test_add()
Definition Number_test.cpp:66
ripple::Number_test::testZero
void testZero()
Definition Number_test.cpp:15
ripple::Number_test::test_toSTAmount
void test_toSTAmount()
Definition Number_test.cpp:682
ripple::Number_test::test_stream
void test_stream()
Definition Number_test.cpp:659
ripple::Number_test::run
void run() override
Runs the suite.
Definition Number_test.cpp:729
ripple::Number_test::test_root
void test_root()
Definition Number_test.cpp:326
ripple::Number_test::test_div
void test_div()
Definition Number_test.cpp:237
ripple::Number_test::testConversions
void testConversions()
Definition Number_test.cpp:427
ripple::Number_test::test_to_integer
void test_to_integer()
Definition Number_test.cpp:453
ripple::Number_test::test_inc_dec
void test_inc_dec()
Definition Number_test.cpp:669
ripple::Number_test::test_limits
void test_limits()
Definition Number_test.cpp:30
ripple::Number_test::test_relationals
void test_relationals()
Definition Number_test.cpp:649
ripple::Number_test::testToString
void testToString()
Definition Number_test.cpp:634
ripple::Number_test::test_power1
void test_power1()
Definition Number_test.cpp:365
ripple::Number_test::test_power2
void test_power2()
Definition Number_test.cpp:381
ripple::Number_test::test_mul
void test_mul()
Definition Number_test.cpp:131
ripple::Number::exponent
constexpr int exponent() const noexcept
Definition Number.h:217
ripple::Number::setround
static rounding_mode setround(rounding_mode mode)
Definition Number.cpp:34
std::numeric_limits::max
T max(T... args)
std::numeric_limits::min
T min(T... args)
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:6
ripple::power
Number power(Number const &f, unsigned n)
Definition Number.cpp:594
ripple::to_string
std::string to_string(base_uint< Bits, Tag > const &a)
Definition base_uint.h:611
ripple::root
Number root(Number f, unsigned d)
Definition Number.cpp:617
ripple::squelch
constexpr Number squelch(Number const &x, Number const &limit) noexcept
Definition Number.h:362
std::ostringstream::str
T str(T... args)
Generated by doxygen 1.9.8