uint256_tests.cpp
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 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>): 78 BOOST_CHECK(R1L.ToString() == ArrayToString(R1Array,32)); 79 BOOST_CHECK(R1S.ToString() == ArrayToString(R1Array,20)); 80 BOOST_CHECK(R2L.ToString() == ArrayToString(R2Array,32)); 81 BOOST_CHECK(R2S.ToString() == ArrayToString(R2Array,20)); 82 BOOST_CHECK(ZeroL.ToString() == ArrayToString(ZeroArray,32)); 83 BOOST_CHECK(ZeroS.ToString() == ArrayToString(ZeroArray,20)); 84 BOOST_CHECK(OneL.ToString() == ArrayToString(OneArray,32)); 85 BOOST_CHECK(OneS.ToString() == ArrayToString(OneArray,20)); 86 BOOST_CHECK(MaxL.ToString() == ArrayToString(MaxArray,32)); 87 BOOST_CHECK(MaxS.ToString() == ArrayToString(MaxArray,20)); 88 BOOST_CHECK(OneL.ToString() != ArrayToString(ZeroArray,32)); 89 BOOST_CHECK(OneS.ToString() != ArrayToString(ZeroArray,20)); 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); 100 BOOST_CHECK(uint256S("0x"+ZeroL.ToString()) == ZeroL); 101 BOOST_CHECK(uint256S("0x"+OneL.ToString()) == OneL); 102 BOOST_CHECK(uint256S("0x"+MaxL.ToString()) == MaxL); 103 BOOST_CHECK(uint256S(R1L.ToString()) == R1L); 104 BOOST_CHECK(uint256S(" 0x"+R1L.ToString()+" ") == R1L); 105 BOOST_CHECK(uint256S("") == ZeroL); 106 BOOST_CHECK(R1L == uint256S(R1ArrayHex)); 107 BOOST_CHECK(uint256(R1L) == R1L); 108 BOOST_CHECK(uint256(ZeroL) == ZeroL); 109 BOOST_CHECK(uint256(OneL) == OneL); 110 111 BOOST_CHECK(uint160S("0x"+R1S.ToString()) == R1S); 112 BOOST_CHECK(uint160S("0x"+R2S.ToString()) == R2S); 113 BOOST_CHECK(uint160S("0x"+ZeroS.ToString()) == ZeroS); 114 BOOST_CHECK(uint160S("0x"+OneS.ToString()) == OneS); 115 BOOST_CHECK(uint160S("0x"+MaxS.ToString()) == MaxS); 116 BOOST_CHECK(uint160S(R1S.ToString()) == R1S); 117 BOOST_CHECK(uint160S(" 0x"+R1S.ToString()+" ") == R1S); 118 BOOST_CHECK(uint160S("") == ZeroS); 119 BOOST_CHECK(R1S == uint160S(R1ArrayHex)); 120 121 BOOST_CHECK(uint160(R1S) == R1S); 122 BOOST_CHECK(uint160(ZeroS) == ZeroS); 123 BOOST_CHECK(uint160(OneS) == OneS); 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 { 160 BOOST_CHECK(R1L.GetHex() == R1L.ToString()); 161 BOOST_CHECK(R2L.GetHex() == R2L.ToString()); 162 BOOST_CHECK(OneL.GetHex() == OneL.ToString()); 163 BOOST_CHECK(MaxL.GetHex() == MaxL.ToString()); 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()); 186 BOOST_CHECK(GetSerializeSize(R1L) == 32); 187 BOOST_CHECK(GetSerializeSize(ZeroL) == 32); 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 206 BOOST_CHECK(R1S.GetHex() == R1S.ToString()); 207 BOOST_CHECK(R2S.GetHex() == R2S.ToString()); 208 BOOST_CHECK(OneS.GetHex() == OneS.ToString()); 209 BOOST_CHECK(MaxS.GetHex() == MaxS.ToString()); 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()); 232 BOOST_CHECK(GetSerializeSize(R1S) == 20); 233 BOOST_CHECK(GetSerializeSize(ZeroS) == 20); 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 { 254 BOOST_CHECK(ArithToUint256(UintToArith256(ZeroL)) == ZeroL); 255 BOOST_CHECK(ArithToUint256(UintToArith256(OneL)) == OneL); 256 BOOST_CHECK(ArithToUint256(UintToArith256(R1L)) == R1L); 257 BOOST_CHECK(ArithToUint256(UintToArith256(R2L)) == R2L); 258 BOOST_CHECK(UintToArith256(ZeroL) == 0); 259 BOOST_CHECK(UintToArith256(OneL) == 1); 260 BOOST_CHECK(ArithToUint256(0) == ZeroL); 261 BOOST_CHECK(ArithToUint256(1) == OneL); 262 BOOST_CHECK(arith_uint256(UintToArith256(uint256S(R1L.GetHex()))) == UintToArith256(R1L)); 263 BOOST_CHECK(arith_uint256(UintToArith256(uint256S(R2L.GetHex()))) == UintToArith256(R2L)); 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 { 270 arith_uint256 v = UintToArith256(uint256S("02")); 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 281 BOOST_AUTO_TEST_CASE(parse) 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 309 BOOST_AUTO_TEST_CASE( check_ONE ) 310 { 311 uint256 one = uint256S("0000000000000000000000000000000000000000000000000000000000000001"); 312 BOOST_CHECK_EQUAL(one, uint256::ONE); 313 } 314 315 BOOST_AUTO_TEST_SUITE_END()