Line data Source code
1 : // Copyright (c) 2011-2013 The Bitcoin Core developers
2 : // Copyright (c) 2019-2021 The PIVX Core developers
3 : // Distributed under the MIT/X11 software license, see the accompanying
4 : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 :
6 : #include <boost/test/unit_test.hpp>
7 : #include <stdint.h>
8 : #include <sstream>
9 : #include <iomanip>
10 : #include <limits>
11 : #include <cmath>
12 : #include "uint256.h"
13 : #include <string>
14 : #include "version.h"
15 : #include "test/test_pivx.h"
16 :
17 :
18 : BOOST_FIXTURE_TEST_SUITE(uint256_tests, BasicTestingSetup)
19 :
20 : const unsigned char R1Array[] =
21 : "\x9c\x52\x4a\xdb\xcf\x56\x11\x12\x2b\x29\x12\x5e\x5d\x35\xd2\xd2"
22 : "\x22\x81\xaa\xb5\x33\xf0\x08\x32\xd5\x56\xb1\xf9\xea\xe5\x1d\x7d";
23 : const char R1ArrayHex[] = "7D1DE5EAF9B156D53208F033B5AA8122D2d2355d5e12292b121156cfdb4a529c";
24 : const uint256 R1L = uint256(std::vector<unsigned char>(R1Array,R1Array+32));
25 : const uint160 R1S = uint160(std::vector<unsigned char>(R1Array,R1Array+20));
26 :
27 : const unsigned char R2Array[] =
28 : "\x70\x32\x1d\x7c\x47\xa5\x6b\x40\x26\x7e\x0a\xc3\xa6\x9c\xb6\xbf"
29 : "\x13\x30\x47\xa3\x19\x2d\xda\x71\x49\x13\x72\xf0\xb4\xca\x81\xd7";
30 : const uint256 R2L = uint256(std::vector<unsigned char>(R2Array,R2Array+32));
31 : const uint160 R2S = uint160(std::vector<unsigned char>(R2Array,R2Array+20));
32 :
33 : const unsigned char ZeroArray[] =
34 : "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
35 : "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
36 : const uint256 ZeroL = uint256(std::vector<unsigned char>(ZeroArray,ZeroArray+32));
37 : const uint160 ZeroS = uint160(std::vector<unsigned char>(ZeroArray,ZeroArray+20));
38 :
39 : const unsigned char OneArray[] =
40 : "\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
41 : "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
42 : const uint256 OneL = uint256(std::vector<unsigned char>(OneArray,OneArray+32));
43 : const uint160 OneS = uint160(std::vector<unsigned char>(OneArray,OneArray+20));
44 :
45 : const unsigned char MaxArray[] =
46 : "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
47 : "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff";
48 : const uint256 MaxL = uint256(std::vector<unsigned char>(MaxArray,MaxArray+32));
49 : const uint160 MaxS = uint160(std::vector<unsigned char>(MaxArray,MaxArray+20));
50 :
51 12 : std::string ArrayToString(const unsigned char A[], unsigned int width)
52 : {
53 12 : std::stringstream Stream;
54 12 : Stream << std::hex;
55 324 : for (unsigned int i = 0; i < width; ++i)
56 : {
57 312 : Stream<<std::setw(2)<<std::setfill('0')<<(unsigned int)A[width-i-1];
58 : }
59 12 : return Stream.str();
60 : }
61 :
62 2 : inline uint160 uint160S(const char *str)
63 : {
64 2 : uint160 rv;
65 2 : rv.SetHex(str);
66 2 : return rv;
67 : }
68 7 : inline uint160 uint160S(const std::string& str)
69 : {
70 7 : uint160 rv;
71 7 : rv.SetHex(str);
72 7 : return rv;
73 : }
74 :
75 2 : BOOST_AUTO_TEST_CASE( basics ) // constructors, equality, inequality
76 : {
77 2 : BOOST_CHECK(1 == 0+1);
78 : // constructor uint256(std::vector<char>):
79 4 : BOOST_CHECK(R1L.ToString() == ArrayToString(R1Array,32));
80 4 : BOOST_CHECK(R1S.ToString() == ArrayToString(R1Array,20));
81 4 : BOOST_CHECK(R2L.ToString() == ArrayToString(R2Array,32));
82 4 : BOOST_CHECK(R2S.ToString() == ArrayToString(R2Array,20));
83 4 : BOOST_CHECK(ZeroL.ToString() == ArrayToString(ZeroArray,32));
84 4 : BOOST_CHECK(ZeroS.ToString() == ArrayToString(ZeroArray,20));
85 4 : BOOST_CHECK(OneL.ToString() == ArrayToString(OneArray,32));
86 4 : BOOST_CHECK(OneS.ToString() == ArrayToString(OneArray,20));
87 4 : BOOST_CHECK(MaxL.ToString() == ArrayToString(MaxArray,32));
88 4 : BOOST_CHECK(MaxS.ToString() == ArrayToString(MaxArray,20));
89 2 : BOOST_CHECK(OneL.ToString() != ArrayToString(ZeroArray,32));
90 4 : BOOST_CHECK(OneS.ToString() != ArrayToString(ZeroArray,20));
91 :
92 : // == and !=
93 2 : BOOST_CHECK(R1L != R2L && R1S != R2S);
94 2 : BOOST_CHECK(ZeroL != OneL && ZeroS != OneS);
95 2 : BOOST_CHECK(OneL != ZeroL && OneS != ZeroS);
96 2 : BOOST_CHECK(MaxL != ZeroL && MaxS != ZeroS);
97 :
98 : // String Constructor and Copy Constructor
99 4 : BOOST_CHECK(uint256S("0x"+R1L.ToString()) == R1L);
100 4 : BOOST_CHECK(uint256S("0x"+R2L.ToString()) == R2L);
101 4 : BOOST_CHECK(uint256S("0x"+ZeroL.ToString()) == ZeroL);
102 4 : BOOST_CHECK(uint256S("0x"+OneL.ToString()) == OneL);
103 4 : BOOST_CHECK(uint256S("0x"+MaxL.ToString()) == MaxL);
104 4 : BOOST_CHECK(uint256S(R1L.ToString()) == R1L);
105 4 : BOOST_CHECK(uint256S(" 0x"+R1L.ToString()+" ") == R1L);
106 3 : BOOST_CHECK(uint256S("") == ZeroL);
107 3 : BOOST_CHECK(R1L == uint256S(R1ArrayHex));
108 2 : BOOST_CHECK(uint256(R1L) == R1L);
109 2 : BOOST_CHECK(uint256(ZeroL) == ZeroL);
110 2 : BOOST_CHECK(uint256(OneL) == OneL);
111 :
112 4 : BOOST_CHECK(uint160S("0x"+R1S.ToString()) == R1S);
113 4 : BOOST_CHECK(uint160S("0x"+R2S.ToString()) == R2S);
114 4 : BOOST_CHECK(uint160S("0x"+ZeroS.ToString()) == ZeroS);
115 4 : BOOST_CHECK(uint160S("0x"+OneS.ToString()) == OneS);
116 4 : BOOST_CHECK(uint160S("0x"+MaxS.ToString()) == MaxS);
117 4 : BOOST_CHECK(uint160S(R1S.ToString()) == R1S);
118 4 : BOOST_CHECK(uint160S(" 0x"+R1S.ToString()+" ") == R1S);
119 3 : BOOST_CHECK(uint160S("") == ZeroS);
120 3 : BOOST_CHECK(R1S == uint160S(R1ArrayHex));
121 :
122 2 : BOOST_CHECK(uint160(R1S) == R1S);
123 2 : BOOST_CHECK(uint160(ZeroS) == ZeroS);
124 2 : BOOST_CHECK(uint160(OneS) == OneS);
125 1 : }
126 :
127 2 : BOOST_AUTO_TEST_CASE( comparison ) // <
128 : {
129 1 : uint256 LastL;
130 257 : for (int i = 255; i >= 0; --i) {
131 256 : uint256 TmpL;
132 256 : *(TmpL.begin() + (i>>3)) |= 1<<(7-(i&7));
133 512 : BOOST_CHECK( LastL < TmpL );
134 256 : LastL = TmpL;
135 : }
136 :
137 2 : BOOST_CHECK( ZeroL < R1L );
138 2 : BOOST_CHECK( R2L < R1L );
139 2 : BOOST_CHECK( ZeroL < OneL );
140 2 : BOOST_CHECK( OneL < MaxL );
141 2 : BOOST_CHECK( R1L < MaxL );
142 2 : BOOST_CHECK( R2L < MaxL );
143 :
144 1 : uint160 LastS;
145 161 : for (int i = 159; i >= 0; --i) {
146 160 : uint160 TmpS;
147 160 : *(TmpS.begin() + (i>>3)) |= 1<<(7-(i&7));
148 320 : BOOST_CHECK( LastS < TmpS );
149 160 : LastS = TmpS;
150 : }
151 2 : BOOST_CHECK( ZeroS < R1S );
152 2 : BOOST_CHECK( R2S < R1S );
153 2 : BOOST_CHECK( ZeroS < OneS );
154 2 : BOOST_CHECK( OneS < MaxS );
155 2 : BOOST_CHECK( R1S < MaxS );
156 2 : BOOST_CHECK( R2S < MaxS );
157 1 : }
158 :
159 2 : BOOST_AUTO_TEST_CASE( methods ) // GetHex SetHex begin() end() size() GetLow64 GetSerializeSize, Serialize, Unserialize
160 : {
161 4 : BOOST_CHECK(R1L.GetHex() == R1L.ToString());
162 4 : BOOST_CHECK(R2L.GetHex() == R2L.ToString());
163 4 : BOOST_CHECK(OneL.GetHex() == OneL.ToString());
164 4 : BOOST_CHECK(MaxL.GetHex() == MaxL.ToString());
165 1 : uint256 TmpL(R1L);
166 2 : BOOST_CHECK(TmpL == R1L);
167 3 : TmpL.SetHex(R2L.ToString()); BOOST_CHECK(TmpL == R2L);
168 4 : TmpL.SetHex(ZeroL.ToString()); BOOST_CHECK(TmpL == uint256());
169 :
170 1 : TmpL.SetHex(R1L.ToString());
171 2 : BOOST_CHECK(memcmp(R1L.begin(), R1Array, 32)==0);
172 2 : BOOST_CHECK(memcmp(TmpL.begin(), R1Array, 32)==0);
173 2 : BOOST_CHECK(memcmp(R2L.begin(), R2Array, 32)==0);
174 2 : BOOST_CHECK(memcmp(ZeroL.begin(), ZeroArray, 32)==0);
175 2 : BOOST_CHECK(memcmp(OneL.begin(), OneArray, 32)==0);
176 2 : BOOST_CHECK(R1L.size() == sizeof(R1L));
177 2 : BOOST_CHECK(sizeof(R1L) == 32);
178 2 : BOOST_CHECK(R1L.size() == 32);
179 2 : BOOST_CHECK(R2L.size() == 32);
180 2 : BOOST_CHECK(ZeroL.size() == 32);
181 2 : BOOST_CHECK(MaxL.size() == 32);
182 2 : BOOST_CHECK(R1L.begin() + 32 == R1L.end());
183 2 : BOOST_CHECK(R2L.begin() + 32 == R2L.end());
184 2 : BOOST_CHECK(OneL.begin() + 32 == OneL.end());
185 2 : BOOST_CHECK(MaxL.begin() + 32 == MaxL.end());
186 2 : BOOST_CHECK(TmpL.begin() + 32 == TmpL.end());
187 2 : BOOST_CHECK(GetSerializeSize(R1L, PROTOCOL_VERSION) == 32);
188 2 : BOOST_CHECK(GetSerializeSize(ZeroL, PROTOCOL_VERSION) == 32);
189 :
190 1 : CDataStream ss(0, PROTOCOL_VERSION);
191 1 : ss << R1L;
192 5 : BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+32));
193 1 : ss >> TmpL;
194 2 : BOOST_CHECK(R1L == TmpL);
195 1 : ss.clear();
196 1 : ss << ZeroL;
197 5 : BOOST_CHECK(ss.str() == std::string(ZeroArray,ZeroArray+32));
198 1 : ss >> TmpL;
199 2 : BOOST_CHECK(ZeroL == TmpL);
200 1 : ss.clear();
201 1 : ss << MaxL;
202 5 : BOOST_CHECK(ss.str() == std::string(MaxArray,MaxArray+32));
203 1 : ss >> TmpL;
204 2 : BOOST_CHECK(MaxL == TmpL);
205 1 : ss.clear();
206 :
207 4 : BOOST_CHECK(R1S.GetHex() == R1S.ToString());
208 4 : BOOST_CHECK(R2S.GetHex() == R2S.ToString());
209 4 : BOOST_CHECK(OneS.GetHex() == OneS.ToString());
210 4 : BOOST_CHECK(MaxS.GetHex() == MaxS.ToString());
211 1 : uint160 TmpS(R1S);
212 2 : BOOST_CHECK(TmpS == R1S);
213 3 : TmpS.SetHex(R2S.ToString()); BOOST_CHECK(TmpS == R2S);
214 4 : TmpS.SetHex(ZeroS.ToString()); BOOST_CHECK(TmpS == uint160());
215 :
216 1 : TmpS.SetHex(R1S.ToString());
217 2 : BOOST_CHECK(memcmp(R1S.begin(), R1Array, 20)==0);
218 2 : BOOST_CHECK(memcmp(TmpS.begin(), R1Array, 20)==0);
219 2 : BOOST_CHECK(memcmp(R2S.begin(), R2Array, 20)==0);
220 2 : BOOST_CHECK(memcmp(ZeroS.begin(), ZeroArray, 20)==0);
221 2 : BOOST_CHECK(memcmp(OneS.begin(), OneArray, 20)==0);
222 2 : BOOST_CHECK(R1S.size() == sizeof(R1S));
223 2 : BOOST_CHECK(sizeof(R1S) == 20);
224 2 : BOOST_CHECK(R1S.size() == 20);
225 2 : BOOST_CHECK(R2S.size() == 20);
226 2 : BOOST_CHECK(ZeroS.size() == 20);
227 2 : BOOST_CHECK(MaxS.size() == 20);
228 2 : BOOST_CHECK(R1S.begin() + 20 == R1S.end());
229 2 : BOOST_CHECK(R2S.begin() + 20 == R2S.end());
230 2 : BOOST_CHECK(OneS.begin() + 20 == OneS.end());
231 2 : BOOST_CHECK(MaxS.begin() + 20 == MaxS.end());
232 2 : BOOST_CHECK(TmpS.begin() + 20 == TmpS.end());
233 2 : BOOST_CHECK(GetSerializeSize(R1S, PROTOCOL_VERSION) == 20);
234 2 : BOOST_CHECK(GetSerializeSize(ZeroS, PROTOCOL_VERSION) == 20);
235 :
236 1 : ss << R1S;
237 5 : BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+20));
238 1 : ss >> TmpS;
239 2 : BOOST_CHECK(R1S == TmpS);
240 1 : ss.clear();
241 1 : ss << ZeroS;
242 5 : BOOST_CHECK(ss.str() == std::string(ZeroArray,ZeroArray+20));
243 1 : ss >> TmpS;
244 2 : BOOST_CHECK(ZeroS == TmpS);
245 1 : ss.clear();
246 1 : ss << MaxS;
247 5 : BOOST_CHECK(ss.str() == std::string(MaxArray,MaxArray+20));
248 1 : ss >> TmpS;
249 2 : BOOST_CHECK(MaxS == TmpS);
250 1 : ss.clear();
251 1 : }
252 :
253 2 : BOOST_AUTO_TEST_CASE( conversion )
254 : {
255 2 : BOOST_CHECK(ArithToUint256(UintToArith256(ZeroL)) == ZeroL);
256 2 : BOOST_CHECK(ArithToUint256(UintToArith256(OneL)) == OneL);
257 2 : BOOST_CHECK(ArithToUint256(UintToArith256(R1L)) == R1L);
258 2 : BOOST_CHECK(ArithToUint256(UintToArith256(R2L)) == R2L);
259 3 : BOOST_CHECK(UintToArith256(ZeroL) == 0);
260 3 : BOOST_CHECK(UintToArith256(OneL) == 1);
261 3 : BOOST_CHECK(ArithToUint256(0) == ZeroL);
262 3 : BOOST_CHECK(ArithToUint256(1) == OneL);
263 4 : BOOST_CHECK(arith_uint256(R1L.GetHex()) == UintToArith256(R1L));
264 4 : BOOST_CHECK(arith_uint256(R2L.GetHex()) == UintToArith256(R2L));
265 4 : BOOST_CHECK(R1L.GetHex() == UintToArith256(R1L).GetHex());
266 4 : BOOST_CHECK(R2L.GetHex() == UintToArith256(R2L).GetHex());
267 1 : }
268 :
269 2 : BOOST_AUTO_TEST_CASE( operator_with_self )
270 : {
271 2 : arith_uint256 v = UintToArith256(uint256S("02"));
272 1 : v *= v;
273 3 : BOOST_CHECK(v == UintToArith256(uint256S("04")));
274 1 : v /= v;
275 3 : BOOST_CHECK(v == UintToArith256(uint256S("01")));
276 9 : v += v;
277 3 : BOOST_CHECK(v == UintToArith256(uint256S("02")));
278 1 : v -= v;
279 3 : BOOST_CHECK(v == UintToArith256(uint256S("0")));
280 1 : }
281 :
282 2 : BOOST_AUTO_TEST_CASE( check_ONE )
283 : {
284 1 : uint256 one = uint256S("0000000000000000000000000000000000000000000000000000000000000001");
285 1 : BOOST_CHECK_EQUAL(one, UINT256_ONE);
286 1 : }
287 :
288 : BOOST_AUTO_TEST_SUITE_END()
289 :
|
