rippled
Loading...
Searching...
No Matches
STAmount_test.cpp
1//------------------------------------------------------------------------------
2/*
3 This file is part of rippled: https://github.com/ripple/rippled
4 Copyright (c) 2012, 2013 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/Log.h>
21#include <xrpl/basics/random.h>
22#include <xrpl/beast/unit_test.h>
23#include <xrpl/protocol/STAmount.h>
24
25namespace ripple {
26
27class STAmount_test : public beast::unit_test::suite
28{
29public:
30 static STAmount
31 serializeAndDeserialize(STAmount const& s)
32 {
33 Serializer ser;
34 s.add(ser);
35
36 SerialIter sit(ser.slice());
37 return STAmount(sit, sfGeneric);
38 }
39
40 //--------------------------------------------------------------------------
41 STAmount
42 roundSelf(STAmount const& amount)
43 {
44 if (amount.native())
45 return amount;
46
47 std::uint64_t mantissa = amount.mantissa();
48 std::uint64_t valueDigits = mantissa % 1000000000;
49
50 if (valueDigits == 1)
51 {
52 mantissa--;
53
54 if (mantissa < STAmount::cMinValue)
55 return {
56 amount.issue(),
57 mantissa,
58 amount.exponent(),
59 amount.negative()};
60
61 return {
62 amount.issue(),
63 mantissa,
64 amount.exponent(),
65 amount.negative(),
66 STAmount::unchecked{}};
67 }
68
69 if (valueDigits == 999999999)
70 {
71 mantissa++;
72
73 if (mantissa > STAmount::cMaxValue)
74 return {
75 amount.issue(),
76 mantissa,
77 amount.exponent(),
78 amount.negative()};
79
80 return {
81 amount.issue(),
82 mantissa,
83 amount.exponent(),
84 amount.negative(),
85 STAmount::unchecked{}};
86 }
87
88 return amount;
89 }
90
91 void
92 roundTest(int n, int d, int m)
93 {
94 // check STAmount rounding
95 STAmount num(noIssue(), n);
96 STAmount den(noIssue(), d);
97 STAmount mul(noIssue(), m);
98 STAmount quot = divide(STAmount(n), STAmount(d), noIssue());
99 STAmount res = roundSelf(multiply(quot, mul, noIssue()));
100
101 BEAST_EXPECT(!res.native());
102
103 STAmount cmp(noIssue(), (n * m) / d);
104
105 BEAST_EXPECT(!cmp.native());
106
107 BEAST_EXPECT(cmp.issue().currency == res.issue().currency);
108
109 if (res != cmp)
110 {
111 log << "(" << num.getText() << "/" << den.getText() << ") X "
112 << mul.getText() << " = " << res.getText() << " not "
113 << cmp.getText();
114 fail("Rounding");
115 return;
116 }
117 }
118
119 void
120 mulTest(int a, int b)
121 {
122 STAmount aa(noIssue(), a);
123 STAmount bb(noIssue(), b);
124 STAmount prod1(multiply(aa, bb, noIssue()));
125
126 BEAST_EXPECT(!prod1.native());
127
128 STAmount prod2(
129 noIssue(),
130 static_cast<std::uint64_t>(a) * static_cast<std::uint64_t>(b));
131
132 if (prod1 != prod2)
133 {
134 log << "nn(" << aa.getFullText() << " * " << bb.getFullText()
135 << ") = " << prod1.getFullText() << " not "
136 << prod2.getFullText();
137 fail("Multiplication result is not exact");
138 }
139 }
140
141 //--------------------------------------------------------------------------
142
143 void
144 testSetValue(
145 std::string const& value,
146 Issue const& issue,
147 bool success = true)
148 {
149 try
150 {
151 STAmount const amount = amountFromString(issue, value);
152 BEAST_EXPECT(amount.getText() == value);
153 }
154 catch (std::exception const&)
155 {
156 BEAST_EXPECT(!success);
157 }
158 }
159
160 void
161 testSetValue()
162 {
163 {
164 testcase("set value (native)");
165
166 Issue const xrp(xrpIssue());
167
168 // fractional XRP (i.e. drops)
169 testSetValue("1", xrp);
170 testSetValue("22", xrp);
171 testSetValue("333", xrp);
172 testSetValue("4444", xrp);
173 testSetValue("55555", xrp);
174 testSetValue("666666", xrp);
175
176 // 1 XRP up to 100 billion, in powers of 10 (in drops)
177 testSetValue("1000000", xrp);
178 testSetValue("10000000", xrp);
179 testSetValue("100000000", xrp);
180 testSetValue("1000000000", xrp);
181 testSetValue("10000000000", xrp);
182 testSetValue("100000000000", xrp);
183 testSetValue("1000000000000", xrp);
184 testSetValue("10000000000000", xrp);
185 testSetValue("100000000000000", xrp);
186 testSetValue("1000000000000000", xrp);
187 testSetValue("10000000000000000", xrp);
188 testSetValue("100000000000000000", xrp);
189
190 // Invalid native values:
191 testSetValue("1.1", xrp, false);
192 testSetValue("100000000000000001", xrp, false);
193 testSetValue("1000000000000000000", xrp, false);
194 }
195
196 {
197 testcase("set value (iou)");
198
199 Issue const usd(Currency(0x5553440000000000), AccountID(0x4985601));
200
201 testSetValue("1", usd);
202 testSetValue("10", usd);
203 testSetValue("100", usd);
204 testSetValue("1000", usd);
205 testSetValue("10000", usd);
206 testSetValue("100000", usd);
207 testSetValue("1000000", usd);
208 testSetValue("10000000", usd);
209 testSetValue("100000000", usd);
210 testSetValue("1000000000", usd);
211 testSetValue("10000000000", usd);
212
213 testSetValue("1234567.1", usd);
214 testSetValue("1234567.12", usd);
215 testSetValue("1234567.123", usd);
216 testSetValue("1234567.1234", usd);
217 testSetValue("1234567.12345", usd);
218 testSetValue("1234567.123456", usd);
219 testSetValue("1234567.1234567", usd);
220 testSetValue("1234567.12345678", usd);
221 testSetValue("1234567.123456789", usd);
222 }
223 }
224
225 //--------------------------------------------------------------------------
226
227 void
228 testNativeCurrency()
229 {
230 testcase("native currency");
231 STAmount zeroSt, one(1), hundred(100);
232 // VFALCO NOTE Why repeat "STAmount fail" so many times??
233 unexpected(serializeAndDeserialize(zeroSt) != zeroSt, "STAmount fail");
234 unexpected(serializeAndDeserialize(one) != one, "STAmount fail");
235 unexpected(
236 serializeAndDeserialize(hundred) != hundred, "STAmount fail");
237 unexpected(!zeroSt.native(), "STAmount fail");
238 unexpected(!hundred.native(), "STAmount fail");
239 unexpected(zeroSt != beast::zero, "STAmount fail");
240 unexpected(one == beast::zero, "STAmount fail");
241 unexpected(hundred == beast::zero, "STAmount fail");
242 unexpected((zeroSt < zeroSt), "STAmount fail");
243 unexpected(!(zeroSt < one), "STAmount fail");
244 unexpected(!(zeroSt < hundred), "STAmount fail");
245 unexpected((one < zeroSt), "STAmount fail");
246 unexpected((one < one), "STAmount fail");
247 unexpected(!(one < hundred), "STAmount fail");
248 unexpected((hundred < zeroSt), "STAmount fail");
249 unexpected((hundred < one), "STAmount fail");
250 unexpected((hundred < hundred), "STAmount fail");
251 unexpected((zeroSt > zeroSt), "STAmount fail");
252 unexpected((zeroSt > one), "STAmount fail");
253 unexpected((zeroSt > hundred), "STAmount fail");
254 unexpected(!(one > zeroSt), "STAmount fail");
255 unexpected((one > one), "STAmount fail");
256 unexpected((one > hundred), "STAmount fail");
257 unexpected(!(hundred > zeroSt), "STAmount fail");
258 unexpected(!(hundred > one), "STAmount fail");
259 unexpected((hundred > hundred), "STAmount fail");
260 unexpected(!(zeroSt <= zeroSt), "STAmount fail");
261 unexpected(!(zeroSt <= one), "STAmount fail");
262 unexpected(!(zeroSt <= hundred), "STAmount fail");
263 unexpected((one <= zeroSt), "STAmount fail");
264 unexpected(!(one <= one), "STAmount fail");
265 unexpected(!(one <= hundred), "STAmount fail");
266 unexpected((hundred <= zeroSt), "STAmount fail");
267 unexpected((hundred <= one), "STAmount fail");
268 unexpected(!(hundred <= hundred), "STAmount fail");
269 unexpected(!(zeroSt >= zeroSt), "STAmount fail");
270 unexpected((zeroSt >= one), "STAmount fail");
271 unexpected((zeroSt >= hundred), "STAmount fail");
272 unexpected(!(one >= zeroSt), "STAmount fail");
273 unexpected(!(one >= one), "STAmount fail");
274 unexpected((one >= hundred), "STAmount fail");
275 unexpected(!(hundred >= zeroSt), "STAmount fail");
276 unexpected(!(hundred >= one), "STAmount fail");
277 unexpected(!(hundred >= hundred), "STAmount fail");
278 unexpected(!(zeroSt == zeroSt), "STAmount fail");
279 unexpected((zeroSt == one), "STAmount fail");
280 unexpected((zeroSt == hundred), "STAmount fail");
281 unexpected((one == zeroSt), "STAmount fail");
282 unexpected(!(one == one), "STAmount fail");
283 unexpected((one == hundred), "STAmount fail");
284 unexpected((hundred == zeroSt), "STAmount fail");
285 unexpected((hundred == one), "STAmount fail");
286 unexpected(!(hundred == hundred), "STAmount fail");
287 unexpected((zeroSt != zeroSt), "STAmount fail");
288 unexpected(!(zeroSt != one), "STAmount fail");
289 unexpected(!(zeroSt != hundred), "STAmount fail");
290 unexpected(!(one != zeroSt), "STAmount fail");
291 unexpected((one != one), "STAmount fail");
292 unexpected(!(one != hundred), "STAmount fail");
293 unexpected(!(hundred != zeroSt), "STAmount fail");
294 unexpected(!(hundred != one), "STAmount fail");
295 unexpected((hundred != hundred), "STAmount fail");
296 unexpected(STAmount().getText() != "0", "STAmount fail");
297 unexpected(STAmount(31).getText() != "31", "STAmount fail");
298 unexpected(STAmount(310).getText() != "310", "STAmount fail");
299 unexpected(to_string(Currency()) != "XRP", "cHC(XRP)");
300 Currency c;
301 unexpected(!to_currency(c, "USD"), "create USD currency");
302 unexpected(to_string(c) != "USD", "check USD currency");
303
304 const std::string cur = "015841551A748AD2C1F76FF6ECB0CCCD00000000";
305 unexpected(!to_currency(c, cur), "create custom currency");
306 unexpected(to_string(c) != cur, "check custom currency");
307 }
308
309 //--------------------------------------------------------------------------
310
311 void
312 testCustomCurrency()
313 {
314 testcase("custom currency");
315 STAmount zeroSt(noIssue()), one(noIssue(), 1), hundred(noIssue(), 100);
316 unexpected(serializeAndDeserialize(zeroSt) != zeroSt, "STAmount fail");
317 unexpected(serializeAndDeserialize(one) != one, "STAmount fail");
318 unexpected(
319 serializeAndDeserialize(hundred) != hundred, "STAmount fail");
320 unexpected(zeroSt.native(), "STAmount fail");
321 unexpected(hundred.native(), "STAmount fail");
322 unexpected(zeroSt != beast::zero, "STAmount fail");
323 unexpected(one == beast::zero, "STAmount fail");
324 unexpected(hundred == beast::zero, "STAmount fail");
325 unexpected((zeroSt < zeroSt), "STAmount fail");
326 unexpected(!(zeroSt < one), "STAmount fail");
327 unexpected(!(zeroSt < hundred), "STAmount fail");
328 unexpected((one < zeroSt), "STAmount fail");
329 unexpected((one < one), "STAmount fail");
330 unexpected(!(one < hundred), "STAmount fail");
331 unexpected((hundred < zeroSt), "STAmount fail");
332 unexpected((hundred < one), "STAmount fail");
333 unexpected((hundred < hundred), "STAmount fail");
334 unexpected((zeroSt > zeroSt), "STAmount fail");
335 unexpected((zeroSt > one), "STAmount fail");
336 unexpected((zeroSt > hundred), "STAmount fail");
337 unexpected(!(one > zeroSt), "STAmount fail");
338 unexpected((one > one), "STAmount fail");
339 unexpected((one > hundred), "STAmount fail");
340 unexpected(!(hundred > zeroSt), "STAmount fail");
341 unexpected(!(hundred > one), "STAmount fail");
342 unexpected((hundred > hundred), "STAmount fail");
343 unexpected(!(zeroSt <= zeroSt), "STAmount fail");
344 unexpected(!(zeroSt <= one), "STAmount fail");
345 unexpected(!(zeroSt <= hundred), "STAmount fail");
346 unexpected((one <= zeroSt), "STAmount fail");
347 unexpected(!(one <= one), "STAmount fail");
348 unexpected(!(one <= hundred), "STAmount fail");
349 unexpected((hundred <= zeroSt), "STAmount fail");
350 unexpected((hundred <= one), "STAmount fail");
351 unexpected(!(hundred <= hundred), "STAmount fail");
352 unexpected(!(zeroSt >= zeroSt), "STAmount fail");
353 unexpected((zeroSt >= one), "STAmount fail");
354 unexpected((zeroSt >= hundred), "STAmount fail");
355 unexpected(!(one >= zeroSt), "STAmount fail");
356 unexpected(!(one >= one), "STAmount fail");
357 unexpected((one >= hundred), "STAmount fail");
358 unexpected(!(hundred >= zeroSt), "STAmount fail");
359 unexpected(!(hundred >= one), "STAmount fail");
360 unexpected(!(hundred >= hundred), "STAmount fail");
361 unexpected(!(zeroSt == zeroSt), "STAmount fail");
362 unexpected((zeroSt == one), "STAmount fail");
363 unexpected((zeroSt == hundred), "STAmount fail");
364 unexpected((one == zeroSt), "STAmount fail");
365 unexpected(!(one == one), "STAmount fail");
366 unexpected((one == hundred), "STAmount fail");
367 unexpected((hundred == zeroSt), "STAmount fail");
368 unexpected((hundred == one), "STAmount fail");
369 unexpected(!(hundred == hundred), "STAmount fail");
370 unexpected((zeroSt != zeroSt), "STAmount fail");
371 unexpected(!(zeroSt != one), "STAmount fail");
372 unexpected(!(zeroSt != hundred), "STAmount fail");
373 unexpected(!(one != zeroSt), "STAmount fail");
374 unexpected((one != one), "STAmount fail");
375 unexpected(!(one != hundred), "STAmount fail");
376 unexpected(!(hundred != zeroSt), "STAmount fail");
377 unexpected(!(hundred != one), "STAmount fail");
378 unexpected((hundred != hundred), "STAmount fail");
379 unexpected(STAmount(noIssue()).getText() != "0", "STAmount fail");
380 unexpected(STAmount(noIssue(), 31).getText() != "31", "STAmount fail");
381 unexpected(
382 STAmount(noIssue(), 31, 1).getText() != "310", "STAmount fail");
383 unexpected(
384 STAmount(noIssue(), 31, -1).getText() != "3.1", "STAmount fail");
385 unexpected(
386 STAmount(noIssue(), 31, -2).getText() != "0.31", "STAmount fail");
387 unexpected(
388 multiply(STAmount(noIssue(), 20), STAmount(3), noIssue())
389 .getText() != "60",
390 "STAmount multiply fail 1");
391 unexpected(
392 multiply(STAmount(noIssue(), 20), STAmount(3), xrpIssue())
393 .getText() != "60",
394 "STAmount multiply fail 2");
395 unexpected(
396 multiply(STAmount(20), STAmount(3), noIssue()).getText() != "60",
397 "STAmount multiply fail 3");
398 unexpected(
399 multiply(STAmount(20), STAmount(3), xrpIssue()).getText() != "60",
400 "STAmount multiply fail 4");
401
402 if (divide(STAmount(noIssue(), 60), STAmount(3), noIssue()).getText() !=
403 "20")
404 {
405 log << "60/3 = "
406 << divide(STAmount(noIssue(), 60), STAmount(3), noIssue())
407 .getText();
408 fail("STAmount divide fail");
409 }
410 else
411 {
412 pass();
413 }
414
415 unexpected(
416 divide(STAmount(noIssue(), 60), STAmount(3), xrpIssue())
417 .getText() != "20",
418 "STAmount divide fail");
419
420 unexpected(
421 divide(STAmount(noIssue(), 60), STAmount(noIssue(), 3), noIssue())
422 .getText() != "20",
423 "STAmount divide fail");
424
425 unexpected(
426 divide(STAmount(noIssue(), 60), STAmount(noIssue(), 3), xrpIssue())
427 .getText() != "20",
428 "STAmount divide fail");
429
430 STAmount a1(noIssue(), 60), a2(noIssue(), 10, -1);
431
432 unexpected(
433 divide(a2, a1, noIssue()) != amountFromQuality(getRate(a1, a2)),
434 "STAmount setRate(getRate) fail");
435
436 unexpected(
437 divide(a1, a2, noIssue()) != amountFromQuality(getRate(a2, a1)),
438 "STAmount setRate(getRate) fail");
439 }
440
441 //--------------------------------------------------------------------------
442
443 void
444 testArithmetic()
445 {
446 testcase("arithmetic");
447
448 // Test currency multiplication and division operations such as
449 // convertToDisplayAmount, convertToInternalAmount, getRate, getClaimed,
450 // and getNeeded
451
452 unexpected(
453 getRate(STAmount(1), STAmount(10)) !=
454 (((100ull - 14) << (64 - 8)) | 1000000000000000ull),
455 "STAmount getRate fail 1");
456
457 unexpected(
458 getRate(STAmount(10), STAmount(1)) !=
459 (((100ull - 16) << (64 - 8)) | 1000000000000000ull),
460 "STAmount getRate fail 2");
461
462 unexpected(
463 getRate(STAmount(noIssue(), 1), STAmount(noIssue(), 10)) !=
464 (((100ull - 14) << (64 - 8)) | 1000000000000000ull),
465 "STAmount getRate fail 3");
466
467 unexpected(
468 getRate(STAmount(noIssue(), 10), STAmount(noIssue(), 1)) !=
469 (((100ull - 16) << (64 - 8)) | 1000000000000000ull),
470 "STAmount getRate fail 4");
471
472 unexpected(
473 getRate(STAmount(noIssue(), 1), STAmount(10)) !=
474 (((100ull - 14) << (64 - 8)) | 1000000000000000ull),
475 "STAmount getRate fail 5");
476
477 unexpected(
478 getRate(STAmount(noIssue(), 10), STAmount(1)) !=
479 (((100ull - 16) << (64 - 8)) | 1000000000000000ull),
480 "STAmount getRate fail 6");
481
482 unexpected(
483 getRate(STAmount(1), STAmount(noIssue(), 10)) !=
484 (((100ull - 14) << (64 - 8)) | 1000000000000000ull),
485 "STAmount getRate fail 7");
486
487 unexpected(
488 getRate(STAmount(10), STAmount(noIssue(), 1)) !=
489 (((100ull - 16) << (64 - 8)) | 1000000000000000ull),
490 "STAmount getRate fail 8");
491
492 roundTest(1, 3, 3);
493 roundTest(2, 3, 9);
494 roundTest(1, 7, 21);
495 roundTest(1, 2, 4);
496 roundTest(3, 9, 18);
497 roundTest(7, 11, 44);
498
499 for (int i = 0; i <= 100000; ++i)
500 {
501 mulTest(rand_int(10000000), rand_int(10000000));
502 }
503 }
504
505 //--------------------------------------------------------------------------
506
507 void
508 testUnderflow()
509 {
510 testcase("underflow");
511
512 STAmount bigNative(STAmount::cMaxNative / 2);
513 STAmount bigValue(
514 noIssue(),
515 (STAmount::cMinValue + STAmount::cMaxValue) / 2,
516 STAmount::cMaxOffset - 1);
517 STAmount smallValue(
518 noIssue(),
519 (STAmount::cMinValue + STAmount::cMaxValue) / 2,
520 STAmount::cMinOffset + 1);
521 STAmount zeroSt(noIssue(), 0);
522
523 STAmount smallXsmall = multiply(smallValue, smallValue, noIssue());
524
525 BEAST_EXPECT(smallXsmall == beast::zero);
526
527 STAmount bigDsmall = divide(smallValue, bigValue, noIssue());
528
529 BEAST_EXPECT(bigDsmall == beast::zero);
530
531 BEAST_EXPECT(bigDsmall == beast::zero);
532
533 bigDsmall = divide(smallValue, bigValue, xrpIssue());
534
535 BEAST_EXPECT(bigDsmall == beast::zero);
536
537 bigDsmall = divide(smallValue, bigNative, xrpIssue());
538
539 BEAST_EXPECT(bigDsmall == beast::zero);
540
541 // very bad offer
542 std::uint64_t r = getRate(smallValue, bigValue);
543
544 BEAST_EXPECT(r == 0);
545
546 // very good offer
547 r = getRate(bigValue, smallValue);
548
549 BEAST_EXPECT(r == 0);
550 }
551
552 //--------------------------------------------------------------------------
553
554 void
555 testRounding()
556 {
557 // VFALCO TODO There are no actual tests here, just printed output?
558 // Change this to actually do something.
559
560#if 0
561 beginTestCase ("rounding ");
562
563 std::uint64_t value = 25000000000000000ull;
564 int offset = -14;
565 canonicalizeRound (false, value, offset, true);
566
567 STAmount one (noIssue(), 1);
568 STAmount two (noIssue(), 2);
569 STAmount three (noIssue(), 3);
570
571 STAmount oneThird1 = divRound (one, three, noIssue(), false);
572 STAmount oneThird2 = divide (one, three, noIssue());
573 STAmount oneThird3 = divRound (one, three, noIssue(), true);
574 log << oneThird1;
575 log << oneThird2;
576 log << oneThird3;
577
578 STAmount twoThird1 = divRound (two, three, noIssue(), false);
579 STAmount twoThird2 = divide (two, three, noIssue());
580 STAmount twoThird3 = divRound (two, three, noIssue(), true);
581 log << twoThird1;
582 log << twoThird2;
583 log << twoThird3;
584
585 STAmount oneA = mulRound (oneThird1, three, noIssue(), false);
586 STAmount oneB = multiply (oneThird2, three, noIssue());
587 STAmount oneC = mulRound (oneThird3, three, noIssue(), true);
588 log << oneA;
589 log << oneB;
590 log << oneC;
591
592 STAmount fourThirdsB = twoThird2 + twoThird2;
593 log << fourThirdsA;
594 log << fourThirdsB;
595 log << fourThirdsC;
596
597 STAmount dripTest1 = mulRound (twoThird2, two, xrpIssue (), false);
598 STAmount dripTest2 = multiply (twoThird2, two, xrpIssue ());
599 STAmount dripTest3 = mulRound (twoThird2, two, xrpIssue (), true);
600 log << dripTest1;
601 log << dripTest2;
602 log << dripTest3;
603#endif
604 }
605
606 void
607 testConvertXRP()
608 {
609 testcase("STAmount to XRPAmount conversions");
610
611 Issue const usd{Currency(0x5553440000000000), AccountID(0x4985601)};
612 Issue const xrp{xrpIssue()};
613
614 for (std::uint64_t drops = 100000000000000000; drops != 1;
615 drops = drops / 10)
616 {
617 auto const t = amountFromString(xrp, std::to_string(drops));
618 auto const s = t.xrp();
619 BEAST_EXPECT(s.drops() == drops);
620 BEAST_EXPECT(t == STAmount(XRPAmount(drops)));
621 BEAST_EXPECT(s == XRPAmount(drops));
622 }
623
624 try
625 {
626 auto const t = amountFromString(usd, "136500");
627 fail(to_string(t.xrp()));
628 }
629 catch (std::logic_error const&)
630 {
631 pass();
632 }
633 catch (std::exception const&)
634 {
635 fail("wrong exception");
636 }
637 }
638
639 void
640 testConvertIOU()
641 {
642 testcase("STAmount to IOUAmount conversions");
643
644 Issue const usd{Currency(0x5553440000000000), AccountID(0x4985601)};
645 Issue const xrp{xrpIssue()};
646
647 for (std::uint64_t dollars = 10000000000; dollars != 1;
648 dollars = dollars / 10)
649 {
650 auto const t = amountFromString(usd, std::to_string(dollars));
651 auto const s = t.iou();
652 BEAST_EXPECT(t == STAmount(s, usd));
653 BEAST_EXPECT(s.mantissa() == t.mantissa());
654 BEAST_EXPECT(s.exponent() == t.exponent());
655 }
656
657 try
658 {
659 auto const t = amountFromString(xrp, "136500");
660 fail(to_string(t.iou()));
661 }
662 catch (std::logic_error const&)
663 {
664 pass();
665 }
666 catch (std::exception const&)
667 {
668 fail("wrong exception");
669 }
670 }
671
672 //--------------------------------------------------------------------------
673
674 void
675 run() override
676 {
677 testSetValue();
678 testNativeCurrency();
679 testCustomCurrency();
680 testArithmetic();
681 testUnderflow();
682 testRounding();
683 testConvertXRP();
684 testConvertIOU();
685 }
686};
687
688BEAST_DEFINE_TESTSUITE(STAmount, ripple_data, ripple);
689
690} // namespace ripple
beast::unit_test::suite
A testsuite class.
Definition: suite.h:53
beast::unit_test::suite::log
log_os< char > log
Logging output stream.
Definition: suite.h:150
beast::unit_test::suite::pass
void pass()
Record a successful test condition.
Definition: suite.h:509
beast::unit_test::suite::unexpected
bool unexpected(Condition shouldBeFalse, String const &reason)
Definition: suite.h:497
beast::unit_test::suite::testcase
testcase_t testcase
Memberspace for declaring test cases.
Definition: suite.h:153
beast::unit_test::suite::fail
void fail(String const &reason, char const *file, int line)
Record a failure.
Definition: suite.h:531
ripple::Issue
A currency issued by an account.
Definition: Issue.h:36
ripple::Issue::currency
Currency currency
Definition: Issue.h:38
ripple::STAmount_test
Definition: STAmount_test.cpp:28
ripple::STAmount_test::roundTest
void roundTest(int n, int d, int m)
Definition: STAmount_test.cpp:92
ripple::STAmount_test::testNativeCurrency
void testNativeCurrency()
Definition: STAmount_test.cpp:228
ripple::STAmount_test::roundSelf
STAmount roundSelf(STAmount const &amount)
Definition: STAmount_test.cpp:42
ripple::STAmount_test::serializeAndDeserialize
static STAmount serializeAndDeserialize(STAmount const &s)
Definition: STAmount_test.cpp:31
ripple::STAmount_test::testArithmetic
void testArithmetic()
Definition: STAmount_test.cpp:444
ripple::STAmount_test::testSetValue
void testSetValue(std::string const &value, Issue const &issue, bool success=true)
Definition: STAmount_test.cpp:144
ripple::STAmount_test::testSetValue
void testSetValue()
Definition: STAmount_test.cpp:161
ripple::STAmount_test::testConvertIOU
void testConvertIOU()
Definition: STAmount_test.cpp:640
ripple::STAmount_test::testCustomCurrency
void testCustomCurrency()
Definition: STAmount_test.cpp:312
ripple::STAmount_test::testConvertXRP
void testConvertXRP()
Definition: STAmount_test.cpp:607
ripple::STAmount_test::testRounding
void testRounding()
Definition: STAmount_test.cpp:555
ripple::STAmount_test::mulTest
void mulTest(int a, int b)
Definition: STAmount_test.cpp:120
ripple::STAmount_test::testUnderflow
void testUnderflow()
Definition: STAmount_test.cpp:508
ripple::STAmount_test::run
void run() override
Runs the suite.
Definition: STAmount_test.cpp:675
ripple::STAmount::exponent
int exponent() const noexcept
Definition: STAmount.h:443
ripple::STAmount::cMaxNative
static const std::uint64_t cMaxNative
Definition: STAmount.h:71
ripple::STAmount::add
void add(Serializer &s) const override
Definition: STAmount.cpp:612
ripple::STAmount::cMaxOffset
static const int cMaxOffset
Definition: STAmount.h:66
ripple::STAmount::getText
std::string getText() const override
Definition: STAmount.cpp:515
ripple::STAmount::negative
bool negative() const noexcept
Definition: STAmount.h:462
ripple::STAmount::issue
Issue const & issue() const
Definition: STAmount.h:487
ripple::STAmount::cMinValue
static const std::uint64_t cMinValue
Definition: STAmount.h:69
ripple::STAmount::cMinOffset
static const int cMinOffset
Definition: STAmount.h:65
ripple::STAmount::mantissa
std::uint64_t mantissa() const noexcept
Definition: STAmount.h:468
ripple::STAmount::getFullText
std::string getFullText() const override
Definition: STAmount.cpp:505
ripple::STAmount::native
bool native() const noexcept
Definition: STAmount.h:449
ripple::STAmount::cMaxValue
static const std::uint64_t cMaxValue
Definition: STAmount.h:70
ripple::Serializer::slice
Slice slice() const noexcept
Definition: Serializer.h:66
ripple::base_uint< 160, detail::CurrencyTag >
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: algorithm.h:26
ripple::AccountID
base_uint< 160, detail::AccountIDTag > AccountID
A 160-bit unsigned that uniquely identifies an account.
Definition: AccountID.h:49
ripple::xrpIssue
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
Definition: Issue.h:118
ripple::amountFromString
STAmount amountFromString(Asset const &issue, std::string const &amount)
Definition: STAmount.cpp:834
ripple::divide
STAmount divide(STAmount const &amount, Rate const &rate)
Definition: Rate2.cpp:87
ripple::one
constexpr Number one
Definition: Number.cpp:169
ripple::rand_int
std::enable_if_t< std::is_integral< Integral >::value, Integral > rand_int()
Definition: include/xrpl/basics/random.h:159
ripple::sfGeneric
SField const sfGeneric
ripple::amountFromQuality
STAmount amountFromQuality(std::uint64_t rate)
Definition: STAmount.cpp:822
ripple::multiply
STAmount multiply(STAmount const &amount, Rate const &rate)
Definition: Rate2.cpp:47
ripple::getRate
std::uint64_t getRate(STAmount const &offerOut, STAmount const &offerIn)
Definition: STAmount.cpp:451
ripple::Currency
base_uint< 160, detail::CurrencyTag > Currency
Currency is a hash representing a specific currency.
Definition: UintTypes.h:56
ripple::noIssue
Issue const & noIssue()
Returns an asset specifier that represents no account and currency.
Definition: Issue.h:126
ripple::divRound
STAmount divRound(STAmount const &v1, STAmount const &v2, Asset const &asset, bool roundUp)
Definition: STAmount.cpp:1617
ripple::to_string
std::string to_string(base_uint< Bits, Tag > const &a)
Definition: base_uint.h:629
ripple::mulRound
STAmount mulRound(STAmount const &v1, STAmount const &v2, Asset const &asset, bool roundUp)
Definition: STAmount.cpp:1510
ripple::to_currency
bool to_currency(Currency &, std::string const &)
Tries to convert a string to a Currency, returns true on success.
Definition: UintTypes.cpp:80
ripple::canonicalizeRound
static void canonicalizeRound(bool native, std::uint64_t &value, int &offset, bool)
Definition: STAmount.cpp:1298
std::to_string
T to_string(T... args)
Generated by doxygen 1.9.5