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