Branch data Line data Source code
# 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 : : #include <version.h>
# 10 : :
# 11 : : #include <boost/test/unit_test.hpp>
# 12 : :
# 13 : : #include <iomanip>
# 14 : : #include <sstream>
# 15 : : #include <string>
# 16 : : #include <vector>
# 17 : :
# 18 : : BOOST_AUTO_TEST_SUITE(uint256_tests)
# 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 : : static std::string ArrayToString(const unsigned char A[], unsigned int width)
# 52 : 24 : {
# 53 : 24 : std::stringstream Stream;
# 54 : 24 : Stream << std::hex;
# 55 [ + + ]: 648 : for (unsigned int i = 0; i < width; ++i)
# 56 : 624 : {
# 57 : 624 : Stream<<std::setw(2)<<std::setfill('0')<<(unsigned int)A[width-i-1];
# 58 : 624 : }
# 59 : 24 : return Stream.str();
# 60 : 24 : }
# 61 : :
# 62 : : inline uint160 uint160S(const char *str)
# 63 : 4 : {
# 64 : 4 : uint160 rv;
# 65 : 4 : rv.SetHex(str);
# 66 : 4 : return rv;
# 67 : 4 : }
# 68 : : inline uint160 uint160S(const std::string& str)
# 69 : 14 : {
# 70 : 14 : uint160 rv;
# 71 : 14 : rv.SetHex(str);
# 72 : 14 : return rv;
# 73 : 14 : }
# 74 : :
# 75 : : BOOST_AUTO_TEST_CASE( basics ) // constructors, equality, inequality
# 76 : 2 : {
# 77 : 2 : BOOST_CHECK(1 == 0+1);
# 78 : : // constructor uint256(vector<char>):
# 79 : 2 : BOOST_CHECK(R1L.ToString() == ArrayToString(R1Array,32));
# 80 : 2 : BOOST_CHECK(R1S.ToString() == ArrayToString(R1Array,20));
# 81 : 2 : BOOST_CHECK(R2L.ToString() == ArrayToString(R2Array,32));
# 82 : 2 : BOOST_CHECK(R2S.ToString() == ArrayToString(R2Array,20));
# 83 : 2 : BOOST_CHECK(ZeroL.ToString() == ArrayToString(ZeroArray,32));
# 84 : 2 : BOOST_CHECK(ZeroS.ToString() == ArrayToString(ZeroArray,20));
# 85 : 2 : BOOST_CHECK(OneL.ToString() == ArrayToString(OneArray,32));
# 86 : 2 : BOOST_CHECK(OneS.ToString() == ArrayToString(OneArray,20));
# 87 : 2 : BOOST_CHECK(MaxL.ToString() == ArrayToString(MaxArray,32));
# 88 : 2 : BOOST_CHECK(MaxS.ToString() == ArrayToString(MaxArray,20));
# 89 : 2 : BOOST_CHECK(OneL.ToString() != ArrayToString(ZeroArray,32));
# 90 : 2 : 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 : 2 : BOOST_CHECK(uint256S("0x"+R1L.ToString()) == R1L);
# 100 : 2 : BOOST_CHECK(uint256S("0x"+R2L.ToString()) == R2L);
# 101 : 2 : BOOST_CHECK(uint256S("0x"+ZeroL.ToString()) == ZeroL);
# 102 : 2 : BOOST_CHECK(uint256S("0x"+OneL.ToString()) == OneL);
# 103 : 2 : BOOST_CHECK(uint256S("0x"+MaxL.ToString()) == MaxL);
# 104 : 2 : BOOST_CHECK(uint256S(R1L.ToString()) == R1L);
# 105 : 2 : BOOST_CHECK(uint256S(" 0x"+R1L.ToString()+" ") == R1L);
# 106 : 2 : BOOST_CHECK(uint256S("") == ZeroL);
# 107 : 2 : 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 : 2 : BOOST_CHECK(uint160S("0x"+R1S.ToString()) == R1S);
# 113 : 2 : BOOST_CHECK(uint160S("0x"+R2S.ToString()) == R2S);
# 114 : 2 : BOOST_CHECK(uint160S("0x"+ZeroS.ToString()) == ZeroS);
# 115 : 2 : BOOST_CHECK(uint160S("0x"+OneS.ToString()) == OneS);
# 116 : 2 : BOOST_CHECK(uint160S("0x"+MaxS.ToString()) == MaxS);
# 117 : 2 : BOOST_CHECK(uint160S(R1S.ToString()) == R1S);
# 118 : 2 : BOOST_CHECK(uint160S(" 0x"+R1S.ToString()+" ") == R1S);
# 119 : 2 : BOOST_CHECK(uint160S("") == ZeroS);
# 120 : 2 : 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 : 2 : }
# 126 : :
# 127 : : BOOST_AUTO_TEST_CASE( comparison ) // <= >= < >
# 128 : 2 : {
# 129 : 2 : uint256 LastL;
# 130 [ + + ]: 514 : for (int i = 255; i >= 0; --i) {
# 131 : 512 : uint256 TmpL;
# 132 : 512 : *(TmpL.begin() + (i>>3)) |= 1<<(7-(i&7));
# 133 : 512 : BOOST_CHECK( LastL < TmpL );
# 134 : 512 : LastL = TmpL;
# 135 : 512 : }
# 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 : 2 : uint160 LastS;
# 145 [ + + ]: 322 : for (int i = 159; i >= 0; --i) {
# 146 : 320 : uint160 TmpS;
# 147 : 320 : *(TmpS.begin() + (i>>3)) |= 1<<(7-(i&7));
# 148 : 320 : BOOST_CHECK( LastS < TmpS );
# 149 : 320 : LastS = TmpS;
# 150 : 320 : }
# 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 : 2 : }
# 158 : :
# 159 : : BOOST_AUTO_TEST_CASE( methods ) // GetHex SetHex begin() end() size() GetLow64 GetSerializeSize, Serialize, Unserialize
# 160 : 2 : {
# 161 : 2 : BOOST_CHECK(R1L.GetHex() == R1L.ToString());
# 162 : 2 : BOOST_CHECK(R2L.GetHex() == R2L.ToString());
# 163 : 2 : BOOST_CHECK(OneL.GetHex() == OneL.ToString());
# 164 : 2 : BOOST_CHECK(MaxL.GetHex() == MaxL.ToString());
# 165 : 2 : uint256 TmpL(R1L);
# 166 : 2 : BOOST_CHECK(TmpL == R1L);
# 167 : 2 : TmpL.SetHex(R2L.ToString()); BOOST_CHECK(TmpL == R2L);
# 168 : 2 : TmpL.SetHex(ZeroL.ToString()); BOOST_CHECK(TmpL == uint256());
# 169 : :
# 170 : 2 : 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 : 2 : CDataStream ss(0, PROTOCOL_VERSION);
# 191 : 2 : ss << R1L;
# 192 : 2 : BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+32));
# 193 : 2 : ss >> TmpL;
# 194 : 2 : BOOST_CHECK(R1L == TmpL);
# 195 : 2 : ss.clear();
# 196 : 2 : ss << ZeroL;
# 197 : 2 : BOOST_CHECK(ss.str() == std::string(ZeroArray,ZeroArray+32));
# 198 : 2 : ss >> TmpL;
# 199 : 2 : BOOST_CHECK(ZeroL == TmpL);
# 200 : 2 : ss.clear();
# 201 : 2 : ss << MaxL;
# 202 : 2 : BOOST_CHECK(ss.str() == std::string(MaxArray,MaxArray+32));
# 203 : 2 : ss >> TmpL;
# 204 : 2 : BOOST_CHECK(MaxL == TmpL);
# 205 : 2 : ss.clear();
# 206 : :
# 207 : 2 : BOOST_CHECK(R1S.GetHex() == R1S.ToString());
# 208 : 2 : BOOST_CHECK(R2S.GetHex() == R2S.ToString());
# 209 : 2 : BOOST_CHECK(OneS.GetHex() == OneS.ToString());
# 210 : 2 : BOOST_CHECK(MaxS.GetHex() == MaxS.ToString());
# 211 : 2 : uint160 TmpS(R1S);
# 212 : 2 : BOOST_CHECK(TmpS == R1S);
# 213 : 2 : TmpS.SetHex(R2S.ToString()); BOOST_CHECK(TmpS == R2S);
# 214 : 2 : TmpS.SetHex(ZeroS.ToString()); BOOST_CHECK(TmpS == uint160());
# 215 : :
# 216 : 2 : 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 : 2 : ss << R1S;
# 237 : 2 : BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+20));
# 238 : 2 : ss >> TmpS;
# 239 : 2 : BOOST_CHECK(R1S == TmpS);
# 240 : 2 : ss.clear();
# 241 : 2 : ss << ZeroS;
# 242 : 2 : BOOST_CHECK(ss.str() == std::string(ZeroArray,ZeroArray+20));
# 243 : 2 : ss >> TmpS;
# 244 : 2 : BOOST_CHECK(ZeroS == TmpS);
# 245 : 2 : ss.clear();
# 246 : 2 : ss << MaxS;
# 247 : 2 : BOOST_CHECK(ss.str() == std::string(MaxArray,MaxArray+20));
# 248 : 2 : ss >> TmpS;
# 249 : 2 : BOOST_CHECK(MaxS == TmpS);
# 250 : 2 : ss.clear();
# 251 : 2 : }
# 252 : :
# 253 : : BOOST_AUTO_TEST_CASE( conversion )
# 254 : 2 : {
# 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 : 2 : BOOST_CHECK(UintToArith256(ZeroL) == 0);
# 260 : 2 : BOOST_CHECK(UintToArith256(OneL) == 1);
# 261 : 2 : BOOST_CHECK(ArithToUint256(0) == ZeroL);
# 262 : 2 : BOOST_CHECK(ArithToUint256(1) == OneL);
# 263 : 2 : BOOST_CHECK(arith_uint256(R1L.GetHex()) == UintToArith256(R1L));
# 264 : 2 : BOOST_CHECK(arith_uint256(R2L.GetHex()) == UintToArith256(R2L));
# 265 : 2 : BOOST_CHECK(R1L.GetHex() == UintToArith256(R1L).GetHex());
# 266 : 2 : BOOST_CHECK(R2L.GetHex() == UintToArith256(R2L).GetHex());
# 267 : 2 : }
# 268 : :
# 269 : : BOOST_AUTO_TEST_CASE( operator_with_self )
# 270 : 2 : {
# 271 : 2 : arith_uint256 v = UintToArith256(uint256S("02"));
# 272 : 2 : v *= v;
# 273 : 2 : BOOST_CHECK(v == UintToArith256(uint256S("04")));
# 274 : 2 : v /= v;
# 275 : 2 : BOOST_CHECK(v == UintToArith256(uint256S("01")));
# 276 : 2 : v += v;
# 277 : 2 : BOOST_CHECK(v == UintToArith256(uint256S("02")));
# 278 : 2 : v -= v;
# 279 : 2 : BOOST_CHECK(v == UintToArith256(uint256S("0")));
# 280 : 2 : }
# 281 : :
# 282 : : BOOST_AUTO_TEST_CASE( check_ONE )
# 283 : 2 : {
# 284 : 2 : uint256 one = uint256S("0000000000000000000000000000000000000000000000000000000000000001");
# 285 : 2 : BOOST_CHECK_EQUAL(one, uint256::ONE);
# 286 : 2 : }
# 287 : :
# 288 : : BOOST_AUTO_TEST_SUITE_END()
|
