xrpld
Loading...
Searching...
No Matches
STNumber_test.cpp
1#include <xrpl/basics/Number.h>
2#include <xrpl/beast/unit_test/suite.h>
3#include <xrpl/json/json_forwards.h>
4#include <xrpl/protocol/IOUAmount.h>
5#include <xrpl/protocol/Issue.h>
6#include <xrpl/protocol/SField.h>
7#include <xrpl/protocol/STAmount.h>
8#include <xrpl/protocol/STNumber.h>
9#include <xrpl/protocol/Serializer.h>
10
11#include <cstdint>
12#include <exception>
13#include <initializer_list>
14#include <limits>
15#include <sstream>
16#include <stdexcept>
17#include <string>
18#include <type_traits>
19#include <typeinfo>
20
21namespace xrpl {
22
24{
25 void
27 {
28 STNumber const before{sfNumber, number};
29 BEAST_EXPECT(number == before);
30 Serializer s;
31 before.add(s);
32 BEAST_EXPECT(s.size() == 12);
33 SerialIter sit(s.slice());
34 STNumber const after{sit, sfNumber};
35 BEAST_EXPECT(after.isEquivalent(before));
36 BEAST_EXPECT(number == after);
37 }
38
39 void
41 {
42 {
43 STNumber const stnum{sfNumber};
44 BEAST_EXPECT(stnum.getSType() == STI_NUMBER);
45 BEAST_EXPECT(stnum.getText() == "0");
46 BEAST_EXPECT(stnum.isDefault() == true);
47 BEAST_EXPECT(stnum.value() == Number{0});
48 }
49
50 std::initializer_list<std::int64_t> const mantissas = {
52 -1,
53 0,
54 1,
56 };
57 for (std::int64_t const mantissa : mantissas)
58 testCombo(Number{mantissa});
59
60 std::initializer_list<std::int32_t> const exponents = {
62 -1,
63 0,
64 1,
66 };
67 for (std::int32_t const exponent : exponents)
68 testCombo(Number{123, exponent});
69
70 {
71 STAmount const strikePrice{noIssue(), 100};
72 STNumber const factor{sfNumber, 100};
73 auto const iouValue = strikePrice.iou();
74 IOUAmount const totalValue{iouValue * factor};
75 STAmount const totalAmount{totalValue, strikePrice.get<Issue>()};
76 BEAST_EXPECT(totalAmount == Number{10'000});
77 }
78
79 {
80 BEAST_EXPECT(numberFromJson(sfNumber, json::Value(42)) == STNumber(sfNumber, 42));
81 BEAST_EXPECT(numberFromJson(sfNumber, json::Value(-42)) == STNumber(sfNumber, -42));
82
83 BEAST_EXPECT(numberFromJson(sfNumber, json::UInt(42)) == STNumber(sfNumber, 42));
84
85 BEAST_EXPECT(numberFromJson(sfNumber, "-123") == STNumber(sfNumber, -123));
86
87 BEAST_EXPECT(numberFromJson(sfNumber, "123") == STNumber(sfNumber, 123));
88 BEAST_EXPECT(numberFromJson(sfNumber, "-123") == STNumber(sfNumber, -123));
89
90 BEAST_EXPECT(numberFromJson(sfNumber, "3.14") == STNumber(sfNumber, Number(314, -2)));
91 BEAST_EXPECT(numberFromJson(sfNumber, "-3.14") == STNumber(sfNumber, -Number(314, -2)));
92 BEAST_EXPECT(numberFromJson(sfNumber, "3.14e2") == STNumber(sfNumber, 314));
93 BEAST_EXPECT(numberFromJson(sfNumber, "-3.14e2") == STNumber(sfNumber, -314));
94
95 BEAST_EXPECT(numberFromJson(sfNumber, "1000e-2") == STNumber(sfNumber, 10));
96 BEAST_EXPECT(numberFromJson(sfNumber, "-1000e-2") == STNumber(sfNumber, -10));
97
98 BEAST_EXPECT(numberFromJson(sfNumber, "0") == STNumber(sfNumber, 0));
99 BEAST_EXPECT(numberFromJson(sfNumber, "0.0") == STNumber(sfNumber, 0));
100 BEAST_EXPECT(numberFromJson(sfNumber, "0.000") == STNumber(sfNumber, 0));
101 BEAST_EXPECT(numberFromJson(sfNumber, "-0") == STNumber(sfNumber, 0));
102 BEAST_EXPECT(numberFromJson(sfNumber, "-0.0") == STNumber(sfNumber, 0));
103 BEAST_EXPECT(numberFromJson(sfNumber, "-0.000") == STNumber(sfNumber, 0));
104 BEAST_EXPECT(numberFromJson(sfNumber, "0e6") == STNumber(sfNumber, 0));
105 BEAST_EXPECT(numberFromJson(sfNumber, "0.0e6") == STNumber(sfNumber, 0));
106 BEAST_EXPECT(numberFromJson(sfNumber, "0.000e6") == STNumber(sfNumber, 0));
107 BEAST_EXPECT(numberFromJson(sfNumber, "-0e6") == STNumber(sfNumber, 0));
108 BEAST_EXPECT(numberFromJson(sfNumber, "-0.0e6") == STNumber(sfNumber, 0));
109 BEAST_EXPECT(numberFromJson(sfNumber, "-0.000e6") == STNumber(sfNumber, 0));
110
111 {
112 auto const parseNumber = [](std::string const& boundary) {
113 return numberFromJson(sfNumber, boundary);
114 };
115 auto const expectParseThrows = [this, &parseNumber](std::string const& boundary) {
116 try
117 {
118 parseNumber(boundary);
119 fail();
120 }
121 catch (std::exception const& e)
122 {
123 BEAST_EXPECT(std::string(e.what()) == "number cannot be represented");
124 }
125 };
126
127 // Small rejects this; large scales parse it as 9223372036854775800e-1.
128 auto constexpr positiveBoundary = "922337203685477580";
129 auto constexpr negativeBoundary = "-922337203685477580";
131 {
132 expectParseThrows(positiveBoundary);
133 expectParseThrows(negativeBoundary);
134 }
135 else
136 {
137 BEAST_EXPECT(
138 parseNumber(positiveBoundary) ==
139 STNumber(sfNumber, Number{922'337'203'685'477'580, 0}));
140 BEAST_EXPECT(
141 parseNumber(negativeBoundary) ==
142 STNumber(sfNumber, Number{-922'337'203'685'477'580, 0}));
143 }
144
146 // maxint64 9,223,372,036,854,775,807
148 // minint64 -9,223,372,036,854,775,808
151 {
152 // min/maxInt can't be exactly represented with the small mantissa, so they
153 // don't parse, and are expected to throw.
154 expectParseThrows(maxInt);
155 expectParseThrows(minInt);
156 }
157 else
158 {
159 // with large mantissas, maxint is fine
160 BEAST_EXPECT(
161 parseNumber(maxInt) ==
162 STNumber(sfNumber, Number{9'223'372'036'854'775'807, 0}));
163 // but minint's mantissa is > kMaxRep, and so rounds, and thus can't be parsed
164 expectParseThrows(minInt);
165 }
166 }
167
168 constexpr auto kIMin = std::numeric_limits<int>::min();
169 BEAST_EXPECT(numberFromJson(sfNumber, kIMin) == STNumber(sfNumber, Number(kIMin, 0)));
170 BEAST_EXPECT(
171 numberFromJson(sfNumber, std::to_string(kIMin)) ==
172 STNumber(sfNumber, Number(kIMin, 0)));
173
174 constexpr auto kIMax = std::numeric_limits<int>::max();
175 BEAST_EXPECT(numberFromJson(sfNumber, kIMax) == STNumber(sfNumber, Number(kIMax, 0)));
176 BEAST_EXPECT(
177 numberFromJson(sfNumber, std::to_string(kIMax)) ==
178 STNumber(sfNumber, Number(kIMax, 0)));
179
180 constexpr auto kUMax = std::numeric_limits<unsigned int>::max();
181 BEAST_EXPECT(numberFromJson(sfNumber, kUMax) == STNumber(sfNumber, Number(kUMax, 0)));
182 BEAST_EXPECT(
183 numberFromJson(sfNumber, std::to_string(kUMax)) ==
184 STNumber(sfNumber, Number(kUMax, 0)));
185
186 auto const expectJsonThrows = [this](
187 json::Value const& num, std::string const& expected) {
188 try
189 {
190 numberFromJson(sfNumber, num);
191 fail();
192 }
193 catch (std::exception const& e)
194 {
196 out << "Json: " << num.asString() << " got exception: " << e.what()
197 << ", expected: " << expected;
198 BEAST_EXPECTS(std::string(e.what()) == expected, out.str());
199 }
200 };
201
202 // Obvious overflows tested here
203 expectJsonThrows("1e2000000", "Number::normalize 2");
204 expectJsonThrows("1e2000000000", "Number::normalize 2");
205
206 // Obvious non-numbers tested here
207 expectJsonThrows("", "'' is not a number");
208 expectJsonThrows("e", "'e' is not a number");
209 expectJsonThrows("1e", "'1e' is not a number");
210 expectJsonThrows("e2", "'e2' is not a number");
211 expectJsonThrows(json::Value(), "not a number");
212
213 try
214 {
215 auto const _ = numberFromJson(
216 sfNumber,
217 "1234567890123456789012345678901234567890123456789012345678"
218 "9012345678901234567890123456789012345678901234567890123456"
219 "78901234567890123456789012345678901234567890");
220 BEAST_EXPECT(false);
221 }
222 catch (std::bad_cast const& e)
223 {
224 BEAST_EXPECT(true);
225 }
226
227 // We do not handle leading zeros
228 try
229 {
230 auto const _ = numberFromJson(sfNumber, "001");
231 BEAST_EXPECT(false);
232 }
233 catch (std::runtime_error const& e)
234 {
235 std::string const expected = "'001' is not a number";
236 BEAST_EXPECT(e.what() == expected);
237 }
238
239 try
240 {
241 auto const _ = numberFromJson(sfNumber, "000.0");
242 BEAST_EXPECT(false);
243 }
244 catch (std::runtime_error const& e)
245 {
246 std::string const expected = "'000.0' is not a number";
247 BEAST_EXPECT(e.what() == expected);
248 }
249
250 // We do not handle dangling dot
251 try
252 {
253 auto const _ = numberFromJson(sfNumber, ".1");
254 BEAST_EXPECT(false);
255 }
256 catch (std::runtime_error const& e)
257 {
258 std::string const expected = "'.1' is not a number";
259 BEAST_EXPECT(e.what() == expected);
260 }
261
262 try
263 {
264 auto const _ = numberFromJson(sfNumber, "1.");
265 BEAST_EXPECT(false);
266 }
267 catch (std::runtime_error const& e)
268 {
269 std::string const expected = "'1.' is not a number";
270 BEAST_EXPECT(e.what() == expected);
271 }
272
273 try
274 {
275 auto const _ = numberFromJson(sfNumber, "1.e3");
276 BEAST_EXPECT(false);
277 }
278 catch (std::runtime_error const& e)
279 {
280 std::string const expected = "'1.e3' is not a number";
281 BEAST_EXPECT(e.what() == expected);
282 }
283 }
284 }
285
286 void
287 run() override
288 {
290
291 for (auto const scale : MantissaRange::getAllScales())
292 {
295 doRun();
296 }
297 }
298};
299
301
302} // namespace xrpl
A testsuite class.
Definition suite.h:52
void fail(String const &reason, char const *file, int line)
Record a failure.
Definition suite.h:554
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Represents a JSON value.
Definition json_value.h:121
std::string asString() const
Returns the unquoted string value.
Floating point representation of amounts with high dynamic range.
Definition IOUAmount.h:26
A currency issued by an account.
Definition Issue.h:18
Sets the new scale and restores the old scale when it leaves scope.
Definition Number.h:967
Number is a floating point type that can represent a wide range of values.
Definition Number.h:351
static constexpr int kMinExponent
Definition Number.h:361
static MantissaRange::MantissaScale getMantissaScale()
Returns which mantissa scale is currently in use for normalization.
static constexpr int kMaxExponent
Definition Number.h:362
constexpr TIss const & get() const
A serializable number.
Definition STNumber.h:42
void add(Serializer &s) const override
Definition STNumber.cpp:70
bool isDefault() const override
Definition STNumber.cpp:148
std::string getText() const override
Definition STNumber.cpp:51
SerializedTypeID getSType() const override
Definition STNumber.cpp:45
Number const & value() const
Definition STNumber.cpp:115
Slice slice() const noexcept
Definition Serializer.h:141
std::size_t size() const noexcept
Definition Serializer.h:147
T is_convertible_v
T max(T... args)
T min(T... args)
unsigned int UInt
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
int scale(Number const &number, Asset const &asset)
Get the scale of a Number for a given asset.
Definition STAmount.h:819
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
bool after(NetClock::time_point now, std::uint32_t mark)
Has the specified time passed?
Definition View.cpp:668
STNumber numberFromJson(SField const &field, json::Value const &value)
Definition STNumber.cpp:220
Issue const & noIssue()
Returns an asset specifier that represents no account and currency.
Definition Issue.h:118
BEAST_DEFINE_TESTSUITE(AccountTxPaging, app, xrpl)
T str(T... args)
static std::set< MantissaScale > const & getAllScales()
Definition Number.h:178
void testCombo(Number number)
void run() override
Runs the suite.
T to_string(T... args)
T what(T... args)