uint256_tests.cpp raw
1 // Copyright (c) 2011-2021 The Limenka 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 <streams.h>
6 #include <test/util/setup_common.h>
7 #include <uint256.h>
8 #include <util/strencodings.h>
9 #include <util/transaction_identifier.h>
10
11 #include <boost/test/unit_test.hpp>
12
13 #include <iomanip>
14 #include <sstream>
15 #include <string>
16 #include <string_view>
17 #include <vector>
18
19 BOOST_AUTO_TEST_SUITE(uint256_tests)
20
21 const unsigned char R1Array[] =
22 "\x9c\x52\x4a\xdb\xcf\x56\x11\x12\x2b\x29\x12\x5e\x5d\x35\xd2\xd2"
23 "\x22\x81\xaa\xb5\x33\xf0\x08\x32\xd5\x56\xb1\xf9\xea\xe5\x1d\x7d";
24 const char R1ArrayHex[] = "7D1DE5EAF9B156D53208F033B5AA8122D2d2355d5e12292b121156cfdb4a529c";
25 const uint256 R1L = uint256(std::vector<unsigned char>(R1Array,R1Array+32));
26 const uint160 R1S = uint160(std::vector<unsigned char>(R1Array,R1Array+20));
27
28 const unsigned char R2Array[] =
29 "\x70\x32\x1d\x7c\x47\xa5\x6b\x40\x26\x7e\x0a\xc3\xa6\x9c\xb6\xbf"
30 "\x13\x30\x47\xa3\x19\x2d\xda\x71\x49\x13\x72\xf0\xb4\xca\x81\xd7";
31 const uint256 R2L = uint256(std::vector<unsigned char>(R2Array,R2Array+32));
32 const uint160 R2S = uint160(std::vector<unsigned char>(R2Array,R2Array+20));
33
34 const unsigned char ZeroArray[] =
35 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
36 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
37 const uint256 ZeroL = uint256(std::vector<unsigned char>(ZeroArray,ZeroArray+32));
38 const uint160 ZeroS = uint160(std::vector<unsigned char>(ZeroArray,ZeroArray+20));
39
40 const unsigned char OneArray[] =
41 "\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
42 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
43 const uint256 OneL = uint256(std::vector<unsigned char>(OneArray,OneArray+32));
44 const uint160 OneS = uint160(std::vector<unsigned char>(OneArray,OneArray+20));
45
46 const unsigned char MaxArray[] =
47 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
48 "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff";
49 const uint256 MaxL = uint256(std::vector<unsigned char>(MaxArray,MaxArray+32));
50 const uint160 MaxS = uint160(std::vector<unsigned char>(MaxArray,MaxArray+20));
51
52 static std::string ArrayToString(const unsigned char A[], unsigned int width)
53 {
54 std::stringstream Stream;
55 Stream << std::hex;
56 for (unsigned int i = 0; i < width; ++i)
57 {
58 Stream<<std::setw(2)<<std::setfill('0')<<(unsigned int)A[width-i-1];
59 }
60 return Stream.str();
61 }
62
63 BOOST_AUTO_TEST_CASE( basics ) // constructors, equality, inequality
64 {
65 // constructor uint256(vector<char>):
66 BOOST_CHECK_EQUAL(R1L.ToString(), ArrayToString(R1Array,32));
67 BOOST_CHECK_EQUAL(R1S.ToString(), ArrayToString(R1Array,20));
68 BOOST_CHECK_EQUAL(R2L.ToString(), ArrayToString(R2Array,32));
69 BOOST_CHECK_EQUAL(R2S.ToString(), ArrayToString(R2Array,20));
70 BOOST_CHECK_EQUAL(ZeroL.ToString(), ArrayToString(ZeroArray,32));
71 BOOST_CHECK_EQUAL(ZeroS.ToString(), ArrayToString(ZeroArray,20));
72 BOOST_CHECK_EQUAL(OneL.ToString(), ArrayToString(OneArray,32));
73 BOOST_CHECK_EQUAL(OneS.ToString(), ArrayToString(OneArray,20));
74 BOOST_CHECK_EQUAL(MaxL.ToString(), ArrayToString(MaxArray,32));
75 BOOST_CHECK_EQUAL(MaxS.ToString(), ArrayToString(MaxArray,20));
76 BOOST_CHECK_NE(OneL.ToString(), ArrayToString(ZeroArray,32));
77 BOOST_CHECK_NE(OneS.ToString(), ArrayToString(ZeroArray,20));
78
79 // == and !=
80 BOOST_CHECK_NE(R1L, R2L); BOOST_CHECK_NE(R1S, R2S);
81 BOOST_CHECK_NE(ZeroL, OneL); BOOST_CHECK_NE(ZeroS, OneS);
82 BOOST_CHECK_NE(OneL, ZeroL); BOOST_CHECK_NE(OneS, ZeroS);
83 BOOST_CHECK_NE(MaxL, ZeroL); BOOST_CHECK_NE(MaxS, ZeroS);
84
85 // String Constructor and Copy Constructor
86 BOOST_CHECK_EQUAL(uint256::FromHex(R1L.ToString()).value(), R1L);
87 BOOST_CHECK_EQUAL(uint256::FromHex(R2L.ToString()).value(), R2L);
88 BOOST_CHECK_EQUAL(uint256::FromHex(ZeroL.ToString()).value(), ZeroL);
89 BOOST_CHECK_EQUAL(uint256::FromHex(OneL.ToString()).value(), OneL);
90 BOOST_CHECK_EQUAL(uint256::FromHex(MaxL.ToString()).value(), MaxL);
91 BOOST_CHECK_EQUAL(uint256::FromHex(R1ArrayHex).value(), R1L);
92 BOOST_CHECK_EQUAL(uint256(R1L), R1L);
93 BOOST_CHECK_EQUAL(uint256(ZeroL), ZeroL);
94 BOOST_CHECK_EQUAL(uint256(OneL), OneL);
95
96 BOOST_CHECK_EQUAL(uint160::FromHex(R1S.ToString()).value(), R1S);
97 BOOST_CHECK_EQUAL(uint160::FromHex(R2S.ToString()).value(), R2S);
98 BOOST_CHECK_EQUAL(uint160::FromHex(ZeroS.ToString()).value(), ZeroS);
99 BOOST_CHECK_EQUAL(uint160::FromHex(OneS.ToString()).value(), OneS);
100 BOOST_CHECK_EQUAL(uint160::FromHex(MaxS.ToString()).value(), MaxS);
101 BOOST_CHECK_EQUAL(uint160::FromHex(std::string_view{R1ArrayHex + 24, 40}).value(), R1S);
102
103 BOOST_CHECK_EQUAL(uint160(R1S), R1S);
104 BOOST_CHECK_EQUAL(uint160(ZeroS), ZeroS);
105 BOOST_CHECK_EQUAL(uint160(OneS), OneS);
106 }
107
108 BOOST_AUTO_TEST_CASE( comparison ) // <= >= < >
109 {
110 uint256 LastL;
111 for (int i = 255; i >= 0; --i) {
112 uint256 TmpL;
113 *(TmpL.begin() + (i>>3)) |= 1<<(7-(i&7));
114 BOOST_CHECK_LT(LastL, TmpL);
115 LastL = TmpL;
116 }
117
118 BOOST_CHECK_LT(ZeroL, R1L);
119 BOOST_CHECK_LT(R2L, R1L);
120 BOOST_CHECK_LT(ZeroL, OneL);
121 BOOST_CHECK_LT(OneL, MaxL);
122 BOOST_CHECK_LT(R1L, MaxL);
123 BOOST_CHECK_LT(R2L, MaxL);
124
125 uint160 LastS;
126 for (int i = 159; i >= 0; --i) {
127 uint160 TmpS;
128 *(TmpS.begin() + (i>>3)) |= 1<<(7-(i&7));
129 BOOST_CHECK_LT(LastS, TmpS);
130 LastS = TmpS;
131 }
132 BOOST_CHECK_LT(ZeroS, R1S);
133 BOOST_CHECK_LT(R2S, R1S);
134 BOOST_CHECK_LT(ZeroS, OneS);
135 BOOST_CHECK_LT(OneS, MaxS);
136 BOOST_CHECK_LT(R1S, MaxS);
137 BOOST_CHECK_LT(R2S, MaxS);
138
139 // Non-arithmetic uint256s compare from the beginning of their inner arrays:
140 BOOST_CHECK_LT(R2L, R1L);
141 // Ensure first element comparisons give the same order as above:
142 BOOST_CHECK_LT(*R2L.begin(), *R1L.begin());
143 // Ensure last element comparisons give a different result (swapped params):
144 BOOST_CHECK_LT(*(R1L.end()-1), *(R2L.end()-1));
145 // Hex strings represent reverse-encoded bytes, with lexicographic ordering:
146 BOOST_CHECK_LT(uint256{"1000000000000000000000000000000000000000000000000000000000000000"},
147 uint256{"0000000000000000000000000000000000000000000000000000000000000001"});
148 }
149
150 BOOST_AUTO_TEST_CASE(methods) // GetHex SetHexDeprecated FromHex begin() end() size() GetLow64 GetSerializeSize, Serialize, Unserialize
151 {
152 BOOST_CHECK_EQUAL(R1L.GetHex(), R1L.ToString());
153 BOOST_CHECK_EQUAL(R2L.GetHex(), R2L.ToString());
154 BOOST_CHECK_EQUAL(OneL.GetHex(), OneL.ToString());
155 BOOST_CHECK_EQUAL(MaxL.GetHex(), MaxL.ToString());
156 uint256 TmpL(R1L);
157 BOOST_CHECK_EQUAL(TmpL, R1L);
158 // Verify previous values don't persist when setting to truncated string.
159 TmpL.SetHexDeprecated("21");
160 BOOST_CHECK_EQUAL(TmpL.ToString(), "0000000000000000000000000000000000000000000000000000000000000021");
161 BOOST_CHECK_EQUAL(uint256::FromHex(R2L.ToString()).value(), R2L);
162 BOOST_CHECK_EQUAL(uint256::FromHex(ZeroL.ToString()).value(), uint256());
163
164 TmpL = uint256::FromHex(R1L.ToString()).value();
165 BOOST_CHECK_EQUAL_COLLECTIONS(R1L.begin(), R1L.end(), R1Array, R1Array + uint256::size());
166 BOOST_CHECK_EQUAL_COLLECTIONS(TmpL.begin(), TmpL.end(), R1Array, R1Array + uint256::size());
167 BOOST_CHECK_EQUAL_COLLECTIONS(R2L.begin(), R2L.end(), R2Array, R2Array + uint256::size());
168 BOOST_CHECK_EQUAL_COLLECTIONS(ZeroL.begin(), ZeroL.end(), ZeroArray, ZeroArray + uint256::size());
169 BOOST_CHECK_EQUAL_COLLECTIONS(OneL.begin(), OneL.end(), OneArray, OneArray + uint256::size());
170 BOOST_CHECK_EQUAL(R1L.size(), sizeof(R1L));
171 BOOST_CHECK_EQUAL(sizeof(R1L), 32);
172 BOOST_CHECK_EQUAL(R1L.size(), 32);
173 BOOST_CHECK_EQUAL(R2L.size(), 32);
174 BOOST_CHECK_EQUAL(ZeroL.size(), 32);
175 BOOST_CHECK_EQUAL(MaxL.size(), 32);
176 BOOST_CHECK_EQUAL(R1L.begin() + 32, R1L.end());
177 BOOST_CHECK_EQUAL(R2L.begin() + 32, R2L.end());
178 BOOST_CHECK_EQUAL(OneL.begin() + 32, OneL.end());
179 BOOST_CHECK_EQUAL(MaxL.begin() + 32, MaxL.end());
180 BOOST_CHECK_EQUAL(TmpL.begin() + 32, TmpL.end());
181 BOOST_CHECK_EQUAL(GetSerializeSize(R1L), 32);
182 BOOST_CHECK_EQUAL(GetSerializeSize(ZeroL), 32);
183
184 DataStream ss{};
185 ss << R1L;
186 BOOST_CHECK_EQUAL(ss.str(), std::string(R1Array,R1Array+32));
187 ss >> TmpL;
188 BOOST_CHECK_EQUAL(R1L, TmpL);
189 ss.clear();
190 ss << ZeroL;
191 BOOST_CHECK_EQUAL(ss.str(), std::string(ZeroArray,ZeroArray+32));
192 ss >> TmpL;
193 BOOST_CHECK_EQUAL(ZeroL, TmpL);
194 ss.clear();
195 ss << MaxL;
196 BOOST_CHECK_EQUAL(ss.str(), std::string(MaxArray,MaxArray+32));
197 ss >> TmpL;
198 BOOST_CHECK_EQUAL(MaxL, TmpL);
199 ss.clear();
200
201 BOOST_CHECK_EQUAL(R1S.GetHex(), R1S.ToString());
202 BOOST_CHECK_EQUAL(R2S.GetHex(), R2S.ToString());
203 BOOST_CHECK_EQUAL(OneS.GetHex(), OneS.ToString());
204 BOOST_CHECK_EQUAL(MaxS.GetHex(), MaxS.ToString());
205 uint160 TmpS(R1S);
206 BOOST_CHECK_EQUAL(TmpS, R1S);
207 BOOST_CHECK_EQUAL(uint160::FromHex(R2S.ToString()).value(), R2S);
208 BOOST_CHECK_EQUAL(uint160::FromHex(ZeroS.ToString()).value(), uint160());
209
210 TmpS = uint160::FromHex(R1S.ToString()).value();
211 BOOST_CHECK_EQUAL_COLLECTIONS(R1S.begin(), R1S.end(), R1Array, R1Array + uint160::size());
212 BOOST_CHECK_EQUAL_COLLECTIONS(TmpS.begin(), TmpS.end(), R1Array, R1Array + uint160::size());
213 BOOST_CHECK_EQUAL_COLLECTIONS(R2S.begin(), R2S.end(), R2Array, R2Array + uint160::size());
214 BOOST_CHECK_EQUAL_COLLECTIONS(ZeroS.begin(), ZeroS.end(), ZeroArray, ZeroArray + uint160::size());
215 BOOST_CHECK_EQUAL_COLLECTIONS(OneS.begin(), OneS.end(), OneArray, OneArray + uint160::size());
216 BOOST_CHECK_EQUAL(R1S.size(), sizeof(R1S));
217 BOOST_CHECK_EQUAL(sizeof(R1S), 20);
218 BOOST_CHECK_EQUAL(R1S.size(), 20);
219 BOOST_CHECK_EQUAL(R2S.size(), 20);
220 BOOST_CHECK_EQUAL(ZeroS.size(), 20);
221 BOOST_CHECK_EQUAL(MaxS.size(), 20);
222 BOOST_CHECK_EQUAL(R1S.begin() + 20, R1S.end());
223 BOOST_CHECK_EQUAL(R2S.begin() + 20, R2S.end());
224 BOOST_CHECK_EQUAL(OneS.begin() + 20, OneS.end());
225 BOOST_CHECK_EQUAL(MaxS.begin() + 20, MaxS.end());
226 BOOST_CHECK_EQUAL(TmpS.begin() + 20, TmpS.end());
227 BOOST_CHECK_EQUAL(GetSerializeSize(R1S), 20);
228 BOOST_CHECK_EQUAL(GetSerializeSize(ZeroS), 20);
229
230 ss << R1S;
231 BOOST_CHECK_EQUAL(ss.str(), std::string(R1Array,R1Array+20));
232 ss >> TmpS;
233 BOOST_CHECK_EQUAL(R1S, TmpS);
234 ss.clear();
235 ss << ZeroS;
236 BOOST_CHECK_EQUAL(ss.str(), std::string(ZeroArray,ZeroArray+20));
237 ss >> TmpS;
238 BOOST_CHECK_EQUAL(ZeroS, TmpS);
239 ss.clear();
240 ss << MaxS;
241 BOOST_CHECK_EQUAL(ss.str(), std::string(MaxArray,MaxArray+20));
242 ss >> TmpS;
243 BOOST_CHECK_EQUAL(MaxS, TmpS);
244 ss.clear();
245 }
246
247 /**
248 * Implemented as a templated function so it can be reused by other classes that have a FromHex()
249 * method that wraps base_blob::FromHex(), such as transaction_identifier::FromHex().
250 */
251 template <typename T>
252 void TestFromHex()
253 {
254 constexpr unsigned int num_chars{T::size() * 2};
255 static_assert(num_chars <= 64); // this test needs to be modified to allow for more than 64 hex chars
256 const std::string valid_64char_input{"0123456789abcdef0123456789ABCDEF0123456789abcdef0123456789ABCDEF"};
257 const auto valid_input{valid_64char_input.substr(0, num_chars)};
258 {
259 // check that lower and upper case hex characters are accepted
260 auto valid_result{T::FromHex(valid_input)};
261 BOOST_REQUIRE(valid_result);
262 BOOST_CHECK_EQUAL(valid_result->ToString(), ToLower(valid_input));
263 }
264 {
265 // check that only strings of size num_chars are accepted
266 BOOST_CHECK(!T::FromHex(""));
267 BOOST_CHECK(!T::FromHex("0"));
268 BOOST_CHECK(!T::FromHex(valid_input.substr(0, num_chars / 2)));
269 BOOST_CHECK(!T::FromHex(valid_input.substr(0, num_chars - 1)));
270 BOOST_CHECK(!T::FromHex(valid_input + "0"));
271 }
272 {
273 // check that non-hex characters are not accepted
274 std::string invalid_chars{R"( !"#$%&'()*+,-./:;<=>?@GHIJKLMNOPQRSTUVWXYZ[\]^_`ghijklmnopqrstuvwxyz{|}~)"};
275 for (auto c : invalid_chars) {
276 BOOST_CHECK(!T::FromHex(valid_input.substr(0, num_chars - 1) + c));
277 }
278 // 0x prefixes are invalid
279 std::string invalid_prefix{"0x" + valid_input};
280 BOOST_CHECK(!T::FromHex(std::string_view(invalid_prefix.data(), num_chars)));
281 BOOST_CHECK(!T::FromHex(invalid_prefix));
282 }
283 {
284 // check that string_view length is respected
285 std::string chars_68{valid_64char_input + "0123"};
286 BOOST_CHECK_EQUAL(T::FromHex(std::string_view(chars_68.data(), num_chars)).value().ToString(), ToLower(valid_input));
287 BOOST_CHECK(!T::FromHex(std::string_view(chars_68.data(), num_chars - 1))); // too short
288 BOOST_CHECK(!T::FromHex(std::string_view(chars_68.data(), num_chars + 1))); // too long
289 }
290 }
291
292 BOOST_AUTO_TEST_CASE(from_hex)
293 {
294 TestFromHex<uint160>();
295 TestFromHex<uint256>();
296 TestFromHex<Txid>();
297 TestFromHex<Wtxid>();
298 }
299
300 BOOST_AUTO_TEST_CASE(from_user_hex)
301 {
302 BOOST_CHECK_EQUAL(uint256::FromUserHex(""), uint256::ZERO);
303 BOOST_CHECK_EQUAL(uint256::FromUserHex("0x"), uint256::ZERO);
304 BOOST_CHECK_EQUAL(uint256::FromUserHex("0"), uint256::ZERO);
305 BOOST_CHECK_EQUAL(uint256::FromUserHex("00"), uint256::ZERO);
306 BOOST_CHECK_EQUAL(uint256::FromUserHex("1"), uint256::ONE);
307 BOOST_CHECK_EQUAL(uint256::FromUserHex("0x10"), uint256{0x10});
308 BOOST_CHECK_EQUAL(uint256::FromUserHex("10"), uint256{0x10});
309 BOOST_CHECK_EQUAL(uint256::FromUserHex("0xFf"), uint256{0xff});
310 BOOST_CHECK_EQUAL(uint256::FromUserHex("Ff"), uint256{0xff});
311 const std::string valid_hex_64{"0x0123456789abcdef0123456789abcdef0123456789ABDCEF0123456789ABCDEF"};
312 BOOST_REQUIRE_EQUAL(valid_hex_64.size(), 2 + 64); // 0x prefix and 64 hex digits
313 BOOST_CHECK_EQUAL(uint256::FromUserHex(valid_hex_64.substr(2)).value().ToString(), ToLower(valid_hex_64.substr(2)));
314 BOOST_CHECK_EQUAL(uint256::FromUserHex(valid_hex_64.substr(0)).value().ToString(), ToLower(valid_hex_64.substr(2)));
315
316 BOOST_CHECK(!uint256::FromUserHex("0x0 ")); // no spaces at end,
317 BOOST_CHECK(!uint256::FromUserHex(" 0x0")); // or beginning,
318 BOOST_CHECK(!uint256::FromUserHex("0x 0")); // or middle,
319 BOOST_CHECK(!uint256::FromUserHex(" ")); // etc.
320 BOOST_CHECK(!uint256::FromUserHex("0x0ga")); // invalid character
321 BOOST_CHECK(!uint256::FromUserHex("x0")); // broken prefix
322 BOOST_CHECK(!uint256::FromUserHex("0x0x00")); // two prefixes not allowed
323 BOOST_CHECK(!uint256::FromUserHex(valid_hex_64.substr(2) + "0")); // 1 hex digit too many
324 BOOST_CHECK(!uint256::FromUserHex(valid_hex_64 + "a")); // 1 hex digit too many
325 BOOST_CHECK(!uint256::FromUserHex(valid_hex_64 + " ")); // whitespace after max length
326 BOOST_CHECK(!uint256::FromUserHex(valid_hex_64 + "z")); // invalid character after max length
327 }
328
329 BOOST_AUTO_TEST_CASE( check_ONE )
330 {
331 uint256 one = uint256{"0000000000000000000000000000000000000000000000000000000000000001"};
332 BOOST_CHECK_EQUAL(one, uint256::ONE);
333 }
334
335 BOOST_AUTO_TEST_CASE(FromHex_vs_uint256)
336 {
337 auto runtime_uint{uint256::FromHex("4A5E1E4BAAB89F3A32518A88C31BC87F618f76673e2cc77ab2127b7afdeda33b")};
338 constexpr uint256 consteval_uint{ "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"};
339 BOOST_CHECK_EQUAL(consteval_uint, runtime_uint);
340 }
341
342 BOOST_AUTO_TEST_SUITE_END()
343