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