Bitcoin Core 32.99.0
P2P Digital Currency
Loading...
Searching...
No Matches
feefrac_tests.cpp
Go to the documentation of this file.
1// Copyright (c) 2024-present The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#include <test/util/common.h>
6#include <util/feefrac.h>
7#include <random.h>
8
9#include <boost/test/unit_test.hpp>
10
11BOOST_AUTO_TEST_SUITE(feefrac_tests)
12
13BOOST_AUTO_TEST_CASE(feefrac_operators)
14{
15 FeeFrac p1{1000, 100}, p2{500, 300};
16 FeeFrac sum{1500, 400};
17 FeeFrac diff{500, -200};
18 FeeFrac empty{0, 0};
19 FeeFrac zero_fee{0, 1}; // zero-fee allowed
20
21 BOOST_CHECK_EQUAL(zero_fee.EvaluateFeeDown(0), 0);
22 BOOST_CHECK_EQUAL(zero_fee.EvaluateFeeDown(1), 0);
23 BOOST_CHECK_EQUAL(zero_fee.EvaluateFeeDown(1000000), 0);
24 BOOST_CHECK_EQUAL(zero_fee.EvaluateFeeDown(0x7fffffff), 0);
25 BOOST_CHECK_EQUAL(zero_fee.EvaluateFeeUp(0), 0);
26 BOOST_CHECK_EQUAL(zero_fee.EvaluateFeeUp(1), 0);
27 BOOST_CHECK_EQUAL(zero_fee.EvaluateFeeUp(1000000), 0);
28 BOOST_CHECK_EQUAL(zero_fee.EvaluateFeeUp(0x7fffffff), 0);
29
30 BOOST_CHECK_EQUAL(p1.EvaluateFeeDown(0), 0);
31 BOOST_CHECK_EQUAL(p1.EvaluateFeeDown(1), 10);
32 BOOST_CHECK_EQUAL(p1.EvaluateFeeDown(100000000), 1000000000);
33 BOOST_CHECK_EQUAL(p1.EvaluateFeeDown(0x7fffffff), int64_t(0x7fffffff) * 10);
34 BOOST_CHECK_EQUAL(p1.EvaluateFeeUp(0), 0);
35 BOOST_CHECK_EQUAL(p1.EvaluateFeeUp(1), 10);
36 BOOST_CHECK_EQUAL(p1.EvaluateFeeUp(100000000), 1000000000);
37 BOOST_CHECK_EQUAL(p1.EvaluateFeeUp(0x7fffffff), int64_t(0x7fffffff) * 10);
38
39 FeeFrac neg{-1001, 100};
40 BOOST_CHECK_EQUAL(neg.EvaluateFeeDown(0), 0);
41 BOOST_CHECK_EQUAL(neg.EvaluateFeeDown(1), -11);
42 BOOST_CHECK_EQUAL(neg.EvaluateFeeDown(2), -21);
43 BOOST_CHECK_EQUAL(neg.EvaluateFeeDown(3), -31);
44 BOOST_CHECK_EQUAL(neg.EvaluateFeeDown(100), -1001);
45 BOOST_CHECK_EQUAL(neg.EvaluateFeeDown(101), -1012);
46 BOOST_CHECK_EQUAL(neg.EvaluateFeeDown(100000000), -1001000000);
47 BOOST_CHECK_EQUAL(neg.EvaluateFeeDown(100000001), -1001000011);
48 BOOST_CHECK_EQUAL(neg.EvaluateFeeDown(0x7fffffff), -21496311307);
49 BOOST_CHECK_EQUAL(neg.EvaluateFeeUp(0), 0);
50 BOOST_CHECK_EQUAL(neg.EvaluateFeeUp(1), -10);
51 BOOST_CHECK_EQUAL(neg.EvaluateFeeUp(2), -20);
52 BOOST_CHECK_EQUAL(neg.EvaluateFeeUp(3), -30);
53 BOOST_CHECK_EQUAL(neg.EvaluateFeeUp(100), -1001);
54 BOOST_CHECK_EQUAL(neg.EvaluateFeeUp(101), -1011);
55 BOOST_CHECK_EQUAL(neg.EvaluateFeeUp(100000000), -1001000000);
56 BOOST_CHECK_EQUAL(neg.EvaluateFeeUp(100000001), -1001000010);
57 BOOST_CHECK_EQUAL(neg.EvaluateFeeUp(0x7fffffff), -21496311306);
58
59 BOOST_CHECK_EQUAL(empty, FeeFrac{}); // same as no-args
60
61 BOOST_CHECK_EQUAL(p1, p1);
62 BOOST_CHECK_EQUAL(p1 + p2, sum);
63 BOOST_CHECK_EQUAL(p1 - p2, diff);
64
65 FeeFrac p3{2000, 200};
66 BOOST_CHECK_NE(p1, p3); // feefracs only equal if both fee and size are same
67 BOOST_CHECK_NE(p2, p3);
68
69 FeeFrac p4{3000, 300};
70 BOOST_CHECK_EQUAL(p1, p4-p3);
71 BOOST_CHECK_EQUAL(p1 + p3, p4);
72
73 // Fee-rate comparison
74 BOOST_CHECK_GT(ByRatioNegSize{p1}, ByRatioNegSize{p2});
75 BOOST_CHECK_GE(ByRatioNegSize{p1}, ByRatioNegSize{p2});
76 BOOST_CHECK_GE(ByRatioNegSize{p1}, ByRatioNegSize{p4-p3});
77 BOOST_CHECK(!(ByRatio{p1} > ByRatio{p3})); // not strictly better
78 BOOST_CHECK(ByRatio{p1} > ByRatio{p2}); // strictly greater feerate
79
80 BOOST_CHECK_LT(ByRatioNegSize{p2}, ByRatioNegSize{p1});
81 BOOST_CHECK_LE(ByRatioNegSize{p2}, ByRatioNegSize{p1});
82 BOOST_CHECK_LE(ByRatioNegSize{p1}, ByRatioNegSize{p4-p3});
83 BOOST_CHECK(!(ByRatio{p3} < ByRatio{p1})); // not strictly worse
84 BOOST_CHECK(ByRatio{p2} < ByRatio{p1}); // strictly lower feerate
85
86 // "empty" comparisons
87 BOOST_CHECK(!(ByRatio{p1} > ByRatio{empty})); // << will always result in false
88 BOOST_CHECK(!(ByRatio{p1} < ByRatio{empty}));
89 BOOST_CHECK(!(ByRatio{empty} > ByRatio{empty}));
90 BOOST_CHECK(!(ByRatio{empty} < ByRatio{empty}));
91
92 // empty is always bigger than everything else
93 BOOST_CHECK_GT(ByRatioNegSize{empty}, ByRatioNegSize{p1});
94 BOOST_CHECK_GT(ByRatioNegSize{empty}, ByRatioNegSize{p2});
95 BOOST_CHECK_GT(ByRatioNegSize{empty}, ByRatioNegSize{p3});
96 BOOST_CHECK_GE(ByRatioNegSize{empty}, ByRatioNegSize{p1});
97 BOOST_CHECK_GE(ByRatioNegSize{empty}, ByRatioNegSize{p2});
98 BOOST_CHECK_GE(ByRatioNegSize{empty}, ByRatioNegSize{p3});
99
100 // check "max" values for comparison
101 FeeFrac oversized_1{4611686000000, 4000000};
102 FeeFrac oversized_2{184467440000000, 100000};
103
104 BOOST_CHECK_LT(ByRatioNegSize{oversized_1}, ByRatioNegSize{oversized_2});
105 BOOST_CHECK_LE(ByRatioNegSize{oversized_1}, ByRatioNegSize{oversized_2});
106 BOOST_CHECK(ByRatio{oversized_1} < ByRatio{oversized_2});
107 BOOST_CHECK_NE(ByRatioNegSize{oversized_1}, ByRatioNegSize{oversized_2});
108
109 BOOST_CHECK_EQUAL(oversized_1.EvaluateFeeDown(0), 0);
110 BOOST_CHECK_EQUAL(oversized_1.EvaluateFeeDown(1), 1152921);
111 BOOST_CHECK_EQUAL(oversized_1.EvaluateFeeDown(2), 2305843);
112 BOOST_CHECK_EQUAL(oversized_1.EvaluateFeeDown(1548031267), 1784758530396540);
113 BOOST_CHECK_EQUAL(oversized_1.EvaluateFeeUp(0), 0);
114 BOOST_CHECK_EQUAL(oversized_1.EvaluateFeeUp(1), 1152922);
115 BOOST_CHECK_EQUAL(oversized_1.EvaluateFeeUp(2), 2305843);
116 BOOST_CHECK_EQUAL(oversized_1.EvaluateFeeUp(1548031267), 1784758530396541);
117
118 // Test cases on the threshold where FeeFrac::Evaluate start using Mul/Div.
119 BOOST_CHECK_EQUAL(FeeFrac(0x1ffffffff, 123456789).EvaluateFeeDown(98765432), 6871947728);
120 BOOST_CHECK_EQUAL(FeeFrac(0x200000000, 123456789).EvaluateFeeDown(98765432), 6871947729);
121 BOOST_CHECK_EQUAL(FeeFrac(0x200000001, 123456789).EvaluateFeeDown(98765432), 6871947730);
122 BOOST_CHECK_EQUAL(FeeFrac(0x1ffffffff, 123456789).EvaluateFeeUp(98765432), 6871947729);
123 BOOST_CHECK_EQUAL(FeeFrac(0x200000000, 123456789).EvaluateFeeUp(98765432), 6871947730);
124 BOOST_CHECK_EQUAL(FeeFrac(0x200000001, 123456789).EvaluateFeeUp(98765432), 6871947731);
125
126 // Tests paths that use double arithmetic
127 FeeFrac busted{(static_cast<int64_t>(INT32_MAX)) + 1, INT32_MAX};
128 BOOST_CHECK(!(ByRatioNegSize{busted} < ByRatioNegSize{busted}));
129
130 FeeFrac max_fee{2100000000000000, INT32_MAX};
131 BOOST_CHECK(!(ByRatioNegSize{max_fee} < ByRatioNegSize{max_fee}));
132 BOOST_CHECK(!(ByRatioNegSize{max_fee} > ByRatioNegSize{max_fee}));
133 BOOST_CHECK_LE(ByRatioNegSize{max_fee}, ByRatioNegSize{max_fee});
134 BOOST_CHECK_GE(ByRatioNegSize{max_fee}, ByRatioNegSize{max_fee});
135
136 BOOST_CHECK_EQUAL(max_fee.EvaluateFeeDown(0), 0);
137 BOOST_CHECK_EQUAL(max_fee.EvaluateFeeDown(1), 977888);
138 BOOST_CHECK_EQUAL(max_fee.EvaluateFeeDown(2), 1955777);
139 BOOST_CHECK_EQUAL(max_fee.EvaluateFeeDown(3), 2933666);
140 BOOST_CHECK_EQUAL(max_fee.EvaluateFeeDown(1256796054), 1229006664189047);
141 BOOST_CHECK_EQUAL(max_fee.EvaluateFeeDown(INT32_MAX), 2100000000000000);
142 BOOST_CHECK_EQUAL(max_fee.EvaluateFeeUp(0), 0);
143 BOOST_CHECK_EQUAL(max_fee.EvaluateFeeUp(1), 977889);
144 BOOST_CHECK_EQUAL(max_fee.EvaluateFeeUp(2), 1955778);
145 BOOST_CHECK_EQUAL(max_fee.EvaluateFeeUp(3), 2933667);
146 BOOST_CHECK_EQUAL(max_fee.EvaluateFeeUp(1256796054), 1229006664189048);
147 BOOST_CHECK_EQUAL(max_fee.EvaluateFeeUp(INT32_MAX), 2100000000000000);
148
149 FeeFrac max_fee2{1, 1};
150 BOOST_CHECK_GE(ByRatioNegSize{max_fee}, ByRatioNegSize{max_fee2});
151
152 // Test for integer overflow issue (https://github.com/bitcoin/bitcoin/issues/32294)
153 BOOST_CHECK_EQUAL((FeeFrac{0x7ffffffdfffffffb, 0x7ffffffd}.EvaluateFeeDown(0x7fffffff)), 0x7fffffffffffffff);
154}
155
156BOOST_AUTO_TEST_SUITE_END()
BOOST_CHECK_LT
BOOST_CHECK_LT(ZeroL, OneL)
ByRatio
Wrapper around FeeFrac & derived types, which adds a feerate-based ordering which treats equal-feerat...
Definition feefrac.h:218
ByRatioNegSize
Wrapper around FeeFrac & derived types, which adds a total ordering which first sorts by feerate and ...
Definition feefrac.h:289
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
sum
volatile double sum
Definition examples.cpp:10
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(feefrac_operators)
Definition feefrac_tests.cpp:13
BOOST_CHECK_GT
BOOST_CHECK_GT(excessive_headers.size(), MAX_HEADERS_SIZE)
BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition object.cpp:17
BOOST_CHECK
#define BOOST_CHECK(expr)
Definition object.cpp:16
FeeFrac
Data structure storing a fee and size.
Definition feefrac.h:21
FeeFrac::EvaluateFeeDown
int64_t EvaluateFeeDown(int32_t at_size) const noexcept
Compute the fee for a given size at_size using this object's feerate, rounding down.
Definition feefrac.h:173
BOOST_CHECK_NE
BOOST_CHECK_NE(OneL.ToString(), ArrayToString(ZeroArray, 32))
Ticks
constexpr auto Ticks(Dur2 d)
Helper to count the seconds of a duration/time_point.
Definition time.h:82
Generated on Mon Nov 2 2026 20:00:30 for Bitcoin Core by doxygen 1.9.8