Branch data Line data Source code
1 : : // Copyright (c) 2011-2021 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 <arith_uint256.h>
6 : : #include <streams.h>
7 : : #include <test/util/setup_common.h>
8 : : #include <uint256.h>
9 : : #include <util/strencodings.h>
10 : : #include <util/transaction_identifier.h>
11 : :
12 : : #include <boost/test/unit_test.hpp>
13 : :
14 : : #include <iomanip>
15 : : #include <sstream>
16 : : #include <string>
17 : : #include <string_view>
18 : : #include <vector>
19 : :
20 : : BOOST_AUTO_TEST_SUITE(uint256_tests)
21 : :
22 : : const unsigned char R1Array[] =
23 : : "\x9c\x52\x4a\xdb\xcf\x56\x11\x12\x2b\x29\x12\x5e\x5d\x35\xd2\xd2"
24 : : "\x22\x81\xaa\xb5\x33\xf0\x08\x32\xd5\x56\xb1\xf9\xea\xe5\x1d\x7d";
25 : : const char R1ArrayHex[] = "7D1DE5EAF9B156D53208F033B5AA8122D2d2355d5e12292b121156cfdb4a529c";
26 : : const uint256 R1L = uint256(std::vector<unsigned char>(R1Array,R1Array+32));
27 : : const uint160 R1S = uint160(std::vector<unsigned char>(R1Array,R1Array+20));
28 : :
29 : : const unsigned char R2Array[] =
30 : : "\x70\x32\x1d\x7c\x47\xa5\x6b\x40\x26\x7e\x0a\xc3\xa6\x9c\xb6\xbf"
31 : : "\x13\x30\x47\xa3\x19\x2d\xda\x71\x49\x13\x72\xf0\xb4\xca\x81\xd7";
32 : : const uint256 R2L = uint256(std::vector<unsigned char>(R2Array,R2Array+32));
33 : : const uint160 R2S = uint160(std::vector<unsigned char>(R2Array,R2Array+20));
34 : :
35 : : const unsigned char ZeroArray[] =
36 : : "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
37 : : "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
38 : : const uint256 ZeroL = uint256(std::vector<unsigned char>(ZeroArray,ZeroArray+32));
39 : : const uint160 ZeroS = uint160(std::vector<unsigned char>(ZeroArray,ZeroArray+20));
40 : :
41 : : const unsigned char OneArray[] =
42 : : "\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
43 : : "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
44 : : const uint256 OneL = uint256(std::vector<unsigned char>(OneArray,OneArray+32));
45 : : const uint160 OneS = uint160(std::vector<unsigned char>(OneArray,OneArray+20));
46 : :
47 : : const unsigned char MaxArray[] =
48 : : "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
49 : : "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff";
50 : : const uint256 MaxL = uint256(std::vector<unsigned char>(MaxArray,MaxArray+32));
51 : : const uint160 MaxS = uint160(std::vector<unsigned char>(MaxArray,MaxArray+20));
52 : :
53 : 12 : static std::string ArrayToString(const unsigned char A[], unsigned int width)
54 : : {
55 : 12 : std::stringstream Stream;
56 : 12 : Stream << std::hex;
57 [ + + ]: 324 : for (unsigned int i = 0; i < width; ++i)
58 : : {
59 [ + - + - ]: 312 : Stream<<std::setw(2)<<std::setfill('0')<<(unsigned int)A[width-i-1];
60 : : }
61 [ + - ]: 24 : return Stream.str();
62 : 12 : }
63 : :
64 : : // Takes hex string in reverse byte order.
65 : 11 : inline uint160 uint160S(std::string_view str)
66 : : {
67 : 11 : uint160 rv;
68 [ + - + - : 6 : rv.SetHexDeprecated(str);
+ - + - ]
69 [ + - + - : 9 : return rv;
+ - + - +
- + - + -
+ - + - ]
70 : : }
71 : :
72 [ + - + - : 7 : BOOST_AUTO_TEST_CASE( basics ) // constructors, equality, inequality
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
73 : : {
74 : : // constructor uint256(vector<char>):
75 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(R1L.ToString(), ArrayToString(R1Array,32));
76 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(R1S.ToString(), ArrayToString(R1Array,20));
77 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(R2L.ToString(), ArrayToString(R2Array,32));
78 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(R2S.ToString(), ArrayToString(R2Array,20));
79 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(ZeroL.ToString(), ArrayToString(ZeroArray,32));
80 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(ZeroS.ToString(), ArrayToString(ZeroArray,20));
81 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(OneL.ToString(), ArrayToString(OneArray,32));
82 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(OneS.ToString(), ArrayToString(OneArray,20));
83 [ + - ]: 2 : BOOST_CHECK_EQUAL(MaxL.ToString(), ArrayToString(MaxArray,32));
84 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(MaxS.ToString(), ArrayToString(MaxArray,20));
85 [ + - + - ]: 1 : BOOST_CHECK_NE(OneL.ToString(), ArrayToString(ZeroArray,32));
86 [ + - + - ]: 1 : BOOST_CHECK_NE(OneS.ToString(), ArrayToString(ZeroArray,20));
87 : :
88 : : // == and !=
89 [ + - + - ]: 1 : BOOST_CHECK_NE(R1L, R2L); BOOST_CHECK_NE(R1S, R2S);
90 [ + - + - ]: 1 : BOOST_CHECK_NE(ZeroL, OneL); BOOST_CHECK_NE(ZeroS, OneS);
91 [ + - + - ]: 1 : BOOST_CHECK_NE(OneL, ZeroL); BOOST_CHECK_NE(OneS, ZeroS);
92 [ + - + - ]: 1 : BOOST_CHECK_NE(MaxL, ZeroL); BOOST_CHECK_NE(MaxS, ZeroS);
93 : :
94 : : // String Constructor and Copy Constructor
95 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S("0x"+R1L.ToString()), R1L);
+ - ]
96 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S("0x"+R2L.ToString()), R2L);
+ - ]
97 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S("0x"+ZeroL.ToString()), ZeroL);
+ - ]
98 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S("0x"+OneL.ToString()), OneL);
+ - ]
99 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S("0x"+MaxL.ToString()), MaxL);
+ - ]
100 [ + - + - ]: 2 : BOOST_CHECK_EQUAL(uint256S(R1L.ToString()), R1L);
101 [ + - + - : 3 : BOOST_CHECK_EQUAL(uint256S(" 0x"+R1L.ToString()+" "), R1L);
+ - ]
102 [ + - + - : 3 : BOOST_CHECK_EQUAL(uint256S(" 0x"+R1L.ToString()+"-trash;%^& "), R1L);
+ - ]
103 [ + - + - : 3 : BOOST_CHECK_EQUAL(uint256S("\t \n \n \f\n\r\t\v\t 0x"+R1L.ToString()+" \t \n \n \f\n\r\t\v\t "), R1L);
+ - ]
104 [ + - ]: 1 : BOOST_CHECK_EQUAL(uint256S(""), ZeroL);
105 [ + - ]: 1 : BOOST_CHECK_EQUAL(uint256S("1"), OneL);
106 [ + - ]: 1 : BOOST_CHECK_EQUAL(R1L, uint256S(R1ArrayHex));
107 [ + - ]: 1 : BOOST_CHECK_EQUAL(uint256(R1L), R1L);
108 [ + - ]: 1 : BOOST_CHECK_EQUAL(uint256(ZeroL), ZeroL);
109 [ + - ]: 1 : BOOST_CHECK_EQUAL(uint256(OneL), OneL);
110 : :
111 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint160S("0x"+R1S.ToString()), R1S);
+ - ]
112 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint160S("0x"+R2S.ToString()), R2S);
+ - ]
113 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint160S("0x"+ZeroS.ToString()), ZeroS);
+ - ]
114 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint160S("0x"+OneS.ToString()), OneS);
+ - ]
115 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint160S("0x"+MaxS.ToString()), MaxS);
+ - ]
116 [ + - + - ]: 2 : BOOST_CHECK_EQUAL(uint160S(R1S.ToString()), R1S);
117 [ + - + - : 3 : BOOST_CHECK_EQUAL(uint160S(" 0x"+R1S.ToString()+" "), R1S);
+ - ]
118 [ + - + - : 3 : BOOST_CHECK_EQUAL(uint160S(" 0x"+R1S.ToString()+"-trash;%^& "), R1S);
+ - ]
119 [ + - + - : 3 : BOOST_CHECK_EQUAL(uint160S(" \t \n \n \f\n\r\t\v\t 0x"+R1S.ToString()+" \t \n \n \f\n\r\t\v\t"), R1S);
+ - ]
120 [ + - ]: 1 : BOOST_CHECK_EQUAL(uint160S(""), ZeroS);
121 [ + - ]: 1 : BOOST_CHECK_EQUAL(R1S, uint160S(R1ArrayHex));
122 : :
123 [ + - ]: 1 : BOOST_CHECK_EQUAL(uint160(R1S), R1S);
124 [ + - ]: 1 : BOOST_CHECK_EQUAL(uint160(ZeroS), ZeroS);
125 [ + - ]: 1 : BOOST_CHECK_EQUAL(uint160(OneS), OneS);
126 : 1 : }
127 : :
128 [ + - + - : 7 : BOOST_AUTO_TEST_CASE( comparison ) // <= >= < >
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
129 : : {
130 : 1 : uint256 LastL;
131 [ + + ]: 257 : for (int i = 255; i >= 0; --i) {
132 : 256 : uint256 TmpL;
133 : 256 : *(TmpL.begin() + (i>>3)) |= 1<<(7-(i&7));
134 [ + - ]: 256 : BOOST_CHECK_LT(LastL, TmpL);
135 : 256 : LastL = TmpL;
136 : : }
137 : :
138 [ + - ]: 1 : BOOST_CHECK_LT(ZeroL, R1L);
139 [ + - ]: 1 : BOOST_CHECK_LT(R2L, R1L);
140 [ + - ]: 1 : BOOST_CHECK_LT(ZeroL, OneL);
141 [ + - ]: 1 : BOOST_CHECK_LT(OneL, MaxL);
142 [ + - ]: 1 : BOOST_CHECK_LT(R1L, MaxL);
143 [ + - ]: 1 : BOOST_CHECK_LT(R2L, MaxL);
144 : :
145 : 1 : uint160 LastS;
146 [ + + ]: 161 : for (int i = 159; i >= 0; --i) {
147 : 160 : uint160 TmpS;
148 : 160 : *(TmpS.begin() + (i>>3)) |= 1<<(7-(i&7));
149 [ + - ]: 160 : BOOST_CHECK_LT(LastS, TmpS);
150 : 160 : LastS = TmpS;
151 : : }
152 [ + - ]: 1 : BOOST_CHECK_LT(ZeroS, R1S);
153 [ + - ]: 1 : BOOST_CHECK_LT(R2S, R1S);
154 [ + - ]: 1 : BOOST_CHECK_LT(ZeroS, OneS);
155 [ + - ]: 1 : BOOST_CHECK_LT(OneS, MaxS);
156 [ + - ]: 1 : BOOST_CHECK_LT(R1S, MaxS);
157 [ + - ]: 1 : BOOST_CHECK_LT(R2S, MaxS);
158 : :
159 : : // Non-arithmetic uint256s compare from the beginning of their inner arrays:
160 [ + - ]: 1 : BOOST_CHECK_LT(R2L, R1L);
161 : : // Ensure first element comparisons give the same order as above:
162 [ + - ]: 1 : BOOST_CHECK_LT(*R2L.begin(), *R1L.begin());
163 : : // Ensure last element comparisons give a different result (swapped params):
164 [ + - ]: 1 : BOOST_CHECK_LT(*(R1L.end()-1), *(R2L.end()-1));
165 : : // Hex strings represent reverse-encoded bytes, with lexicographic ordering:
166 [ + - ]: 1 : BOOST_CHECK_LT(uint256{"1000000000000000000000000000000000000000000000000000000000000000"},
167 : : uint256{"0000000000000000000000000000000000000000000000000000000000000001"});
168 : 1 : }
169 : :
170 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(methods) // GetHex SetHexDeprecated FromHex begin() end() size() GetLow64 GetSerializeSize, Serialize, Unserialize
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
171 : : {
172 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(R1L.GetHex(), R1L.ToString());
173 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(R2L.GetHex(), R2L.ToString());
174 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(OneL.GetHex(), OneL.ToString());
175 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(MaxL.GetHex(), MaxL.ToString());
176 : 1 : uint256 TmpL(R1L);
177 [ + - ]: 1 : BOOST_CHECK_EQUAL(TmpL, R1L);
178 : : // Verify previous values don't persist when setting to truncated string.
179 : 1 : TmpL.SetHexDeprecated("21");
180 [ + - ]: 1 : BOOST_CHECK_EQUAL(TmpL.ToString(), "0000000000000000000000000000000000000000000000000000000000000021");
181 [ + - + - ]: 2 : BOOST_CHECK_EQUAL(uint256::FromHex(R2L.ToString()).value(), R2L);
182 [ + - + - ]: 2 : BOOST_CHECK_EQUAL(uint256::FromHex(ZeroL.ToString()).value(), uint256());
183 : :
184 [ + - ]: 2 : TmpL = uint256::FromHex(R1L.ToString()).value();
185 [ + - + - ]: 2 : BOOST_CHECK_EQUAL_COLLECTIONS(R1L.begin(), R1L.end(), R1Array, R1Array + uint256::size());
186 [ + - + - ]: 2 : BOOST_CHECK_EQUAL_COLLECTIONS(TmpL.begin(), TmpL.end(), R1Array, R1Array + uint256::size());
187 [ + - + - ]: 2 : BOOST_CHECK_EQUAL_COLLECTIONS(R2L.begin(), R2L.end(), R2Array, R2Array + uint256::size());
188 [ + - + - ]: 2 : BOOST_CHECK_EQUAL_COLLECTIONS(ZeroL.begin(), ZeroL.end(), ZeroArray, ZeroArray + uint256::size());
189 [ + - + - ]: 2 : BOOST_CHECK_EQUAL_COLLECTIONS(OneL.begin(), OneL.end(), OneArray, OneArray + uint256::size());
190 [ + - ]: 1 : BOOST_CHECK_EQUAL(R1L.size(), sizeof(R1L));
191 [ + - ]: 1 : BOOST_CHECK_EQUAL(sizeof(R1L), 32);
192 [ + - ]: 1 : BOOST_CHECK_EQUAL(R1L.size(), 32);
193 [ + - ]: 1 : BOOST_CHECK_EQUAL(R2L.size(), 32);
194 [ + - ]: 1 : BOOST_CHECK_EQUAL(ZeroL.size(), 32);
195 [ + - ]: 1 : BOOST_CHECK_EQUAL(MaxL.size(), 32);
196 [ + - ]: 1 : BOOST_CHECK_EQUAL(R1L.begin() + 32, R1L.end());
197 [ + - ]: 1 : BOOST_CHECK_EQUAL(R2L.begin() + 32, R2L.end());
198 [ + - ]: 1 : BOOST_CHECK_EQUAL(OneL.begin() + 32, OneL.end());
199 [ + - ]: 1 : BOOST_CHECK_EQUAL(MaxL.begin() + 32, MaxL.end());
200 [ + - ]: 1 : BOOST_CHECK_EQUAL(TmpL.begin() + 32, TmpL.end());
201 [ + - ]: 1 : BOOST_CHECK_EQUAL(GetSerializeSize(R1L), 32);
202 [ + - ]: 1 : BOOST_CHECK_EQUAL(GetSerializeSize(ZeroL), 32);
203 : :
204 : 1 : DataStream ss{};
205 [ + - ]: 1 : ss << R1L;
206 [ + - + - : 2 : BOOST_CHECK_EQUAL(ss.str(), std::string(R1Array,R1Array+32));
+ - + - ]
207 [ + - ]: 1 : ss >> TmpL;
208 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(R1L, TmpL);
209 [ - + ]: 1 : ss.clear();
210 [ + - ]: 1 : ss << ZeroL;
211 [ + - + - : 2 : BOOST_CHECK_EQUAL(ss.str(), std::string(ZeroArray,ZeroArray+32));
+ - + - ]
212 [ + - ]: 1 : ss >> TmpL;
213 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(ZeroL, TmpL);
214 [ - + ]: 1 : ss.clear();
215 [ + - ]: 1 : ss << MaxL;
216 [ + - + - : 2 : BOOST_CHECK_EQUAL(ss.str(), std::string(MaxArray,MaxArray+32));
+ - + - ]
217 [ + - ]: 1 : ss >> TmpL;
218 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(MaxL, TmpL);
219 [ - + ]: 1 : ss.clear();
220 : :
221 [ + - + - : 1 : BOOST_CHECK_EQUAL(R1S.GetHex(), R1S.ToString());
+ - + - ]
222 [ + - + - : 1 : BOOST_CHECK_EQUAL(R2S.GetHex(), R2S.ToString());
+ - + - ]
223 [ + - + - : 1 : BOOST_CHECK_EQUAL(OneS.GetHex(), OneS.ToString());
+ - + - ]
224 [ + - + - : 1 : BOOST_CHECK_EQUAL(MaxS.GetHex(), MaxS.ToString());
+ - + - ]
225 : 1 : uint160 TmpS(R1S);
226 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(TmpS, R1S);
227 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint160::FromHex(R2S.ToString()).value(), R2S);
+ - + - ]
228 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint160::FromHex(ZeroS.ToString()).value(), uint160());
+ - + - ]
229 : :
230 [ + - + - ]: 2 : TmpS = uint160::FromHex(R1S.ToString()).value();
231 [ + - + - : 2 : BOOST_CHECK_EQUAL_COLLECTIONS(R1S.begin(), R1S.end(), R1Array, R1Array + uint160::size());
+ - + - ]
232 [ + - + - : 2 : BOOST_CHECK_EQUAL_COLLECTIONS(TmpS.begin(), TmpS.end(), R1Array, R1Array + uint160::size());
+ - + - ]
233 [ + - + - : 2 : BOOST_CHECK_EQUAL_COLLECTIONS(R2S.begin(), R2S.end(), R2Array, R2Array + uint160::size());
+ - + - ]
234 [ + - + - : 2 : BOOST_CHECK_EQUAL_COLLECTIONS(ZeroS.begin(), ZeroS.end(), ZeroArray, ZeroArray + uint160::size());
+ - + - ]
235 [ + - + - : 2 : BOOST_CHECK_EQUAL_COLLECTIONS(OneS.begin(), OneS.end(), OneArray, OneArray + uint160::size());
+ - + - ]
236 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(R1S.size(), sizeof(R1S));
237 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(sizeof(R1S), 20);
238 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(R1S.size(), 20);
239 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(R2S.size(), 20);
240 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(ZeroS.size(), 20);
241 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(MaxS.size(), 20);
242 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(R1S.begin() + 20, R1S.end());
243 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(R2S.begin() + 20, R2S.end());
244 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(OneS.begin() + 20, OneS.end());
245 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(MaxS.begin() + 20, MaxS.end());
246 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(TmpS.begin() + 20, TmpS.end());
247 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(GetSerializeSize(R1S), 20);
248 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(GetSerializeSize(ZeroS), 20);
249 : :
250 [ + - ]: 1 : ss << R1S;
251 [ + - + - : 2 : BOOST_CHECK_EQUAL(ss.str(), std::string(R1Array,R1Array+20));
+ - + - ]
252 [ + - ]: 1 : ss >> TmpS;
253 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(R1S, TmpS);
254 [ - + ]: 1 : ss.clear();
255 [ + - ]: 1 : ss << ZeroS;
256 [ + - + - : 2 : BOOST_CHECK_EQUAL(ss.str(), std::string(ZeroArray,ZeroArray+20));
+ - + - ]
257 [ + - ]: 1 : ss >> TmpS;
258 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(ZeroS, TmpS);
259 [ - + ]: 1 : ss.clear();
260 [ + - ]: 1 : ss << MaxS;
261 [ + - + - : 2 : BOOST_CHECK_EQUAL(ss.str(), std::string(MaxArray,MaxArray+20));
+ - + - ]
262 [ + - ]: 1 : ss >> TmpS;
263 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(MaxS, TmpS);
264 [ - + ]: 1 : ss.clear();
265 : 1 : }
266 : :
267 [ + - + - : 7 : BOOST_AUTO_TEST_CASE( conversion )
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
268 : : {
269 [ + - ]: 1 : BOOST_CHECK_EQUAL(ArithToUint256(UintToArith256(ZeroL)), ZeroL);
270 [ + - ]: 1 : BOOST_CHECK_EQUAL(ArithToUint256(UintToArith256(OneL)), OneL);
271 [ + - ]: 1 : BOOST_CHECK_EQUAL(ArithToUint256(UintToArith256(R1L)), R1L);
272 [ + - ]: 1 : BOOST_CHECK_EQUAL(ArithToUint256(UintToArith256(R2L)), R2L);
273 [ + - ]: 1 : BOOST_CHECK_EQUAL(UintToArith256(ZeroL), 0);
274 [ + - ]: 1 : BOOST_CHECK_EQUAL(UintToArith256(OneL), 1);
275 [ + - ]: 2 : BOOST_CHECK_EQUAL(ArithToUint256(0), ZeroL);
276 [ + - ]: 2 : BOOST_CHECK_EQUAL(ArithToUint256(1), OneL);
277 [ + - + - : 2 : BOOST_CHECK_EQUAL(arith_uint256(UintToArith256(uint256S(R1L.GetHex()))), UintToArith256(R1L));
+ - ]
278 [ + - + - : 2 : BOOST_CHECK_EQUAL(arith_uint256(UintToArith256(uint256S(R2L.GetHex()))), UintToArith256(R2L));
+ - ]
279 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(R1L.GetHex(), UintToArith256(R1L).GetHex());
280 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(R2L.GetHex(), UintToArith256(R2L).GetHex());
281 : 1 : }
282 : :
283 [ + - + - : 7 : BOOST_AUTO_TEST_CASE( operator_with_self )
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
284 : : {
285 : :
286 : : /* Clang 16 and earlier detects v -= v and v /= v as self-assignments
287 : : to 0 and 1 respectively.
288 : : See: https://github.com/llvm/llvm-project/issues/42469
289 : : and the fix in commit c5302325b2a62d77cf13dd16cd5c19141862fed0 .
290 : :
291 : : This makes some sense for arithmetic classes, but could be considered a bug
292 : : elsewhere. Disable the warning here so that the code can be tested, but the
293 : : warning should remain on as there will likely always be a better way to
294 : : express this.
295 : : */
296 : :
297 : : #if defined(__clang__)
298 : : # pragma clang diagnostic push
299 : : # pragma clang diagnostic ignored "-Wself-assign-overloaded"
300 : : #endif
301 : 1 : arith_uint256 v = UintToArith256(uint256S("02"));
302 : 1 : v *= v;
303 [ + - ]: 1 : BOOST_CHECK_EQUAL(v, UintToArith256(uint256S("04")));
304 : 1 : v /= v;
305 [ + - ]: 1 : BOOST_CHECK_EQUAL(v, UintToArith256(uint256S("01")));
306 : 1 : v += v;
307 [ + - ]: 1 : BOOST_CHECK_EQUAL(v, UintToArith256(uint256S("02")));
308 : 1 : v -= v;
309 [ + - ]: 1 : BOOST_CHECK_EQUAL(v, UintToArith256(uint256S("0")));
310 : : #if defined(__clang__)
311 : : # pragma clang diagnostic pop
312 : : #endif
313 : 1 : }
314 : :
315 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(parse)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
316 : : {
317 : 1 : {
318 : 1 : std::string s_12{"0000000000000000000000000000000000000000000000000000000000000012"};
319 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S("12\0").GetHex(), s_12);
+ - + - ]
320 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S(std::string_view{"12\0", 3}).GetHex(), s_12);
+ - + - ]
321 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S("0x12").GetHex(), s_12);
+ - + - ]
322 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S(" 0x12").GetHex(), s_12);
+ - + - ]
323 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S(" 12").GetHex(), s_12);
+ - + - ]
324 : 0 : }
325 : 1 : {
326 : 1 : std::string s_1{uint256::ONE.GetHex()};
327 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S("1\0").GetHex(), s_1);
+ - + - ]
328 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S(std::string_view{"1\0", 2}).GetHex(), s_1);
+ - + - ]
329 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S("0x1").GetHex(), s_1);
+ - + - ]
330 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S(" 0x1").GetHex(), s_1);
+ - + - ]
331 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S(" 1").GetHex(), s_1);
+ - + - ]
332 : 0 : }
333 : 1 : {
334 : 1 : std::string s_0{uint256::ZERO.GetHex()};
335 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S("\0").GetHex(), s_0);
+ - + - ]
336 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S(std::string_view{"\0", 1}).GetHex(), s_0);
+ - + - ]
337 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S("0x").GetHex(), s_0);
+ - + - ]
338 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S(" 0x").GetHex(), s_0);
+ - + - ]
339 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256S(" ").GetHex(), s_0);
+ - + - ]
340 : 1 : }
341 : 1 : }
342 : :
343 : : /**
344 : : * Implemented as a templated function so it can be reused by other classes that have a FromHex()
345 : : * method that wraps base_blob::FromHex(), such as transaction_identifier::FromHex().
346 : : */
347 : : template <typename T>
348 : 4 : void TestFromHex()
349 : : {
350 : 4 : constexpr unsigned int num_chars{T::size() * 2};
351 : : static_assert(num_chars <= 64); // this test needs to be modified to allow for more than 64 hex chars
352 : 4 : const std::string valid_64char_input{"0123456789abcdef0123456789ABCDEF0123456789abcdef0123456789ABCDEF"};
353 [ + - ]: 4 : const auto valid_input{valid_64char_input.substr(0, num_chars)};
354 : : {
355 : : // check that lower and upper case hex characters are accepted
356 [ + - ]: 4 : auto valid_result{T::FromHex(valid_input)};
357 [ + - + - : 8 : BOOST_REQUIRE(valid_result);
+ - ]
358 [ + - + - : 4 : BOOST_CHECK_EQUAL(valid_result->ToString(), ToLower(valid_input));
+ - + - ]
359 : : }
360 : : {
361 : : // check that only strings of size num_chars are accepted
362 [ + - + - : 8 : BOOST_CHECK(!T::FromHex(""));
+ - + - ]
363 [ + - + - : 8 : BOOST_CHECK(!T::FromHex("0"));
+ - + - ]
364 [ + - + - : 8 : BOOST_CHECK(!T::FromHex(valid_input.substr(0, num_chars / 2)));
+ - + - +
- ]
365 [ + - + - : 8 : BOOST_CHECK(!T::FromHex(valid_input.substr(0, num_chars - 1)));
+ - + - +
- ]
366 [ + - + - : 8 : BOOST_CHECK(!T::FromHex(valid_input + "0"));
+ - + - +
- ]
367 : : }
368 : : {
369 : : // check that non-hex characters are not accepted
370 [ + - ]: 4 : std::string invalid_chars{R"( !"#$%&'()*+,-./:;<=>?@GHIJKLMNOPQRSTUVWXYZ[\]^_`ghijklmnopqrstuvwxyz{|}~)"};
371 [ + + ]: 296 : for (auto c : invalid_chars) {
372 [ + - + - : 584 : BOOST_CHECK(!T::FromHex(valid_input.substr(0, num_chars - 1) + c));
+ - + - +
- ]
373 : : }
374 : : // 0x prefixes are invalid
375 [ + - ]: 4 : std::string invalid_prefix{"0x" + valid_input};
376 [ + - + - : 8 : BOOST_CHECK(!T::FromHex(std::string_view(invalid_prefix.data(), num_chars)));
+ - + - ]
377 [ + - + - : 8 : BOOST_CHECK(!T::FromHex(invalid_prefix));
+ - ]
378 : 4 : }
379 : : {
380 : : // check that string_view length is respected
381 [ + - ]: 4 : std::string chars_68{valid_64char_input + "0123"};
382 [ + - + - : 8 : BOOST_CHECK_EQUAL(T::FromHex(std::string_view(chars_68.data(), num_chars)).value().ToString(), ToLower(valid_input));
+ - + - +
- ]
383 [ + - + - : 8 : BOOST_CHECK(!T::FromHex(std::string_view(chars_68.data(), num_chars - 1))); // too short
+ - + - ]
384 [ + - + - : 8 : BOOST_CHECK(!T::FromHex(std::string_view(chars_68.data(), num_chars + 1))); // too long
+ - ]
385 : 4 : }
386 : 4 : }
387 : :
388 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(from_hex)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
389 : : {
390 : 1 : TestFromHex<uint160>();
391 : 1 : TestFromHex<uint256>();
392 : 1 : TestFromHex<Txid>();
393 : 1 : TestFromHex<Wtxid>();
394 : 1 : }
395 : :
396 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(from_user_hex)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
397 : : {
398 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(uint256::FromUserHex("").value(), uint256::ZERO);
399 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(uint256::FromUserHex("0x").value(), uint256::ZERO);
400 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(uint256::FromUserHex("0").value(), uint256::ZERO);
401 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(uint256::FromUserHex("00").value(), uint256::ZERO);
402 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(uint256::FromUserHex("1").value(), uint256::ONE);
403 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(uint256::FromUserHex("0x10").value(), uint256{0x10});
404 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(uint256::FromUserHex("10").value(), uint256{0x10});
405 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(uint256::FromUserHex("0xFf").value(), uint256{0xff});
406 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(uint256::FromUserHex("Ff").value(), uint256{0xff});
407 : 1 : const std::string valid_hex_64{"0x0123456789abcdef0123456789abcdef0123456789ABDCEF0123456789ABCDEF"};
408 [ + - + - ]: 1 : BOOST_REQUIRE_EQUAL(valid_hex_64.size(), 2 + 64); // 0x prefix and 64 hex digits
409 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256::FromUserHex(valid_hex_64.substr(2)).value().ToString(), ToLower(valid_hex_64.substr(2)));
+ - + - +
- + - +
- ]
410 [ + - + - : 2 : BOOST_CHECK_EQUAL(uint256::FromUserHex(valid_hex_64.substr(0)).value().ToString(), ToLower(valid_hex_64.substr(2)));
+ - + - +
- + - +
- ]
411 : :
412 [ + - + - : 2 : BOOST_CHECK(!uint256::FromUserHex("0x0 ")); // no spaces at end,
+ - + - ]
413 [ + - + - : 2 : BOOST_CHECK(!uint256::FromUserHex(" 0x0")); // or beginning,
+ - + - ]
414 [ + - + - : 2 : BOOST_CHECK(!uint256::FromUserHex("0x 0")); // or middle,
+ - + - ]
415 [ + - + - : 2 : BOOST_CHECK(!uint256::FromUserHex(" ")); // etc.
+ - + - ]
416 [ + - + - : 2 : BOOST_CHECK(!uint256::FromUserHex("0x0ga")); // invalid character
+ - + - ]
417 [ + - + - : 2 : BOOST_CHECK(!uint256::FromUserHex("x0")); // broken prefix
+ - + - ]
418 [ + - + - : 2 : BOOST_CHECK(!uint256::FromUserHex("0x0x00")); // two prefixes not allowed
+ - + - ]
419 [ + - + - : 3 : BOOST_CHECK(!uint256::FromUserHex(valid_hex_64.substr(2) + "0")); // 1 hex digit too many
+ - + - +
- ]
420 [ + - + - : 2 : BOOST_CHECK(!uint256::FromUserHex(valid_hex_64 + "a")); // 1 hex digit too many
+ - + - +
- ]
421 [ + - + - : 2 : BOOST_CHECK(!uint256::FromUserHex(valid_hex_64 + " ")); // whitespace after max length
+ - + - +
- ]
422 [ + - + - : 2 : BOOST_CHECK(!uint256::FromUserHex(valid_hex_64 + "z")); // invalid character after max length
+ - + - ]
423 : 1 : }
424 : :
425 [ + - + - : 7 : BOOST_AUTO_TEST_CASE( check_ONE )
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
426 : : {
427 : 1 : uint256 one = uint256{"0000000000000000000000000000000000000000000000000000000000000001"};
428 [ + - ]: 1 : BOOST_CHECK_EQUAL(one, uint256::ONE);
429 : 1 : }
430 : :
431 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(FromHex_vs_uint256)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
432 : : {
433 [ + - ]: 1 : auto runtime_uint{uint256::FromHex("4A5E1E4BAAB89F3A32518A88C31BC87F618f76673e2cc77ab2127b7afdeda33b").value()};
434 : 1 : constexpr uint256 consteval_uint{ "4a5e1e4baab89f3a32518a88c31bc87f618F76673E2CC77AB2127B7AFDEDA33B"};
435 [ + - ]: 1 : BOOST_CHECK_EQUAL(consteval_uint, runtime_uint);
436 : 1 : }
437 : :
438 : : BOOST_AUTO_TEST_SUITE_END()
|
