Bitcoin Core  27.99.0
P2P Digital Currency
uint256_tests.cpp
Go to the documentation of this file.
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>
8 #include <uint256.h>
9 
10 #include <boost/test/unit_test.hpp>
11 
12 #include <iomanip>
13 #include <sstream>
14 #include <string>
15 #include <vector>
16 
17 BOOST_AUTO_TEST_SUITE(uint256_tests)
18 
19 const unsigned char R1Array[] =
20  "\x9c\x52\x4a\xdb\xcf\x56\x11\x12\x2b\x29\x12\x5e\x5d\x35\xd2\xd2"
21  "\x22\x81\xaa\xb5\x33\xf0\x08\x32\xd5\x56\xb1\xf9\xea\xe5\x1d\x7d";
22 const char R1ArrayHex[] = "7D1DE5EAF9B156D53208F033B5AA8122D2d2355d5e12292b121156cfdb4a529c";
23 const uint256 R1L = uint256(std::vector<unsigned char>(R1Array,R1Array+32));
24 const uint160 R1S = uint160(std::vector<unsigned char>(R1Array,R1Array+20));
25 
26 const unsigned char R2Array[] =
27  "\x70\x32\x1d\x7c\x47\xa5\x6b\x40\x26\x7e\x0a\xc3\xa6\x9c\xb6\xbf"
28  "\x13\x30\x47\xa3\x19\x2d\xda\x71\x49\x13\x72\xf0\xb4\xca\x81\xd7";
29 const uint256 R2L = uint256(std::vector<unsigned char>(R2Array,R2Array+32));
30 const uint160 R2S = uint160(std::vector<unsigned char>(R2Array,R2Array+20));
31 
32 const unsigned char ZeroArray[] =
33  "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
34  "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
35 const uint256 ZeroL = uint256(std::vector<unsigned char>(ZeroArray,ZeroArray+32));
36 const uint160 ZeroS = uint160(std::vector<unsigned char>(ZeroArray,ZeroArray+20));
37 
38 const unsigned char OneArray[] =
39  "\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
40  "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
41 const uint256 OneL = uint256(std::vector<unsigned char>(OneArray,OneArray+32));
42 const uint160 OneS = uint160(std::vector<unsigned char>(OneArray,OneArray+20));
43 
44 const unsigned char MaxArray[] =
45  "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
46  "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff";
47 const uint256 MaxL = uint256(std::vector<unsigned char>(MaxArray,MaxArray+32));
48 const uint160 MaxS = uint160(std::vector<unsigned char>(MaxArray,MaxArray+20));
49 
50 static std::string ArrayToString(const unsigned char A[], unsigned int width)
51 {
52  std::stringstream Stream;
53  Stream << std::hex;
54  for (unsigned int i = 0; i < width; ++i)
55  {
56  Stream<<std::setw(2)<<std::setfill('0')<<(unsigned int)A[width-i-1];
57  }
58  return Stream.str();
59 }
60 
61 inline uint160 uint160S(const char *str)
62 {
63  uint160 rv;
64  rv.SetHex(str);
65  return rv;
66 }
67 inline uint160 uint160S(const std::string& str)
68 {
69  uint160 rv;
70  rv.SetHex(str);
71  return rv;
72 }
73 
74 BOOST_AUTO_TEST_CASE( basics ) // constructors, equality, inequality
75 {
76  BOOST_CHECK(1 == 0+1);
77  // constructor uint256(vector<char>):
90 
91  // == and !=
92  BOOST_CHECK(R1L != R2L && R1S != R2S);
93  BOOST_CHECK(ZeroL != OneL && ZeroS != OneS);
94  BOOST_CHECK(OneL != ZeroL && OneS != ZeroS);
95  BOOST_CHECK(MaxL != ZeroL && MaxS != ZeroS);
96 
97  // String Constructor and Copy Constructor
98  BOOST_CHECK(uint256S("0x"+R1L.ToString()) == R1L);
99  BOOST_CHECK(uint256S("0x"+R2L.ToString()) == R2L);
101  BOOST_CHECK(uint256S("0x"+OneL.ToString()) == OneL);
102  BOOST_CHECK(uint256S("0x"+MaxL.ToString()) == MaxL);
104  BOOST_CHECK(uint256S(" 0x"+R1L.ToString()+" ") == R1L);
105  BOOST_CHECK(uint256S("") == ZeroL);
107  BOOST_CHECK(uint256(R1L) == R1L);
110 
111  BOOST_CHECK(uint160S("0x"+R1S.ToString()) == R1S);
112  BOOST_CHECK(uint160S("0x"+R2S.ToString()) == R2S);
114  BOOST_CHECK(uint160S("0x"+OneS.ToString()) == OneS);
115  BOOST_CHECK(uint160S("0x"+MaxS.ToString()) == MaxS);
117  BOOST_CHECK(uint160S(" 0x"+R1S.ToString()+" ") == R1S);
118  BOOST_CHECK(uint160S("") == ZeroS);
120 
121  BOOST_CHECK(uint160(R1S) == R1S);
124 }
125 
126 BOOST_AUTO_TEST_CASE( comparison ) // <= >= < >
127 {
128  uint256 LastL;
129  for (int i = 255; i >= 0; --i) {
130  uint256 TmpL;
131  *(TmpL.begin() + (i>>3)) |= 1<<(7-(i&7));
132  BOOST_CHECK( LastL < TmpL );
133  LastL = TmpL;
134  }
135 
136  BOOST_CHECK( ZeroL < R1L );
137  BOOST_CHECK( R2L < R1L );
138  BOOST_CHECK( ZeroL < OneL );
139  BOOST_CHECK( OneL < MaxL );
140  BOOST_CHECK( R1L < MaxL );
141  BOOST_CHECK( R2L < MaxL );
142 
143  uint160 LastS;
144  for (int i = 159; i >= 0; --i) {
145  uint160 TmpS;
146  *(TmpS.begin() + (i>>3)) |= 1<<(7-(i&7));
147  BOOST_CHECK( LastS < TmpS );
148  LastS = TmpS;
149  }
150  BOOST_CHECK( ZeroS < R1S );
151  BOOST_CHECK( R2S < R1S );
152  BOOST_CHECK( ZeroS < OneS );
153  BOOST_CHECK( OneS < MaxS );
154  BOOST_CHECK( R1S < MaxS );
155  BOOST_CHECK( R2S < MaxS );
156 }
157 
158 BOOST_AUTO_TEST_CASE( methods ) // GetHex SetHex begin() end() size() GetLow64 GetSerializeSize, Serialize, Unserialize
159 {
164  uint256 TmpL(R1L);
165  BOOST_CHECK(TmpL == R1L);
166  TmpL.SetHex(R2L.ToString()); BOOST_CHECK(TmpL == R2L);
167  TmpL.SetHex(ZeroL.ToString()); BOOST_CHECK(TmpL == uint256());
168 
169  TmpL.SetHex(R1L.ToString());
170  BOOST_CHECK(memcmp(R1L.begin(), R1Array, 32)==0);
171  BOOST_CHECK(memcmp(TmpL.begin(), R1Array, 32)==0);
172  BOOST_CHECK(memcmp(R2L.begin(), R2Array, 32)==0);
173  BOOST_CHECK(memcmp(ZeroL.begin(), ZeroArray, 32)==0);
174  BOOST_CHECK(memcmp(OneL.begin(), OneArray, 32)==0);
175  BOOST_CHECK(R1L.size() == sizeof(R1L));
176  BOOST_CHECK(sizeof(R1L) == 32);
177  BOOST_CHECK(R1L.size() == 32);
178  BOOST_CHECK(R2L.size() == 32);
179  BOOST_CHECK(ZeroL.size() == 32);
180  BOOST_CHECK(MaxL.size() == 32);
181  BOOST_CHECK(R1L.begin() + 32 == R1L.end());
182  BOOST_CHECK(R2L.begin() + 32 == R2L.end());
183  BOOST_CHECK(OneL.begin() + 32 == OneL.end());
184  BOOST_CHECK(MaxL.begin() + 32 == MaxL.end());
185  BOOST_CHECK(TmpL.begin() + 32 == TmpL.end());
188 
189  DataStream ss{};
190  ss << R1L;
191  BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+32));
192  ss >> TmpL;
193  BOOST_CHECK(R1L == TmpL);
194  ss.clear();
195  ss << ZeroL;
196  BOOST_CHECK(ss.str() == std::string(ZeroArray,ZeroArray+32));
197  ss >> TmpL;
198  BOOST_CHECK(ZeroL == TmpL);
199  ss.clear();
200  ss << MaxL;
201  BOOST_CHECK(ss.str() == std::string(MaxArray,MaxArray+32));
202  ss >> TmpL;
203  BOOST_CHECK(MaxL == TmpL);
204  ss.clear();
205 
210  uint160 TmpS(R1S);
211  BOOST_CHECK(TmpS == R1S);
212  TmpS.SetHex(R2S.ToString()); BOOST_CHECK(TmpS == R2S);
213  TmpS.SetHex(ZeroS.ToString()); BOOST_CHECK(TmpS == uint160());
214 
215  TmpS.SetHex(R1S.ToString());
216  BOOST_CHECK(memcmp(R1S.begin(), R1Array, 20)==0);
217  BOOST_CHECK(memcmp(TmpS.begin(), R1Array, 20)==0);
218  BOOST_CHECK(memcmp(R2S.begin(), R2Array, 20)==0);
219  BOOST_CHECK(memcmp(ZeroS.begin(), ZeroArray, 20)==0);
220  BOOST_CHECK(memcmp(OneS.begin(), OneArray, 20)==0);
221  BOOST_CHECK(R1S.size() == sizeof(R1S));
222  BOOST_CHECK(sizeof(R1S) == 20);
223  BOOST_CHECK(R1S.size() == 20);
224  BOOST_CHECK(R2S.size() == 20);
225  BOOST_CHECK(ZeroS.size() == 20);
226  BOOST_CHECK(MaxS.size() == 20);
227  BOOST_CHECK(R1S.begin() + 20 == R1S.end());
228  BOOST_CHECK(R2S.begin() + 20 == R2S.end());
229  BOOST_CHECK(OneS.begin() + 20 == OneS.end());
230  BOOST_CHECK(MaxS.begin() + 20 == MaxS.end());
231  BOOST_CHECK(TmpS.begin() + 20 == TmpS.end());
234 
235  ss << R1S;
236  BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+20));
237  ss >> TmpS;
238  BOOST_CHECK(R1S == TmpS);
239  ss.clear();
240  ss << ZeroS;
241  BOOST_CHECK(ss.str() == std::string(ZeroArray,ZeroArray+20));
242  ss >> TmpS;
243  BOOST_CHECK(ZeroS == TmpS);
244  ss.clear();
245  ss << MaxS;
246  BOOST_CHECK(ss.str() == std::string(MaxArray,MaxArray+20));
247  ss >> TmpS;
248  BOOST_CHECK(MaxS == TmpS);
249  ss.clear();
250 }
251 
252 BOOST_AUTO_TEST_CASE( conversion )
253 {
264  BOOST_CHECK(R1L.GetHex() == UintToArith256(R1L).GetHex());
265  BOOST_CHECK(R2L.GetHex() == UintToArith256(R2L).GetHex());
266 }
267 
268 BOOST_AUTO_TEST_CASE( operator_with_self )
269 {
271  v *= v;
272  BOOST_CHECK(v == UintToArith256(uint256S("04")));
273  v /= v;
274  BOOST_CHECK(v == UintToArith256(uint256S("01")));
275  v += v;
276  BOOST_CHECK(v == UintToArith256(uint256S("02")));
277  v -= v;
278  BOOST_CHECK(v == UintToArith256(uint256S("0")));
279 }
280 
282 {
283  {
284  std::string s_12{"0000000000000000000000000000000000000000000000000000000000000012"};
285  BOOST_CHECK_EQUAL(uint256S("12\0").GetHex(), s_12);
286  BOOST_CHECK_EQUAL(uint256S(std::string{"12\0", 3}).GetHex(), s_12);
287  BOOST_CHECK_EQUAL(uint256S("0x12").GetHex(), s_12);
288  BOOST_CHECK_EQUAL(uint256S(" 0x12").GetHex(), s_12);
289  BOOST_CHECK_EQUAL(uint256S(" 12").GetHex(), s_12);
290  }
291  {
292  std::string s_1{uint256::ONE.GetHex()};
293  BOOST_CHECK_EQUAL(uint256S("1\0").GetHex(), s_1);
294  BOOST_CHECK_EQUAL(uint256S(std::string{"1\0", 2}).GetHex(), s_1);
295  BOOST_CHECK_EQUAL(uint256S("0x1").GetHex(), s_1);
296  BOOST_CHECK_EQUAL(uint256S(" 0x1").GetHex(), s_1);
297  BOOST_CHECK_EQUAL(uint256S(" 1").GetHex(), s_1);
298  }
299  {
300  std::string s_0{uint256::ZERO.GetHex()};
301  BOOST_CHECK_EQUAL(uint256S("\0").GetHex(), s_0);
302  BOOST_CHECK_EQUAL(uint256S(std::string{"\0", 1}).GetHex(), s_0);
303  BOOST_CHECK_EQUAL(uint256S("0x").GetHex(), s_0);
304  BOOST_CHECK_EQUAL(uint256S(" 0x").GetHex(), s_0);
305  BOOST_CHECK_EQUAL(uint256S(" ").GetHex(), s_0);
306  }
307 }
308 
310 {
311  uint256 one = uint256S("0000000000000000000000000000000000000000000000000000000000000001");
313 }
314 
arith_uint256 UintToArith256(const uint256 &a)
uint256 ArithToUint256(const arith_uint256 &a)
Double ended buffer combining vector and stream-like interfaces.
Definition: streams.h:147
256-bit unsigned big integer.
constexpr unsigned char * end()
Definition: uint256.h:69
static constexpr unsigned int size()
Definition: uint256.h:74
void SetHex(const char *psz)
Definition: uint256.cpp:21
std::string ToString() const
Definition: uint256.cpp:55
constexpr unsigned char * begin()
Definition: uint256.h:68
std::string GetHex() const
Definition: uint256.cpp:11
160-bit opaque blob.
Definition: uint256.h:95
256-bit opaque blob.
Definition: uint256.h:106
static const uint256 ONE
Definition: uint256.h:112
static const uint256 ZERO
Definition: uint256.h:111
BOOST_AUTO_TEST_SUITE(cuckoocache_tests)
Test Suite for CuckooCache.
BOOST_AUTO_TEST_SUITE_END()
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:18
#define BOOST_CHECK(expr)
Definition: object.cpp:17
size_t GetSerializeSize(const T &t)
Definition: serialize.h:1116
uint256 uint256S(const char *str)
Definition: uint256.h:119
uint160 uint160S(const char *str)
const unsigned char ZeroArray[]
const unsigned char R1Array[]
BOOST_AUTO_TEST_CASE(basics)
const unsigned char OneArray[]
const uint160 OneS
const uint160 MaxS
const char R1ArrayHex[]
const uint160 ZeroS
const uint256 MaxL
const uint160 R1S
const unsigned char R2Array[]
const uint256 R2L
const uint160 R2S
const uint256 R1L
static std::string ArrayToString(const unsigned char A[], unsigned int width)
const unsigned char MaxArray[]
const uint256 ZeroL
const uint256 OneL