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         146 : 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         146 : const uint256 R1L = uint256(std::vector<unsigned char>(R1Array,R1Array+32));
      25         146 : 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         146 : const uint256 R2L = uint256(std::vector<unsigned char>(R2Array,R2Array+32));
      31         146 : 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         146 : const uint256 ZeroL = uint256(std::vector<unsigned char>(ZeroArray,ZeroArray+32));
      37         146 : 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         146 : const uint256 OneL = uint256(std::vector<unsigned char>(OneArray,OneArray+32));
      43         146 : 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         146 : const uint256 MaxL = uint256(std::vector<unsigned char>(MaxArray,MaxArray+32));
      49         146 : const uint160 MaxS = uint160(std::vector<unsigned char>(MaxArray,MaxArray+20));
      50             : 
      51          12 : static 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         312 :     }
      59          12 :     return Stream.str();
      60          12 : }
      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         148 : BOOST_AUTO_TEST_CASE( basics ) // constructors, equality, inequality
      76             : {
      77           1 :     BOOST_CHECK(1 == 0+1);
      78             :     // constructor uint256(vector<char>):
      79           1 :     BOOST_CHECK(R1L.ToString() == ArrayToString(R1Array,32));
      80           1 :     BOOST_CHECK(R1S.ToString() == ArrayToString(R1Array,20));
      81           1 :     BOOST_CHECK(R2L.ToString() == ArrayToString(R2Array,32));
      82           1 :     BOOST_CHECK(R2S.ToString() == ArrayToString(R2Array,20));
      83           1 :     BOOST_CHECK(ZeroL.ToString() == ArrayToString(ZeroArray,32));
      84           1 :     BOOST_CHECK(ZeroS.ToString() == ArrayToString(ZeroArray,20));
      85           1 :     BOOST_CHECK(OneL.ToString() == ArrayToString(OneArray,32));
      86           1 :     BOOST_CHECK(OneS.ToString() == ArrayToString(OneArray,20));
      87           1 :     BOOST_CHECK(MaxL.ToString() == ArrayToString(MaxArray,32));
      88           1 :     BOOST_CHECK(MaxS.ToString() == ArrayToString(MaxArray,20));
      89           1 :     BOOST_CHECK(OneL.ToString() != ArrayToString(ZeroArray,32));
      90           1 :     BOOST_CHECK(OneS.ToString() != ArrayToString(ZeroArray,20));
      91             : 
      92             :     // == and !=
      93           1 :     BOOST_CHECK(R1L != R2L && R1S != R2S);
      94           1 :     BOOST_CHECK(ZeroL != OneL && ZeroS != OneS);
      95           1 :     BOOST_CHECK(OneL != ZeroL && OneS != ZeroS);
      96           1 :     BOOST_CHECK(MaxL != ZeroL && MaxS != ZeroS);
      97             : 
      98             :     // String Constructor and Copy Constructor
      99           1 :     BOOST_CHECK(uint256S("0x"+R1L.ToString()) == R1L);
     100           1 :     BOOST_CHECK(uint256S("0x"+R2L.ToString()) == R2L);
     101           1 :     BOOST_CHECK(uint256S("0x"+ZeroL.ToString()) == ZeroL);
     102           1 :     BOOST_CHECK(uint256S("0x"+OneL.ToString()) == OneL);
     103           1 :     BOOST_CHECK(uint256S("0x"+MaxL.ToString()) == MaxL);
     104           1 :     BOOST_CHECK(uint256S(R1L.ToString()) == R1L);
     105           1 :     BOOST_CHECK(uint256S("   0x"+R1L.ToString()+"   ") == R1L);
     106           1 :     BOOST_CHECK(uint256S("") == ZeroL);
     107           1 :     BOOST_CHECK(R1L == uint256S(R1ArrayHex));
     108           1 :     BOOST_CHECK(uint256(R1L) == R1L);
     109           1 :     BOOST_CHECK(uint256(ZeroL) == ZeroL);
     110           1 :     BOOST_CHECK(uint256(OneL) == OneL);
     111             : 
     112           1 :     BOOST_CHECK(uint160S("0x"+R1S.ToString()) == R1S);
     113           1 :     BOOST_CHECK(uint160S("0x"+R2S.ToString()) == R2S);
     114           1 :     BOOST_CHECK(uint160S("0x"+ZeroS.ToString()) == ZeroS);
     115           1 :     BOOST_CHECK(uint160S("0x"+OneS.ToString()) == OneS);
     116           1 :     BOOST_CHECK(uint160S("0x"+MaxS.ToString()) == MaxS);
     117           1 :     BOOST_CHECK(uint160S(R1S.ToString()) == R1S);
     118           1 :     BOOST_CHECK(uint160S("   0x"+R1S.ToString()+"   ") == R1S);
     119           1 :     BOOST_CHECK(uint160S("") == ZeroS);
     120           1 :     BOOST_CHECK(R1S == uint160S(R1ArrayHex));
     121             : 
     122           1 :     BOOST_CHECK(uint160(R1S) == R1S);
     123           1 :     BOOST_CHECK(uint160(ZeroS) == ZeroS);
     124           1 :     BOOST_CHECK(uint160(OneS) == OneS);
     125           1 : }
     126             : 
     127         148 : 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         256 :         BOOST_CHECK( LastL < TmpL );
     134         256 :         LastL = TmpL;
     135         256 :     }
     136             : 
     137           1 :     BOOST_CHECK( ZeroL < R1L );
     138           1 :     BOOST_CHECK( R2L < R1L );
     139           1 :     BOOST_CHECK( ZeroL < OneL );
     140           1 :     BOOST_CHECK( OneL < MaxL );
     141           1 :     BOOST_CHECK( R1L < MaxL );
     142           1 :     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         160 :         BOOST_CHECK( LastS < TmpS );
     149         160 :         LastS = TmpS;
     150         160 :     }
     151           1 :     BOOST_CHECK( ZeroS < R1S );
     152           1 :     BOOST_CHECK( R2S < R1S );
     153           1 :     BOOST_CHECK( ZeroS < OneS );
     154           1 :     BOOST_CHECK( OneS < MaxS );
     155           1 :     BOOST_CHECK( R1S < MaxS );
     156           1 :     BOOST_CHECK( R2S < MaxS );
     157           1 : }
     158             : 
     159         148 : BOOST_AUTO_TEST_CASE( methods ) // GetHex SetHex begin() end() size() GetLow64 GetSerializeSize, Serialize, Unserialize
     160             : {
     161           1 :     BOOST_CHECK(R1L.GetHex() == R1L.ToString());
     162           1 :     BOOST_CHECK(R2L.GetHex() == R2L.ToString());
     163           1 :     BOOST_CHECK(OneL.GetHex() == OneL.ToString());
     164           1 :     BOOST_CHECK(MaxL.GetHex() == MaxL.ToString());
     165           1 :     uint256 TmpL(R1L);
     166           1 :     BOOST_CHECK(TmpL == R1L);
     167           1 :     TmpL.SetHex(R2L.ToString());   BOOST_CHECK(TmpL == R2L);
     168           1 :     TmpL.SetHex(ZeroL.ToString()); BOOST_CHECK(TmpL == uint256());
     169             : 
     170           1 :     TmpL.SetHex(R1L.ToString());
     171           1 :     BOOST_CHECK(memcmp(R1L.begin(), R1Array, 32)==0);
     172           1 :     BOOST_CHECK(memcmp(TmpL.begin(), R1Array, 32)==0);
     173           1 :     BOOST_CHECK(memcmp(R2L.begin(), R2Array, 32)==0);
     174           1 :     BOOST_CHECK(memcmp(ZeroL.begin(), ZeroArray, 32)==0);
     175           1 :     BOOST_CHECK(memcmp(OneL.begin(), OneArray, 32)==0);
     176           1 :     BOOST_CHECK(R1L.size() == sizeof(R1L));
     177           1 :     BOOST_CHECK(sizeof(R1L) == 32);
     178           1 :     BOOST_CHECK(R1L.size() == 32);
     179           1 :     BOOST_CHECK(R2L.size() == 32);
     180           1 :     BOOST_CHECK(ZeroL.size() == 32);
     181           1 :     BOOST_CHECK(MaxL.size() == 32);
     182           1 :     BOOST_CHECK(R1L.begin() + 32 == R1L.end());
     183           1 :     BOOST_CHECK(R2L.begin() + 32 == R2L.end());
     184           1 :     BOOST_CHECK(OneL.begin() + 32 == OneL.end());
     185           1 :     BOOST_CHECK(MaxL.begin() + 32 == MaxL.end());
     186           1 :     BOOST_CHECK(TmpL.begin() + 32 == TmpL.end());
     187           1 :     BOOST_CHECK(GetSerializeSize(R1L, PROTOCOL_VERSION) == 32);
     188           1 :     BOOST_CHECK(GetSerializeSize(ZeroL, PROTOCOL_VERSION) == 32);
     189             : 
     190           1 :     CDataStream ss(0, PROTOCOL_VERSION);
     191           1 :     ss << R1L;
     192           1 :     BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+32));
     193           1 :     ss >> TmpL;
     194           1 :     BOOST_CHECK(R1L == TmpL);
     195           1 :     ss.clear();
     196           1 :     ss << ZeroL;
     197           1 :     BOOST_CHECK(ss.str() == std::string(ZeroArray,ZeroArray+32));
     198           1 :     ss >> TmpL;
     199           1 :     BOOST_CHECK(ZeroL == TmpL);
     200           1 :     ss.clear();
     201           1 :     ss << MaxL;
     202           1 :     BOOST_CHECK(ss.str() == std::string(MaxArray,MaxArray+32));
     203           1 :     ss >> TmpL;
     204           1 :     BOOST_CHECK(MaxL == TmpL);
     205           1 :     ss.clear();
     206             : 
     207           1 :     BOOST_CHECK(R1S.GetHex() == R1S.ToString());
     208           1 :     BOOST_CHECK(R2S.GetHex() == R2S.ToString());
     209           1 :     BOOST_CHECK(OneS.GetHex() == OneS.ToString());
     210           1 :     BOOST_CHECK(MaxS.GetHex() == MaxS.ToString());
     211           1 :     uint160 TmpS(R1S);
     212           1 :     BOOST_CHECK(TmpS == R1S);
     213           1 :     TmpS.SetHex(R2S.ToString());   BOOST_CHECK(TmpS == R2S);
     214           1 :     TmpS.SetHex(ZeroS.ToString()); BOOST_CHECK(TmpS == uint160());
     215             : 
     216           1 :     TmpS.SetHex(R1S.ToString());
     217           1 :     BOOST_CHECK(memcmp(R1S.begin(), R1Array, 20)==0);
     218           1 :     BOOST_CHECK(memcmp(TmpS.begin(), R1Array, 20)==0);
     219           1 :     BOOST_CHECK(memcmp(R2S.begin(), R2Array, 20)==0);
     220           1 :     BOOST_CHECK(memcmp(ZeroS.begin(), ZeroArray, 20)==0);
     221           1 :     BOOST_CHECK(memcmp(OneS.begin(), OneArray, 20)==0);
     222           1 :     BOOST_CHECK(R1S.size() == sizeof(R1S));
     223           1 :     BOOST_CHECK(sizeof(R1S) == 20);
     224           1 :     BOOST_CHECK(R1S.size() == 20);
     225           1 :     BOOST_CHECK(R2S.size() == 20);
     226           1 :     BOOST_CHECK(ZeroS.size() == 20);
     227           1 :     BOOST_CHECK(MaxS.size() == 20);
     228           1 :     BOOST_CHECK(R1S.begin() + 20 == R1S.end());
     229           1 :     BOOST_CHECK(R2S.begin() + 20 == R2S.end());
     230           1 :     BOOST_CHECK(OneS.begin() + 20 == OneS.end());
     231           1 :     BOOST_CHECK(MaxS.begin() + 20 == MaxS.end());
     232           1 :     BOOST_CHECK(TmpS.begin() + 20 == TmpS.end());
     233           1 :     BOOST_CHECK(GetSerializeSize(R1S, PROTOCOL_VERSION) == 20);
     234           1 :     BOOST_CHECK(GetSerializeSize(ZeroS, PROTOCOL_VERSION) == 20);
     235             : 
     236           1 :     ss << R1S;
     237           1 :     BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+20));
     238           1 :     ss >> TmpS;
     239           1 :     BOOST_CHECK(R1S == TmpS);
     240           1 :     ss.clear();
     241           1 :     ss << ZeroS;
     242           1 :     BOOST_CHECK(ss.str() == std::string(ZeroArray,ZeroArray+20));
     243           1 :     ss >> TmpS;
     244           1 :     BOOST_CHECK(ZeroS == TmpS);
     245           1 :     ss.clear();
     246           1 :     ss << MaxS;
     247           1 :     BOOST_CHECK(ss.str() == std::string(MaxArray,MaxArray+20));
     248           1 :     ss >> TmpS;
     249           1 :     BOOST_CHECK(MaxS == TmpS);
     250           1 :     ss.clear();
     251           1 : }
     252             : 
     253         148 : BOOST_AUTO_TEST_CASE( conversion )
     254             : {
     255           1 :     BOOST_CHECK(ArithToUint256(UintToArith256(ZeroL)) == ZeroL);
     256           1 :     BOOST_CHECK(ArithToUint256(UintToArith256(OneL)) == OneL);
     257           1 :     BOOST_CHECK(ArithToUint256(UintToArith256(R1L)) == R1L);
     258           1 :     BOOST_CHECK(ArithToUint256(UintToArith256(R2L)) == R2L);
     259           1 :     BOOST_CHECK(UintToArith256(ZeroL) == 0);
     260           1 :     BOOST_CHECK(UintToArith256(OneL) == 1);
     261           1 :     BOOST_CHECK(ArithToUint256(0) == ZeroL);
     262           1 :     BOOST_CHECK(ArithToUint256(1) == OneL);
     263           1 :     BOOST_CHECK(arith_uint256(UintToArith256(uint256S(R1L.GetHex()))) == UintToArith256(R1L));
     264           1 :     BOOST_CHECK(arith_uint256(UintToArith256(uint256S(R2L.GetHex()))) == UintToArith256(R2L));
     265           1 :     BOOST_CHECK(R1L.GetHex() == UintToArith256(R1L).GetHex());
     266           1 :     BOOST_CHECK(R2L.GetHex() == UintToArith256(R2L).GetHex());
     267           1 : }
     268             : 
     269         148 : BOOST_AUTO_TEST_CASE( operator_with_self )
     270             : {
     271             : 
     272             : /* Clang 16 and earlier detects v -= v and v /= v as self-assignments
     273             :    to 0 and 1 respectively.
     274             :    See: https://github.com/llvm/llvm-project/issues/42469
     275             :    and the fix in commit c5302325b2a62d77cf13dd16cd5c19141862fed0 .
     276             : 
     277             :    This makes some sense for arithmetic classes, but could be considered a bug
     278             :    elsewhere. Disable the warning here so that the code can be tested, but the
     279             :    warning should remain on as there will likely always be a better way to
     280             :    express this.
     281             : */
     282             : 
     283             : #if defined(__clang__)
     284             : #    pragma clang diagnostic push
     285             : #    pragma clang diagnostic ignored "-Wself-assign-overloaded"
     286             : #endif
     287           1 :     arith_uint256 v = UintToArith256(uint256S("02"));
     288           1 :     v *= v;
     289           1 :     BOOST_CHECK(v == UintToArith256(uint256S("04")));
     290           1 :     v /= v;
     291           1 :     BOOST_CHECK(v == UintToArith256(uint256S("01")));
     292           1 :     v += v;
     293           1 :     BOOST_CHECK(v == UintToArith256(uint256S("02")));
     294           1 :     v -= v;
     295           1 :     BOOST_CHECK(v == UintToArith256(uint256S("0")));
     296             : #if defined(__clang__)
     297             : #    pragma clang diagnostic pop
     298             : #endif
     299           1 : }
     300             : 
     301         148 : BOOST_AUTO_TEST_CASE(parse)
     302             : {
     303             :     {
     304           1 :         std::string s_12{"0000000000000000000000000000000000000000000000000000000000000012"};
     305           1 :         BOOST_CHECK_EQUAL(uint256S("12\0").GetHex(), s_12);
     306           1 :         BOOST_CHECK_EQUAL(uint256S(std::string{"12\0", 3}).GetHex(), s_12);
     307           1 :         BOOST_CHECK_EQUAL(uint256S("0x12").GetHex(), s_12);
     308           1 :         BOOST_CHECK_EQUAL(uint256S(" 0x12").GetHex(), s_12);
     309           1 :         BOOST_CHECK_EQUAL(uint256S(" 12").GetHex(), s_12);
     310           1 :     }
     311             :     {
     312           1 :         std::string s_1{uint256::ONE.GetHex()};
     313           1 :         BOOST_CHECK_EQUAL(uint256S("1\0").GetHex(), s_1);
     314           1 :         BOOST_CHECK_EQUAL(uint256S(std::string{"1\0", 2}).GetHex(), s_1);
     315           1 :         BOOST_CHECK_EQUAL(uint256S("0x1").GetHex(), s_1);
     316           1 :         BOOST_CHECK_EQUAL(uint256S(" 0x1").GetHex(), s_1);
     317           1 :         BOOST_CHECK_EQUAL(uint256S(" 1").GetHex(), s_1);
     318           1 :     }
     319             :     {
     320           1 :         std::string s_0{uint256::ZERO.GetHex()};
     321           1 :         BOOST_CHECK_EQUAL(uint256S("\0").GetHex(), s_0);
     322           1 :         BOOST_CHECK_EQUAL(uint256S(std::string{"\0", 1}).GetHex(), s_0);
     323           1 :         BOOST_CHECK_EQUAL(uint256S("0x").GetHex(), s_0);
     324           1 :         BOOST_CHECK_EQUAL(uint256S(" 0x").GetHex(), s_0);
     325           1 :         BOOST_CHECK_EQUAL(uint256S(" ").GetHex(), s_0);
     326           1 :     }
     327           1 : }
     328             : 
     329         148 : BOOST_AUTO_TEST_CASE( check_ONE )
     330             : {
     331           1 :     uint256 one = uint256S("0000000000000000000000000000000000000000000000000000000000000001");
     332           1 :     BOOST_CHECK_EQUAL(one, uint256::ONE);
     333           1 : }
     334             : 
     335         146 : BOOST_AUTO_TEST_SUITE_END()