rippled
Loading...
Searching...
No Matches
Units_test.cpp
1#include <xrpl/beast/unit_test.h>
2#include <xrpl/protocol/SystemParameters.h>
3#include <xrpl/protocol/Units.h>
4
5namespace ripple {
6namespace test {
7
8class units_test : public beast::unit_test::suite
9{
10private:
11 void
12 testTypes()
13 {
14 using FeeLevel32 = FeeLevel<std::uint32_t>;
15
16 {
17 XRPAmount x{100};
18 BEAST_EXPECT(x.drops() == 100);
19 BEAST_EXPECT(
20 (std::is_same_v<decltype(x)::unit_type, unit::dropTag>));
21 auto y = 4u * x;
22 BEAST_EXPECT(y.value() == 400);
23 BEAST_EXPECT(
24 (std::is_same_v<decltype(y)::unit_type, unit::dropTag>));
25
26 auto z = 4 * y;
27 BEAST_EXPECT(z.value() == 1600);
28 BEAST_EXPECT(
29 (std::is_same_v<decltype(z)::unit_type, unit::dropTag>));
30
31 FeeLevel32 f{10};
32 FeeLevel32 baseFee{100};
33
34 auto drops = mulDiv(baseFee, x, f);
35
36 BEAST_EXPECT(drops);
37 BEAST_EXPECT(drops.value() == 1000);
38 BEAST_EXPECT((std::is_same_v<
39 std::remove_reference_t<decltype(*drops)>::unit_type,
40 unit::dropTag>));
41
42 BEAST_EXPECT((std::is_same_v<
43 std::remove_reference_t<decltype(*drops)>,
44 XRPAmount>));
45 }
46 {
47 XRPAmount x{100};
48 BEAST_EXPECT(x.value() == 100);
49 BEAST_EXPECT(
50 (std::is_same_v<decltype(x)::unit_type, unit::dropTag>));
51 auto y = 4u * x;
52 BEAST_EXPECT(y.value() == 400);
53 BEAST_EXPECT(
54 (std::is_same_v<decltype(y)::unit_type, unit::dropTag>));
55
56 FeeLevel64 f{10};
57 FeeLevel64 baseFee{100};
58
59 auto drops = mulDiv(baseFee, x, f);
60
61 BEAST_EXPECT(drops);
62 BEAST_EXPECT(drops.value() == 1000);
63 BEAST_EXPECT((std::is_same_v<
64 std::remove_reference_t<decltype(*drops)>::unit_type,
65 unit::dropTag>));
66 BEAST_EXPECT((std::is_same_v<
67 std::remove_reference_t<decltype(*drops)>,
68 XRPAmount>));
69 }
70 {
71 FeeLevel64 x{1024};
72 BEAST_EXPECT(x.value() == 1024);
73 BEAST_EXPECT(
74 (std::is_same_v<decltype(x)::unit_type, unit::feelevelTag>));
75 std::uint64_t m = 4;
76 auto y = m * x;
77 BEAST_EXPECT(y.value() == 4096);
78 BEAST_EXPECT(
79 (std::is_same_v<decltype(y)::unit_type, unit::feelevelTag>));
80
81 XRPAmount basefee{10};
82 FeeLevel64 referencefee{256};
83
84 auto drops = mulDiv(x, basefee, referencefee);
85
86 BEAST_EXPECT(drops);
87 BEAST_EXPECT(drops.value() == 40);
88 BEAST_EXPECT((std::is_same_v<
89 std::remove_reference_t<decltype(*drops)>::unit_type,
90 unit::dropTag>));
91 BEAST_EXPECT((std::is_same_v<
92 std::remove_reference_t<decltype(*drops)>,
93 XRPAmount>));
94 }
95 }
96
97 void
98 testJson()
99 {
100 // Json value functionality
101 using FeeLevel32 = FeeLevel<std::uint32_t>;
102
103 {
104 FeeLevel32 x{std::numeric_limits<std::uint32_t>::max()};
105 auto y = x.jsonClipped();
106 BEAST_EXPECT(y.type() == Json::uintValue);
107 BEAST_EXPECT(y == Json::Value{x.fee()});
108 }
109
110 {
111 FeeLevel32 x{std::numeric_limits<std::uint32_t>::min()};
112 auto y = x.jsonClipped();
113 BEAST_EXPECT(y.type() == Json::uintValue);
114 BEAST_EXPECT(y == Json::Value{x.fee()});
115 }
116
117 {
118 FeeLevel64 x{std::numeric_limits<std::uint64_t>::max()};
119 auto y = x.jsonClipped();
120 BEAST_EXPECT(y.type() == Json::uintValue);
121 BEAST_EXPECT(
122 y == Json::Value{std::numeric_limits<std::uint32_t>::max()});
123 }
124
125 {
126 FeeLevel64 x{std::numeric_limits<std::uint64_t>::min()};
127 auto y = x.jsonClipped();
128 BEAST_EXPECT(y.type() == Json::uintValue);
129 BEAST_EXPECT(y == Json::Value{0});
130 }
131
132 {
133 FeeLevelDouble x{std::numeric_limits<double>::max()};
134 auto y = x.jsonClipped();
135 BEAST_EXPECT(y.type() == Json::realValue);
136 BEAST_EXPECT(y == Json::Value{std::numeric_limits<double>::max()});
137 }
138
139 {
140 FeeLevelDouble x{std::numeric_limits<double>::min()};
141 auto y = x.jsonClipped();
142 BEAST_EXPECT(y.type() == Json::realValue);
143 BEAST_EXPECT(y == Json::Value{std::numeric_limits<double>::min()});
144 }
145
146 {
147 XRPAmount x{std::numeric_limits<std::int64_t>::max()};
148 auto y = x.jsonClipped();
149 BEAST_EXPECT(y.type() == Json::intValue);
150 BEAST_EXPECT(
151 y == Json::Value{std::numeric_limits<std::int32_t>::max()});
152 }
153
154 {
155 XRPAmount x{std::numeric_limits<std::int64_t>::min()};
156 auto y = x.jsonClipped();
157 BEAST_EXPECT(y.type() == Json::intValue);
158 BEAST_EXPECT(
159 y == Json::Value{std::numeric_limits<std::int32_t>::min()});
160 }
161 }
162
163 void
164 testFunctions()
165 {
166 // Explicitly test every defined function for the ValueUnit class
167 // since some of them are templated, but not used anywhere else.
168 using FeeLevel32 = FeeLevel<std::uint32_t>;
169
170 {
171 auto make = [&](auto x) -> FeeLevel64 { return x; };
172 auto explicitmake = [&](auto x) -> FeeLevel64 {
173 return FeeLevel64{x};
174 };
175
176 [[maybe_unused]]
177 FeeLevel64 defaulted;
178 FeeLevel64 test{0};
179 BEAST_EXPECT(test.fee() == 0);
180
181 test = explicitmake(beast::zero);
182 BEAST_EXPECT(test.fee() == 0);
183
184 test = beast::zero;
185 BEAST_EXPECT(test.fee() == 0);
186
187 test = explicitmake(100u);
188 BEAST_EXPECT(test.fee() == 100);
189
190 FeeLevel64 const targetSame{200u};
191 FeeLevel32 const targetOther{300u};
192 test = make(targetSame);
193 BEAST_EXPECT(test.fee() == 200);
194 BEAST_EXPECT(test == targetSame);
195 BEAST_EXPECT(test < FeeLevel64{1000});
196 BEAST_EXPECT(test > FeeLevel64{100});
197 test = make(targetOther);
198 BEAST_EXPECT(test.fee() == 300);
199 BEAST_EXPECT(test == targetOther);
200
201 test = std::uint64_t(200);
202 BEAST_EXPECT(test.fee() == 200);
203 test = std::uint32_t(300);
204 BEAST_EXPECT(test.fee() == 300);
205
206 test = targetSame;
207 BEAST_EXPECT(test.fee() == 200);
208 test = targetOther.fee();
209 BEAST_EXPECT(test.fee() == 300);
210 BEAST_EXPECT(test == targetOther);
211
212 test = targetSame * 2;
213 BEAST_EXPECT(test.fee() == 400);
214 test = 3 * targetSame;
215 BEAST_EXPECT(test.fee() == 600);
216 test = targetSame / 10;
217 BEAST_EXPECT(test.fee() == 20);
218
219 test += targetSame;
220 BEAST_EXPECT(test.fee() == 220);
221
222 test -= targetSame;
223 BEAST_EXPECT(test.fee() == 20);
224
225 test++;
226 BEAST_EXPECT(test.fee() == 21);
227 ++test;
228 BEAST_EXPECT(test.fee() == 22);
229 test--;
230 BEAST_EXPECT(test.fee() == 21);
231 --test;
232 BEAST_EXPECT(test.fee() == 20);
233
234 test *= 5;
235 BEAST_EXPECT(test.fee() == 100);
236 test /= 2;
237 BEAST_EXPECT(test.fee() == 50);
238 test %= 13;
239 BEAST_EXPECT(test.fee() == 11);
240
241 /*
242 // illegal with unsigned
243 test = -test;
244 BEAST_EXPECT(test.fee() == -11);
245 BEAST_EXPECT(test.signum() == -1);
246 BEAST_EXPECT(to_string(test) == "-11");
247 */
248
249 BEAST_EXPECT(test);
250 test = 0;
251 BEAST_EXPECT(!test);
252 BEAST_EXPECT(test.signum() == 0);
253 test = targetSame;
254 BEAST_EXPECT(test.signum() == 1);
255 BEAST_EXPECT(to_string(test) == "200");
256 }
257 {
258 auto make = [&](auto x) -> FeeLevelDouble { return x; };
259 auto explicitmake = [&](auto x) -> FeeLevelDouble {
260 return FeeLevelDouble{x};
261 };
262
263 [[maybe_unused]]
264 FeeLevelDouble defaulted;
265 FeeLevelDouble test{0};
266 BEAST_EXPECT(test.fee() == 0);
267
268 test = explicitmake(beast::zero);
269 BEAST_EXPECT(test.fee() == 0);
270
271 test = beast::zero;
272 BEAST_EXPECT(test.fee() == 0);
273
274 test = explicitmake(100.0);
275 BEAST_EXPECT(test.fee() == 100);
276
277 FeeLevelDouble const targetSame{200.0};
278 FeeLevel64 const targetOther{300};
279 test = make(targetSame);
280 BEAST_EXPECT(test.fee() == 200);
281 BEAST_EXPECT(test == targetSame);
282 BEAST_EXPECT(test < FeeLevelDouble{1000.0});
283 BEAST_EXPECT(test > FeeLevelDouble{100.0});
284 test = targetOther.fee();
285 BEAST_EXPECT(test.fee() == 300);
286 BEAST_EXPECT(test == targetOther);
287
288 test = 200.0;
289 BEAST_EXPECT(test.fee() == 200);
290 test = std::uint64_t(300);
291 BEAST_EXPECT(test.fee() == 300);
292
293 test = targetSame;
294 BEAST_EXPECT(test.fee() == 200);
295
296 test = targetSame * 2;
297 BEAST_EXPECT(test.fee() == 400);
298 test = 3 * targetSame;
299 BEAST_EXPECT(test.fee() == 600);
300 test = targetSame / 10;
301 BEAST_EXPECT(test.fee() == 20);
302
303 test += targetSame;
304 BEAST_EXPECT(test.fee() == 220);
305
306 test -= targetSame;
307 BEAST_EXPECT(test.fee() == 20);
308
309 test++;
310 BEAST_EXPECT(test.fee() == 21);
311 ++test;
312 BEAST_EXPECT(test.fee() == 22);
313 test--;
314 BEAST_EXPECT(test.fee() == 21);
315 --test;
316 BEAST_EXPECT(test.fee() == 20);
317
318 test *= 5;
319 BEAST_EXPECT(test.fee() == 100);
320 test /= 2;
321 BEAST_EXPECT(test.fee() == 50);
322 /* illegal with floating
323 test %= 13;
324 BEAST_EXPECT(test.fee() == 11);
325 */
326
327 // legal with signed
328 test = -test;
329 BEAST_EXPECT(test.fee() == -50);
330 BEAST_EXPECT(test.signum() == -1);
331 BEAST_EXPECT(to_string(test) == "-50.000000");
332
333 BEAST_EXPECT(test);
334 test = 0;
335 BEAST_EXPECT(!test);
336 BEAST_EXPECT(test.signum() == 0);
337 test = targetSame;
338 BEAST_EXPECT(test.signum() == 1);
339 BEAST_EXPECT(to_string(test) == "200.000000");
340 }
341 }
342
343public:
344 void
345 run() override
346 {
347 BEAST_EXPECT(INITIAL_XRP.drops() == 100'000'000'000'000'000);
348 BEAST_EXPECT(INITIAL_XRP == XRPAmount{100'000'000'000'000'000});
349
350 testTypes();
351 testJson();
352 testFunctions();
353 }
354};
355
356BEAST_DEFINE_TESTSUITE(units, basics, ripple);
357
358} // namespace test
359} // namespace ripple
Json::Value
Represents a JSON value.
Definition json_value.h:130
beast::unit_test::suite
A testsuite class.
Definition suite.h:52
ripple::XRPAmount::drops
constexpr value_type drops() const
Returns the number of drops.
Definition XRPAmount.h:158
ripple::XRPAmount::jsonClipped
Json::Value jsonClipped() const
Definition XRPAmount.h:199
ripple::test::units_test
Definition Units_test.cpp:9
ripple::test::units_test::testFunctions
void testFunctions()
Definition Units_test.cpp:164
ripple::test::units_test::testTypes
void testTypes()
Definition Units_test.cpp:12
ripple::test::units_test::run
void run() override
Runs the suite.
Definition Units_test.cpp:345
ripple::test::units_test::testJson
void testJson()
Definition Units_test.cpp:98
ripple::unit::ValueUnit::jsonClipped
Json::Value jsonClipped() const
Definition Units.h:295
std::is_same_v
T is_same_v
std::numeric_limits::max
T max(T... args)
std::numeric_limits::min
T min(T... args)
Json::realValue
@ realValue
double value
Definition json_value.h:22
Json::intValue
@ intValue
signed integer value
Definition json_value.h:20
Json::uintValue
@ uintValue
unsigned integer value
Definition json_value.h:21
ripple::test::jtx::drops
PrettyAmount drops(Integer i)
Returns an XRP PrettyAmount, which is trivially convertible to STAmount.
Definition src/test/jtx/amount.h:307
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:6
ripple::INITIAL_XRP
constexpr XRPAmount INITIAL_XRP
Configure the native currency.
Definition SystemParameters.h:25
ripple::to_string
std::string to_string(base_uint< Bits, Tag > const &a)
Definition base_uint.h:611
ripple::mulDiv
std::optional< std::uint64_t > mulDiv(std::uint64_t value, std::uint64_t mul, std::uint64_t div)
Return value*mul/div accurately.
Definition libxrpl/basics/mulDiv.cpp:13
Generated by doxygen 1.9.8