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>
7 #include <test/util/setup_common.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 // Input is treated as little-endian.
62 inline uint160 uint160S(std::string_view str)
63 {
64  uint160 rv;
65  rv.SetHexDeprecated(str);
66  return rv;
67 }
68 
69 BOOST_AUTO_TEST_CASE( basics ) // constructors, equality, inequality
70 {
71  // constructor uint256(vector<char>):
72  BOOST_CHECK_EQUAL(R1L.ToString(), ArrayToString(R1Array,32));
73  BOOST_CHECK_EQUAL(R1S.ToString(), ArrayToString(R1Array,20));
74  BOOST_CHECK_EQUAL(R2L.ToString(), ArrayToString(R2Array,32));
75  BOOST_CHECK_EQUAL(R2S.ToString(), ArrayToString(R2Array,20));
76  BOOST_CHECK_EQUAL(ZeroL.ToString(), ArrayToString(ZeroArray,32));
77  BOOST_CHECK_EQUAL(ZeroS.ToString(), ArrayToString(ZeroArray,20));
78  BOOST_CHECK_EQUAL(OneL.ToString(), ArrayToString(OneArray,32));
79  BOOST_CHECK_EQUAL(OneS.ToString(), ArrayToString(OneArray,20));
80  BOOST_CHECK_EQUAL(MaxL.ToString(), ArrayToString(MaxArray,32));
81  BOOST_CHECK_EQUAL(MaxS.ToString(), ArrayToString(MaxArray,20));
82  BOOST_CHECK_NE(OneL.ToString(), ArrayToString(ZeroArray,32));
83  BOOST_CHECK_NE(OneS.ToString(), ArrayToString(ZeroArray,20));
84 
85  // == and !=
86  BOOST_CHECK_NE(R1L, R2L); BOOST_CHECK_NE(R1S, R2S);
87  BOOST_CHECK_NE(ZeroL, OneL); BOOST_CHECK_NE(ZeroS, OneS);
88  BOOST_CHECK_NE(OneL, ZeroL); BOOST_CHECK_NE(OneS, ZeroS);
89  BOOST_CHECK_NE(MaxL, ZeroL); BOOST_CHECK_NE(MaxS, ZeroS);
90 
91  // String Constructor and Copy Constructor
92  BOOST_CHECK_EQUAL(uint256S("0x"+R1L.ToString()), R1L);
93  BOOST_CHECK_EQUAL(uint256S("0x"+R2L.ToString()), R2L);
94  BOOST_CHECK_EQUAL(uint256S("0x"+ZeroL.ToString()), ZeroL);
95  BOOST_CHECK_EQUAL(uint256S("0x"+OneL.ToString()), OneL);
96  BOOST_CHECK_EQUAL(uint256S("0x"+MaxL.ToString()), MaxL);
97  BOOST_CHECK_EQUAL(uint256S(R1L.ToString()), R1L);
98  BOOST_CHECK_EQUAL(uint256S(" 0x"+R1L.ToString()+" "), R1L);
99  BOOST_CHECK_EQUAL(uint256S(" 0x"+R1L.ToString()+"-trash;%^& "), R1L);
100  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);
101  BOOST_CHECK_EQUAL(uint256S(""), ZeroL);
102  BOOST_CHECK_EQUAL(R1L, uint256S(R1ArrayHex));
103  BOOST_CHECK_EQUAL(uint256(R1L), R1L);
104  BOOST_CHECK_EQUAL(uint256(ZeroL), ZeroL);
105  BOOST_CHECK_EQUAL(uint256(OneL), OneL);
106 
107  BOOST_CHECK_EQUAL(uint160S("0x"+R1S.ToString()), R1S);
108  BOOST_CHECK_EQUAL(uint160S("0x"+R2S.ToString()), R2S);
109  BOOST_CHECK_EQUAL(uint160S("0x"+ZeroS.ToString()), ZeroS);
110  BOOST_CHECK_EQUAL(uint160S("0x"+OneS.ToString()), OneS);
111  BOOST_CHECK_EQUAL(uint160S("0x"+MaxS.ToString()), MaxS);
112  BOOST_CHECK_EQUAL(uint160S(R1S.ToString()), R1S);
113  BOOST_CHECK_EQUAL(uint160S(" 0x"+R1S.ToString()+" "), R1S);
114  BOOST_CHECK_EQUAL(uint160S(" 0x"+R1S.ToString()+"-trash;%^& "), R1S);
115  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);
116  BOOST_CHECK_EQUAL(uint160S(""), ZeroS);
117  BOOST_CHECK_EQUAL(R1S, uint160S(R1ArrayHex));
118 
119  BOOST_CHECK_EQUAL(uint160(R1S), R1S);
120  BOOST_CHECK_EQUAL(uint160(ZeroS), ZeroS);
121  BOOST_CHECK_EQUAL(uint160(OneS), OneS);
122 }
123 
124 BOOST_AUTO_TEST_CASE( comparison ) // <= >= < >
125 {
126  uint256 LastL;
127  for (int i = 255; i >= 0; --i) {
128  uint256 TmpL;
129  *(TmpL.begin() + (i>>3)) |= 1<<(7-(i&7));
130  BOOST_CHECK_LT(LastL, TmpL);
131  LastL = TmpL;
132  }
133 
134  BOOST_CHECK_LT(ZeroL, R1L);
135  BOOST_CHECK_LT(R2L, R1L);
136  BOOST_CHECK_LT(ZeroL, OneL);
137  BOOST_CHECK_LT(OneL, MaxL);
138  BOOST_CHECK_LT(R1L, MaxL);
139  BOOST_CHECK_LT(R2L, MaxL);
140 
141  uint160 LastS;
142  for (int i = 159; i >= 0; --i) {
143  uint160 TmpS;
144  *(TmpS.begin() + (i>>3)) |= 1<<(7-(i&7));
145  BOOST_CHECK_LT(LastS, TmpS);
146  LastS = TmpS;
147  }
148  BOOST_CHECK_LT(ZeroS, R1S);
149  BOOST_CHECK_LT(R2S, R1S);
150  BOOST_CHECK_LT(ZeroS, OneS);
151  BOOST_CHECK_LT(OneS, MaxS);
152  BOOST_CHECK_LT(R1S, MaxS);
153  BOOST_CHECK_LT(R2S, MaxS);
154 
155  // Verify hex strings are little-endian
156  BOOST_CHECK_LT(uint256S("2000000000000000000000000000000000000000000000000000000000000001"),
157  uint256S("1000000000000000000000000000000000000000000000000000000000000002"));
158 }
159 
160 BOOST_AUTO_TEST_CASE(methods) // GetHex SetHexDeprecated FromHex begin() end() size() GetLow64 GetSerializeSize, Serialize, Unserialize
161 {
162  BOOST_CHECK_EQUAL(R1L.GetHex(), R1L.ToString());
163  BOOST_CHECK_EQUAL(R2L.GetHex(), R2L.ToString());
164  BOOST_CHECK_EQUAL(OneL.GetHex(), OneL.ToString());
165  BOOST_CHECK_EQUAL(MaxL.GetHex(), MaxL.ToString());
166  uint256 TmpL(R1L);
167  BOOST_CHECK_EQUAL(TmpL, R1L);
168  // Verify previous values don't persist when setting to truncated string.
169  TmpL.SetHexDeprecated("21");
170  BOOST_CHECK_EQUAL(TmpL.ToString(), "0000000000000000000000000000000000000000000000000000000000000021");
171  BOOST_CHECK_EQUAL(uint256::FromHex(R2L.ToString()).value(), R2L);
172  BOOST_CHECK_EQUAL(uint256::FromHex(ZeroL.ToString()).value(), uint256());
173 
174  TmpL = uint256::FromHex(R1L.ToString()).value();
175  BOOST_CHECK_EQUAL_COLLECTIONS(R1L.begin(), R1L.end(), R1Array, R1Array + R1L.size());
176  BOOST_CHECK_EQUAL_COLLECTIONS(TmpL.begin(), TmpL.end(), R1Array, R1Array + TmpL.size());
177  BOOST_CHECK_EQUAL_COLLECTIONS(R2L.begin(), R2L.end(), R2Array, R2Array + R2L.size());
178  BOOST_CHECK_EQUAL_COLLECTIONS(ZeroL.begin(), ZeroL.end(), ZeroArray, ZeroArray + ZeroL.size());
179  BOOST_CHECK_EQUAL_COLLECTIONS(OneL.begin(), OneL.end(), OneArray, OneArray + OneL.size());
180  BOOST_CHECK_EQUAL(R1L.size(), sizeof(R1L));
181  BOOST_CHECK_EQUAL(sizeof(R1L), 32);
182  BOOST_CHECK_EQUAL(R1L.size(), 32);
183  BOOST_CHECK_EQUAL(R2L.size(), 32);
184  BOOST_CHECK_EQUAL(ZeroL.size(), 32);
185  BOOST_CHECK_EQUAL(MaxL.size(), 32);
186  BOOST_CHECK_EQUAL(R1L.begin() + 32, R1L.end());
187  BOOST_CHECK_EQUAL(R2L.begin() + 32, R2L.end());
188  BOOST_CHECK_EQUAL(OneL.begin() + 32, OneL.end());
189  BOOST_CHECK_EQUAL(MaxL.begin() + 32, MaxL.end());
190  BOOST_CHECK_EQUAL(TmpL.begin() + 32, TmpL.end());
191  BOOST_CHECK_EQUAL(GetSerializeSize(R1L), 32);
192  BOOST_CHECK_EQUAL(GetSerializeSize(ZeroL), 32);
193 
194  DataStream ss{};
195  ss << R1L;
196  BOOST_CHECK_EQUAL(ss.str(), std::string(R1Array,R1Array+32));
197  ss >> TmpL;
198  BOOST_CHECK_EQUAL(R1L, TmpL);
199  ss.clear();
200  ss << ZeroL;
201  BOOST_CHECK_EQUAL(ss.str(), std::string(ZeroArray,ZeroArray+32));
202  ss >> TmpL;
203  BOOST_CHECK_EQUAL(ZeroL, TmpL);
204  ss.clear();
205  ss << MaxL;
206  BOOST_CHECK_EQUAL(ss.str(), std::string(MaxArray,MaxArray+32));
207  ss >> TmpL;
208  BOOST_CHECK_EQUAL(MaxL, TmpL);
209  ss.clear();
210 
211  BOOST_CHECK_EQUAL(R1S.GetHex(), R1S.ToString());
212  BOOST_CHECK_EQUAL(R2S.GetHex(), R2S.ToString());
213  BOOST_CHECK_EQUAL(OneS.GetHex(), OneS.ToString());
214  BOOST_CHECK_EQUAL(MaxS.GetHex(), MaxS.ToString());
215  uint160 TmpS(R1S);
216  BOOST_CHECK_EQUAL(TmpS, R1S);
217  BOOST_CHECK_EQUAL(uint160::FromHex(R2S.ToString()).value(), R2S);
218  BOOST_CHECK_EQUAL(uint160::FromHex(ZeroS.ToString()).value(), uint160());
219 
220  TmpS = uint160::FromHex(R1S.ToString()).value();
221  BOOST_CHECK_EQUAL_COLLECTIONS(R1S.begin(), R1S.end(), R1Array, R1Array + R1S.size());
222  BOOST_CHECK_EQUAL_COLLECTIONS(TmpS.begin(), TmpS.end(), R1Array, R1Array + TmpS.size());
223  BOOST_CHECK_EQUAL_COLLECTIONS(R2S.begin(), R2S.end(), R2Array, R2Array + R2S.size());
224  BOOST_CHECK_EQUAL_COLLECTIONS(ZeroS.begin(), ZeroS.end(), ZeroArray, ZeroArray + ZeroS.size());
225  BOOST_CHECK_EQUAL_COLLECTIONS(OneS.begin(), OneS.end(), OneArray, OneArray + OneS.size());
226  BOOST_CHECK_EQUAL(R1S.size(), sizeof(R1S));
227  BOOST_CHECK_EQUAL(sizeof(R1S), 20);
228  BOOST_CHECK_EQUAL(R1S.size(), 20);
229  BOOST_CHECK_EQUAL(R2S.size(), 20);
230  BOOST_CHECK_EQUAL(ZeroS.size(), 20);
231  BOOST_CHECK_EQUAL(MaxS.size(), 20);
232  BOOST_CHECK_EQUAL(R1S.begin() + 20, R1S.end());
233  BOOST_CHECK_EQUAL(R2S.begin() + 20, R2S.end());
234  BOOST_CHECK_EQUAL(OneS.begin() + 20, OneS.end());
235  BOOST_CHECK_EQUAL(MaxS.begin() + 20, MaxS.end());
236  BOOST_CHECK_EQUAL(TmpS.begin() + 20, TmpS.end());
237  BOOST_CHECK_EQUAL(GetSerializeSize(R1S), 20);
238  BOOST_CHECK_EQUAL(GetSerializeSize(ZeroS), 20);
239 
240  ss << R1S;
241  BOOST_CHECK_EQUAL(ss.str(), std::string(R1Array,R1Array+20));
242  ss >> TmpS;
243  BOOST_CHECK_EQUAL(R1S, TmpS);
244  ss.clear();
245  ss << ZeroS;
246  BOOST_CHECK_EQUAL(ss.str(), std::string(ZeroArray,ZeroArray+20));
247  ss >> TmpS;
248  BOOST_CHECK_EQUAL(ZeroS, TmpS);
249  ss.clear();
250  ss << MaxS;
251  BOOST_CHECK_EQUAL(ss.str(), std::string(MaxArray,MaxArray+20));
252  ss >> TmpS;
253  BOOST_CHECK_EQUAL(MaxS, TmpS);
254  ss.clear();
255 }
256 
257 BOOST_AUTO_TEST_CASE( conversion )
258 {
259  BOOST_CHECK_EQUAL(ArithToUint256(UintToArith256(ZeroL)), ZeroL);
260  BOOST_CHECK_EQUAL(ArithToUint256(UintToArith256(OneL)), OneL);
261  BOOST_CHECK_EQUAL(ArithToUint256(UintToArith256(R1L)), R1L);
262  BOOST_CHECK_EQUAL(ArithToUint256(UintToArith256(R2L)), R2L);
263  BOOST_CHECK_EQUAL(UintToArith256(ZeroL), 0);
264  BOOST_CHECK_EQUAL(UintToArith256(OneL), 1);
265  BOOST_CHECK_EQUAL(ArithToUint256(0), ZeroL);
266  BOOST_CHECK_EQUAL(ArithToUint256(1), OneL);
267  BOOST_CHECK_EQUAL(arith_uint256(UintToArith256(uint256S(R1L.GetHex()))), UintToArith256(R1L));
268  BOOST_CHECK_EQUAL(arith_uint256(UintToArith256(uint256S(R2L.GetHex()))), UintToArith256(R2L));
269  BOOST_CHECK_EQUAL(R1L.GetHex(), UintToArith256(R1L).GetHex());
270  BOOST_CHECK_EQUAL(R2L.GetHex(), UintToArith256(R2L).GetHex());
271 }
272 
273 BOOST_AUTO_TEST_CASE( operator_with_self )
274 {
275 
276 /* Clang 16 and earlier detects v -= v and v /= v as self-assignments
277  to 0 and 1 respectively.
278  See: https://github.com/llvm/llvm-project/issues/42469
279  and the fix in commit c5302325b2a62d77cf13dd16cd5c19141862fed0 .
280 
281  This makes some sense for arithmetic classes, but could be considered a bug
282  elsewhere. Disable the warning here so that the code can be tested, but the
283  warning should remain on as there will likely always be a better way to
284  express this.
285 */
286 
287 #if defined(__clang__)
288 # pragma clang diagnostic push
289 # pragma clang diagnostic ignored "-Wself-assign-overloaded"
290 #endif
291  arith_uint256 v = UintToArith256(uint256S("02"));
292  v *= v;
293  BOOST_CHECK_EQUAL(v, UintToArith256(uint256S("04")));
294  v /= v;
295  BOOST_CHECK_EQUAL(v, UintToArith256(uint256S("01")));
296  v += v;
297  BOOST_CHECK_EQUAL(v, UintToArith256(uint256S("02")));
298  v -= v;
299  BOOST_CHECK_EQUAL(v, UintToArith256(uint256S("0")));
300 #if defined(__clang__)
301 # pragma clang diagnostic pop
302 #endif
303 }
304 
305 BOOST_AUTO_TEST_CASE(parse)
306 {
307  {
308  std::string s_12{"0000000000000000000000000000000000000000000000000000000000000012"};
309  BOOST_CHECK_EQUAL(uint256S("12\0").GetHex(), s_12);
310  BOOST_CHECK_EQUAL(uint256S(std::string{"12\0", 3}).GetHex(), s_12);
311  BOOST_CHECK_EQUAL(uint256S("0x12").GetHex(), s_12);
312  BOOST_CHECK_EQUAL(uint256S(" 0x12").GetHex(), s_12);
313  BOOST_CHECK_EQUAL(uint256S(" 12").GetHex(), s_12);
314  }
315  {
316  std::string s_1{uint256::ONE.GetHex()};
317  BOOST_CHECK_EQUAL(uint256S("1\0").GetHex(), s_1);
318  BOOST_CHECK_EQUAL(uint256S(std::string{"1\0", 2}).GetHex(), s_1);
319  BOOST_CHECK_EQUAL(uint256S("0x1").GetHex(), s_1);
320  BOOST_CHECK_EQUAL(uint256S(" 0x1").GetHex(), s_1);
321  BOOST_CHECK_EQUAL(uint256S(" 1").GetHex(), s_1);
322  }
323  {
324  std::string s_0{uint256::ZERO.GetHex()};
325  BOOST_CHECK_EQUAL(uint256S("\0").GetHex(), s_0);
326  BOOST_CHECK_EQUAL(uint256S(std::string{"\0", 1}).GetHex(), s_0);
327  BOOST_CHECK_EQUAL(uint256S("0x").GetHex(), s_0);
328  BOOST_CHECK_EQUAL(uint256S(" 0x").GetHex(), s_0);
329  BOOST_CHECK_EQUAL(uint256S(" ").GetHex(), s_0);
330  }
331 }
332 
333 BOOST_AUTO_TEST_CASE( check_ONE )
334 {
335  uint256 one = uint256S("0000000000000000000000000000000000000000000000000000000000000001");
336  BOOST_CHECK_EQUAL(one, uint256::ONE);
337 }
338 
339 BOOST_AUTO_TEST_SUITE_END()
UintToArith256
arith_uint256 UintToArith256(const uint256 &a)
Definition: arith_uint256.cpp:225
ArithToUint256
uint256 ArithToUint256(const arith_uint256 &a)
Definition: arith_uint256.cpp:218
arith_uint256.h
DataStream
Double ended buffer combining vector and stream-like interfaces.
Definition: streams.h:147
arith_uint256
256-bit unsigned big integer.
Definition: arith_uint256.h:243
base_blob::end
constexpr unsigned char * end()
Definition: uint256.h:72
base_blob::size
static constexpr unsigned int size()
Definition: uint256.h:77
base_blob::ToString
std::string ToString() const
Definition: uint256.cpp:47
base_blob::SetHexDeprecated
void SetHexDeprecated(std::string_view str)
Unlike FromHex this accepts any invalid input, thus it is fragile and deprecated.
Definition: uint256.cpp:21
base_blob::begin
constexpr unsigned char * begin()
Definition: uint256.h:71
base_blob::GetHex
std::string GetHex() const
Definition: uint256.cpp:11
uint160
160-bit opaque blob.
Definition: uint256.h:115
uint160::FromHex
static std::optional< uint160 > FromHex(std::string_view str)
Definition: uint256.h:117
uint256
256-bit opaque blob.
Definition: uint256.h:127
uint256::ONE
static const uint256 ONE
Definition: uint256.h:134
uint256::ZERO
static const uint256 ZERO
Definition: uint256.h:133
uint256::FromHex
static std::optional< uint256 > FromHex(std::string_view str)
Definition: uint256.h:129
BOOST_AUTO_TEST_SUITE
BOOST_AUTO_TEST_SUITE(cuckoocache_tests)
Test Suite for CuckooCache.
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:18
GetSerializeSize
size_t GetSerializeSize(const T &t)
Definition: serialize.h:1101
setup_common.h
uint256S
uint256 uint256S(std::string_view str)
Definition: uint256.h:140
ZeroArray
const unsigned char ZeroArray[]
Definition: uint256_tests.cpp:32
R1Array
const unsigned char R1Array[]
Definition: uint256_tests.cpp:19
uint160S
uint160 uint160S(std::string_view str)
Definition: uint256_tests.cpp:62
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(basics)
Definition: uint256_tests.cpp:69
OneArray
const unsigned char OneArray[]
Definition: uint256_tests.cpp:38
OneS
const uint160 OneS
Definition: uint256_tests.cpp:42
MaxS
const uint160 MaxS
Definition: uint256_tests.cpp:48
R1ArrayHex
const char R1ArrayHex[]
Definition: uint256_tests.cpp:22
ZeroS
const uint160 ZeroS
Definition: uint256_tests.cpp:36
MaxL
const uint256 MaxL
Definition: uint256_tests.cpp:47
R1S
const uint160 R1S
Definition: uint256_tests.cpp:24
R2Array
const unsigned char R2Array[]
Definition: uint256_tests.cpp:26
R2L
const uint256 R2L
Definition: uint256_tests.cpp:29
R2S
const uint160 R2S
Definition: uint256_tests.cpp:30
R1L
const uint256 R1L
Definition: uint256_tests.cpp:23
ArrayToString
static std::string ArrayToString(const unsigned char A[], unsigned int width)
Definition: uint256_tests.cpp:50
MaxArray
const unsigned char MaxArray[]
Definition: uint256_tests.cpp:44
ZeroL
const uint256 ZeroL
Definition: uint256_tests.cpp:35
OneL
const uint256 OneL
Definition: uint256_tests.cpp:41
Generated on Sat Jul 27 2024 02:44:50 for Bitcoin Core by doxygen 1.9.1