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