Bitcoin Core 28.0.0
P2P Digital Currency
Loading...
Searching...
No Matches
Functions | Variables
uint256_tests.cpp File Reference
#include <arith_uint256.h>
#include <streams.h>
#include <test/util/setup_common.h>
#include <uint256.h>
#include <util/strencodings.h>
#include <util/transaction_identifier.h>
#include <boost/test/unit_test.hpp>
#include <iomanip>
#include <sstream>
#include <string>
#include <string_view>
#include <vector>
Include dependency graph for uint256_tests.cpp:

Go to the source code of this file.

Functions

static std::string ArrayToString (const unsigned char A[], unsigned int width)
 
uint160 uint160S (std::string_view str)
 
 BOOST_CHECK_EQUAL (R1S.ToString(), ArrayToString(R1Array, 20))
 
 BOOST_CHECK_EQUAL (R2L.ToString(), ArrayToString(R2Array, 32))
 
 BOOST_CHECK_EQUAL (R2S.ToString(), ArrayToString(R2Array, 20))
 
 BOOST_CHECK_EQUAL (ZeroL.ToString(), ArrayToString(ZeroArray, 32))
 
 BOOST_CHECK_EQUAL (ZeroS.ToString(), ArrayToString(ZeroArray, 20))
 
 BOOST_CHECK_EQUAL (OneL.ToString(), ArrayToString(OneArray, 32))
 
 BOOST_CHECK_EQUAL (OneS.ToString(), ArrayToString(OneArray, 20))
 
 BOOST_CHECK_EQUAL (MaxL.ToString(), ArrayToString(MaxArray, 32))
 
 BOOST_CHECK_EQUAL (MaxS.ToString(), ArrayToString(MaxArray, 20))
 
 BOOST_CHECK_NE (OneL.ToString(), ArrayToString(ZeroArray, 32))
 
 BOOST_CHECK_NE (OneS.ToString(), ArrayToString(ZeroArray, 20))
 
 BOOST_CHECK_NE (R1L, R2L)
 
 BOOST_CHECK_NE (R1S, R2S)
 
 BOOST_CHECK_NE (ZeroL, OneL)
 
 BOOST_CHECK_NE (ZeroS, OneS)
 
 BOOST_CHECK_NE (OneL, ZeroL)
 
 BOOST_CHECK_NE (OneS, ZeroS)
 
 BOOST_CHECK_NE (MaxL, ZeroL)
 
 BOOST_CHECK_NE (MaxS, ZeroS)
 
 BOOST_CHECK_EQUAL (uint256S("0x"+R1L.ToString()), R1L)
 
 BOOST_CHECK_EQUAL (uint256S("0x"+R2L.ToString()), R2L)
 
 BOOST_CHECK_EQUAL (uint256S("0x"+ZeroL.ToString()), ZeroL)
 
 BOOST_CHECK_EQUAL (uint256S("0x"+OneL.ToString()), OneL)
 
 BOOST_CHECK_EQUAL (uint256S("0x"+MaxL.ToString()), MaxL)
 
 BOOST_CHECK_EQUAL (uint256S(R1L.ToString()), R1L)
 
 BOOST_CHECK_EQUAL (uint256S(" 0x"+R1L.ToString()+" "), R1L)
 
 BOOST_CHECK_EQUAL (uint256S(" 0x"+R1L.ToString()+"-trash;%^& "), R1L)
 
 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)
 
 BOOST_CHECK_EQUAL (uint256S(""), ZeroL)
 
 BOOST_CHECK_EQUAL (uint256S("1"), OneL)
 
 BOOST_CHECK_EQUAL (R1L, uint256S(R1ArrayHex))
 
 BOOST_CHECK_EQUAL (uint256(R1L), R1L)
 
 BOOST_CHECK_EQUAL (uint256(ZeroL), ZeroL)
 
 BOOST_CHECK_EQUAL (uint256(OneL), OneL)
 
 BOOST_CHECK_EQUAL (uint160S("0x"+R1S.ToString()), R1S)
 
 BOOST_CHECK_EQUAL (uint160S("0x"+R2S.ToString()), R2S)
 
 BOOST_CHECK_EQUAL (uint160S("0x"+ZeroS.ToString()), ZeroS)
 
 BOOST_CHECK_EQUAL (uint160S("0x"+OneS.ToString()), OneS)
 
 BOOST_CHECK_EQUAL (uint160S("0x"+MaxS.ToString()), MaxS)
 
 BOOST_CHECK_EQUAL (uint160S(R1S.ToString()), R1S)
 
 BOOST_CHECK_EQUAL (uint160S(" 0x"+R1S.ToString()+" "), R1S)
 
 BOOST_CHECK_EQUAL (uint160S(" 0x"+R1S.ToString()+"-trash;%^& "), R1S)
 
 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)
 
 BOOST_CHECK_EQUAL (uint160S(""), ZeroS)
 
 BOOST_CHECK_EQUAL (R1S, uint160S(R1ArrayHex))
 
 BOOST_CHECK_EQUAL (uint160(R1S), R1S)
 
 BOOST_CHECK_EQUAL (uint160(ZeroS), ZeroS)
 
 BOOST_CHECK_EQUAL (uint160(OneS), OneS)
 
 for (int i=255;i >=0;--i)
 
 BOOST_CHECK_LT (ZeroL, R1L)
 
 BOOST_CHECK_LT (R2L, R1L)
 
 BOOST_CHECK_LT (ZeroL, OneL)
 
 BOOST_CHECK_LT (OneL, MaxL)
 
 BOOST_CHECK_LT (R1L, MaxL)
 
 BOOST_CHECK_LT (R2L, MaxL)
 
 BOOST_CHECK_LT (ZeroS, R1S)
 
 BOOST_CHECK_LT (R2S, R1S)
 
 BOOST_CHECK_LT (ZeroS, OneS)
 
 BOOST_CHECK_LT (OneS, MaxS)
 
 BOOST_CHECK_LT (R1S, MaxS)
 
 BOOST_CHECK_LT (R2S, MaxS)
 
 BOOST_CHECK_LT (uint256{"1000000000000000000000000000000000000000000000000000000000000000"}, uint256{"0000000000000000000000000000000000000000000000000000000000000001"})
 
 BOOST_CHECK_EQUAL (R2L.GetHex(), R2L.ToString())
 
 BOOST_CHECK_EQUAL (OneL.GetHex(), OneL.ToString())
 
 BOOST_CHECK_EQUAL (MaxL.GetHex(), MaxL.ToString())
 
 BOOST_CHECK_EQUAL (TmpL, R1L)
 
TmpL SetHexDeprecated ("21")
 
 BOOST_CHECK_EQUAL (TmpL.ToString(), "0000000000000000000000000000000000000000000000000000000000000021")
 
 BOOST_CHECK_EQUAL (uint256::FromHex(R2L.ToString()).value(), R2L)
 
 BOOST_CHECK_EQUAL (uint256::FromHex(ZeroL.ToString()).value(), uint256())
 
 BOOST_CHECK_EQUAL_COLLECTIONS (R1L.begin(), R1L.end(), R1Array, R1Array+uint256::size())
 
 BOOST_CHECK_EQUAL_COLLECTIONS (TmpL.begin(), TmpL.end(), R1Array, R1Array+uint256::size())
 
 BOOST_CHECK_EQUAL_COLLECTIONS (R2L.begin(), R2L.end(), R2Array, R2Array+uint256::size())
 
 BOOST_CHECK_EQUAL_COLLECTIONS (ZeroL.begin(), ZeroL.end(), ZeroArray, ZeroArray+uint256::size())
 
 BOOST_CHECK_EQUAL_COLLECTIONS (OneL.begin(), OneL.end(), OneArray, OneArray+uint256::size())
 
 BOOST_CHECK_EQUAL (R1L.size(), sizeof(R1L))
 
 BOOST_CHECK_EQUAL (sizeof(R1L), 32)
 
 BOOST_CHECK_EQUAL (R1L.size(), 32)
 
 BOOST_CHECK_EQUAL (R2L.size(), 32)
 
 BOOST_CHECK_EQUAL (ZeroL.size(), 32)
 
 BOOST_CHECK_EQUAL (MaxL.size(), 32)
 
 BOOST_CHECK_EQUAL (R1L.begin()+32, R1L.end())
 
 BOOST_CHECK_EQUAL (R2L.begin()+32, R2L.end())
 
 BOOST_CHECK_EQUAL (OneL.begin()+32, OneL.end())
 
 BOOST_CHECK_EQUAL (MaxL.begin()+32, MaxL.end())
 
 BOOST_CHECK_EQUAL (TmpL.begin()+32, TmpL.end())
 
 BOOST_CHECK_EQUAL (GetSerializeSize(R1L), 32)
 
 BOOST_CHECK_EQUAL (GetSerializeSize(ZeroL), 32)
 
 BOOST_CHECK_EQUAL (R1L, TmpL)
 
ss clear ()
 
 BOOST_CHECK_EQUAL (ZeroL, TmpL)
 
 BOOST_CHECK_EQUAL (MaxL, TmpL)
 
 BOOST_CHECK_EQUAL (R1S.GetHex(), R1S.ToString())
 
 BOOST_CHECK_EQUAL (R2S.GetHex(), R2S.ToString())
 
 BOOST_CHECK_EQUAL (OneS.GetHex(), OneS.ToString())
 
 BOOST_CHECK_EQUAL (MaxS.GetHex(), MaxS.ToString())
 
 BOOST_CHECK_EQUAL (TmpS, R1S)
 
 BOOST_CHECK_EQUAL (uint160::FromHex(R2S.ToString()).value(), R2S)
 
 BOOST_CHECK_EQUAL (uint160::FromHex(ZeroS.ToString()).value(), uint160())
 
 BOOST_CHECK_EQUAL_COLLECTIONS (R1S.begin(), R1S.end(), R1Array, R1Array+uint160::size())
 
 BOOST_CHECK_EQUAL_COLLECTIONS (TmpS.begin(), TmpS.end(), R1Array, R1Array+uint160::size())
 
 BOOST_CHECK_EQUAL_COLLECTIONS (R2S.begin(), R2S.end(), R2Array, R2Array+uint160::size())
 
 BOOST_CHECK_EQUAL_COLLECTIONS (ZeroS.begin(), ZeroS.end(), ZeroArray, ZeroArray+uint160::size())
 
 BOOST_CHECK_EQUAL_COLLECTIONS (OneS.begin(), OneS.end(), OneArray, OneArray+uint160::size())
 
 BOOST_CHECK_EQUAL (R1S.size(), sizeof(R1S))
 
 BOOST_CHECK_EQUAL (sizeof(R1S), 20)
 
 BOOST_CHECK_EQUAL (R1S.size(), 20)
 
 BOOST_CHECK_EQUAL (R2S.size(), 20)
 
 BOOST_CHECK_EQUAL (ZeroS.size(), 20)
 
 BOOST_CHECK_EQUAL (MaxS.size(), 20)
 
 BOOST_CHECK_EQUAL (R1S.begin()+20, R1S.end())
 
 BOOST_CHECK_EQUAL (R2S.begin()+20, R2S.end())
 
 BOOST_CHECK_EQUAL (OneS.begin()+20, OneS.end())
 
 BOOST_CHECK_EQUAL (MaxS.begin()+20, MaxS.end())
 
 BOOST_CHECK_EQUAL (TmpS.begin()+20, TmpS.end())
 
 BOOST_CHECK_EQUAL (GetSerializeSize(R1S), 20)
 
 BOOST_CHECK_EQUAL (GetSerializeSize(ZeroS), 20)
 
 BOOST_CHECK_EQUAL (R1S, TmpS)
 
 BOOST_CHECK_EQUAL (ZeroS, TmpS)
 
 BOOST_CHECK_EQUAL (MaxS, TmpS)
 
 BOOST_AUTO_TEST_CASE (conversion)
 
 BOOST_AUTO_TEST_CASE (operator_with_self)
 
 BOOST_AUTO_TEST_CASE (parse)
 
template<typename T >
void TestFromHex ()
 Implemented as a templated function so it can be reused by other classes that have a FromHex() method that wraps base_blob::FromHex(), such as transaction_identifier::FromHex().
 
 BOOST_AUTO_TEST_CASE (from_hex)
 
 BOOST_AUTO_TEST_CASE (check_ONE)
 
 BOOST_AUTO_TEST_CASE (FromHex_vs_uint256)
 

Variables

const unsigned char R1Array []
 
const char R1ArrayHex [] = "7D1DE5EAF9B156D53208F033B5AA8122D2d2355d5e12292b121156cfdb4a529c"
 
const uint256 R1L = uint256(std::vector<unsigned char>(R1Array,R1Array+32))
 
const uint160 R1S = uint160(std::vector<unsigned char>(R1Array,R1Array+20))
 
const unsigned char R2Array []
 
const uint256 R2L = uint256(std::vector<unsigned char>(R2Array,R2Array+32))
 
const uint160 R2S = uint160(std::vector<unsigned char>(R2Array,R2Array+20))
 
const unsigned char ZeroArray []
 
const uint256 ZeroL = uint256(std::vector<unsigned char>(ZeroArray,ZeroArray+32))
 
const uint160 ZeroS = uint160(std::vector<unsigned char>(ZeroArray,ZeroArray+20))
 
const unsigned char OneArray []
 
const uint256 OneL = uint256(std::vector<unsigned char>(OneArray,OneArray+32))
 
const uint160 OneS = uint160(std::vector<unsigned char>(OneArray,OneArray+20))
 
const unsigned char MaxArray []
 
const uint256 MaxL = uint256(std::vector<unsigned char>(MaxArray,MaxArray+32))
 
const uint160 MaxS = uint160(std::vector<unsigned char>(MaxArray,MaxArray+20))
 
uint160 LastS
 
uint256 TmpL (R1L) = uint256::FromHex(R1L.ToString()).value()
 
DataStream ss {}
 
uint160 TmpS (R1S) = uint160::FromHex(R1S.ToString()).value()
 

Function Documentation

◆ ArrayToString()

static std::string ArrayToString ( const unsigned char A[],
unsigned int width )
static

Definition at line 53 of file uint256_tests.cpp.

◆ BOOST_AUTO_TEST_CASE() [1/6]

BOOST_AUTO_TEST_CASE ( check_ONE )

Definition at line 396 of file uint256_tests.cpp.

◆ BOOST_AUTO_TEST_CASE() [2/6]

BOOST_AUTO_TEST_CASE ( conversion )

Definition at line 267 of file uint256_tests.cpp.

Here is the call graph for this function:

◆ BOOST_AUTO_TEST_CASE() [3/6]

BOOST_AUTO_TEST_CASE ( from_hex )

Definition at line 388 of file uint256_tests.cpp.

Here is the call graph for this function:

◆ BOOST_AUTO_TEST_CASE() [4/6]

BOOST_AUTO_TEST_CASE ( FromHex_vs_uint256 )

Definition at line 402 of file uint256_tests.cpp.

Here is the call graph for this function:

◆ BOOST_AUTO_TEST_CASE() [5/6]

BOOST_AUTO_TEST_CASE ( operator_with_self )

Definition at line 283 of file uint256_tests.cpp.

Here is the call graph for this function:

◆ BOOST_AUTO_TEST_CASE() [6/6]

BOOST_AUTO_TEST_CASE ( parse )

Definition at line 315 of file uint256_tests.cpp.

Here is the call graph for this function:

◆ BOOST_CHECK_EQUAL() [1/84]

BOOST_CHECK_EQUAL ( GetSerializeSize(R1L) ,
32  )

◆ BOOST_CHECK_EQUAL() [2/84]

BOOST_CHECK_EQUAL ( GetSerializeSize(R1S) ,
20  )

◆ BOOST_CHECK_EQUAL() [3/84]

BOOST_CHECK_EQUAL ( GetSerializeSize(ZeroL) ,
32  )

◆ BOOST_CHECK_EQUAL() [4/84]

BOOST_CHECK_EQUAL ( GetSerializeSize(ZeroS) ,
20  )

◆ BOOST_CHECK_EQUAL() [5/84]

BOOST_CHECK_EQUAL ( MaxL ,
TmpL  )

◆ BOOST_CHECK_EQUAL() [6/84]

BOOST_CHECK_EQUAL ( MaxL.begin()+ 32,
MaxL. end() )

◆ BOOST_CHECK_EQUAL() [7/84]

BOOST_CHECK_EQUAL ( MaxL. GetHex(),
MaxL. ToString() )

◆ BOOST_CHECK_EQUAL() [8/84]

BOOST_CHECK_EQUAL ( MaxL. size(),
32  )

◆ BOOST_CHECK_EQUAL() [9/84]

BOOST_CHECK_EQUAL ( MaxL. ToString(),
ArrayToString(MaxArray, 32)  )

◆ BOOST_CHECK_EQUAL() [10/84]

BOOST_CHECK_EQUAL ( MaxS ,
TmpS  )

◆ BOOST_CHECK_EQUAL() [11/84]

BOOST_CHECK_EQUAL ( MaxS.begin()+ 20,
MaxS. end() )

◆ BOOST_CHECK_EQUAL() [12/84]

BOOST_CHECK_EQUAL ( MaxS. GetHex(),
MaxS. ToString() )

◆ BOOST_CHECK_EQUAL() [13/84]

BOOST_CHECK_EQUAL ( MaxS. size(),
20  )

◆ BOOST_CHECK_EQUAL() [14/84]

BOOST_CHECK_EQUAL ( MaxS. ToString(),
ArrayToString(MaxArray, 20)  )

◆ BOOST_CHECK_EQUAL() [15/84]

BOOST_CHECK_EQUAL ( OneL.begin()+ 32,
OneL. end() )

◆ BOOST_CHECK_EQUAL() [16/84]

BOOST_CHECK_EQUAL ( OneL. GetHex(),
OneL. ToString() )

◆ BOOST_CHECK_EQUAL() [17/84]

BOOST_CHECK_EQUAL ( OneL. ToString(),
ArrayToString(OneArray, 32)  )

◆ BOOST_CHECK_EQUAL() [18/84]

BOOST_CHECK_EQUAL ( OneS.begin()+ 20,
OneS. end() )

◆ BOOST_CHECK_EQUAL() [19/84]

BOOST_CHECK_EQUAL ( OneS. GetHex(),
OneS. ToString() )

◆ BOOST_CHECK_EQUAL() [20/84]

BOOST_CHECK_EQUAL ( OneS. ToString(),
ArrayToString(OneArray, 20)  )

◆ BOOST_CHECK_EQUAL() [21/84]

BOOST_CHECK_EQUAL ( R1L ,
TmpL  )

◆ BOOST_CHECK_EQUAL() [22/84]

BOOST_CHECK_EQUAL ( R1L ,
uint256S(R1ArrayHex)  )

◆ BOOST_CHECK_EQUAL() [23/84]

BOOST_CHECK_EQUAL ( R1L.begin()+ 32,
R1L. end() )

◆ BOOST_CHECK_EQUAL() [24/84]

BOOST_CHECK_EQUAL ( R1L. size(),
32  )

◆ BOOST_CHECK_EQUAL() [25/84]

BOOST_CHECK_EQUAL ( R1L. size(),
sizeof(R1L)  )

◆ BOOST_CHECK_EQUAL() [26/84]

BOOST_CHECK_EQUAL ( R1S ,
TmpS  )

◆ BOOST_CHECK_EQUAL() [27/84]

BOOST_CHECK_EQUAL ( R1S ,
uint160S(R1ArrayHex)  )

◆ BOOST_CHECK_EQUAL() [28/84]

BOOST_CHECK_EQUAL ( R1S.begin()+ 20,
R1S. end() )

◆ BOOST_CHECK_EQUAL() [29/84]

BOOST_CHECK_EQUAL ( R1S. GetHex(),
R1S. ToString() )

◆ BOOST_CHECK_EQUAL() [30/84]

BOOST_CHECK_EQUAL ( R1S. size(),
20  )

◆ BOOST_CHECK_EQUAL() [31/84]

BOOST_CHECK_EQUAL ( R1S. size(),
sizeof(R1S)  )

◆ BOOST_CHECK_EQUAL() [32/84]

BOOST_CHECK_EQUAL ( R1S. ToString(),
ArrayToString(R1Array, 20)  )

◆ BOOST_CHECK_EQUAL() [33/84]

BOOST_CHECK_EQUAL ( R2L.begin()+ 32,
R2L. end() )

◆ BOOST_CHECK_EQUAL() [34/84]

BOOST_CHECK_EQUAL ( R2L. GetHex(),
R2L. ToString() )

◆ BOOST_CHECK_EQUAL() [35/84]

BOOST_CHECK_EQUAL ( R2L. size(),
32  )

◆ BOOST_CHECK_EQUAL() [36/84]

BOOST_CHECK_EQUAL ( R2L. ToString(),
ArrayToString(R2Array, 32)  )

◆ BOOST_CHECK_EQUAL() [37/84]

BOOST_CHECK_EQUAL ( R2S.begin()+ 20,
R2S. end() )

◆ BOOST_CHECK_EQUAL() [38/84]

BOOST_CHECK_EQUAL ( R2S. GetHex(),
R2S. ToString() )

◆ BOOST_CHECK_EQUAL() [39/84]

BOOST_CHECK_EQUAL ( R2S. size(),
20  )

◆ BOOST_CHECK_EQUAL() [40/84]

BOOST_CHECK_EQUAL ( R2S. ToString(),
ArrayToString(R2Array, 20)  )

◆ BOOST_CHECK_EQUAL() [41/84]

BOOST_CHECK_EQUAL ( sizeof(R1L) ,
32  )

◆ BOOST_CHECK_EQUAL() [42/84]

BOOST_CHECK_EQUAL ( sizeof(R1S) ,
20  )

◆ BOOST_CHECK_EQUAL() [43/84]

BOOST_CHECK_EQUAL ( TmpL ,
R1L  )

◆ BOOST_CHECK_EQUAL() [44/84]

BOOST_CHECK_EQUAL ( TmpL.begin()+ 32,
TmpL. end() )

◆ BOOST_CHECK_EQUAL() [45/84]

BOOST_CHECK_EQUAL ( TmpL. ToString(),
"0000000000000000000000000000000000000000000000000000000000000021"  )

◆ BOOST_CHECK_EQUAL() [46/84]

BOOST_CHECK_EQUAL ( TmpS ,
R1S  )

◆ BOOST_CHECK_EQUAL() [47/84]

BOOST_CHECK_EQUAL ( TmpS.begin()+ 20,
TmpS. end() )

◆ BOOST_CHECK_EQUAL() [48/84]

BOOST_CHECK_EQUAL ( uint160(OneS) ,
OneS  )

◆ BOOST_CHECK_EQUAL() [49/84]

BOOST_CHECK_EQUAL ( uint160(R1S) ,
R1S  )

◆ BOOST_CHECK_EQUAL() [50/84]

BOOST_CHECK_EQUAL ( uint160(ZeroS) ,
ZeroS  )

◆ BOOST_CHECK_EQUAL() [51/84]

BOOST_CHECK_EQUAL ( uint160::FromHex(R2S.ToString()).value() ,
R2S  )

◆ BOOST_CHECK_EQUAL() [52/84]

BOOST_CHECK_EQUAL ( uint160::FromHex(ZeroS.ToString()).value() ,
uint160()  )

◆ BOOST_CHECK_EQUAL() [53/84]

BOOST_CHECK_EQUAL ( uint160S(" 0x"+R1S.ToString()+" ") ,
R1S  )

◆ BOOST_CHECK_EQUAL() [54/84]

BOOST_CHECK_EQUAL ( uint160S(" 0x"+R1S.ToString()+"-trash;%^& ") ,
R1S  )

◆ BOOST_CHECK_EQUAL() [55/84]

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  )

◆ BOOST_CHECK_EQUAL() [56/84]

BOOST_CHECK_EQUAL ( uint160S("") ,
ZeroS  )

◆ BOOST_CHECK_EQUAL() [57/84]

BOOST_CHECK_EQUAL ( uint160S("0x"+MaxS.ToString()) ,
MaxS  )

◆ BOOST_CHECK_EQUAL() [58/84]

BOOST_CHECK_EQUAL ( uint160S("0x"+OneS.ToString()) ,
OneS  )

◆ BOOST_CHECK_EQUAL() [59/84]

BOOST_CHECK_EQUAL ( uint160S("0x"+R1S.ToString()) ,
R1S  )

◆ BOOST_CHECK_EQUAL() [60/84]

BOOST_CHECK_EQUAL ( uint160S("0x"+R2S.ToString()) ,
R2S  )

◆ BOOST_CHECK_EQUAL() [61/84]

BOOST_CHECK_EQUAL ( uint160S("0x"+ZeroS.ToString()) ,
ZeroS  )

◆ BOOST_CHECK_EQUAL() [62/84]

BOOST_CHECK_EQUAL ( uint160S(R1S.ToString()) ,
R1S  )

◆ BOOST_CHECK_EQUAL() [63/84]

BOOST_CHECK_EQUAL ( uint256(OneL) ,
OneL  )

◆ BOOST_CHECK_EQUAL() [64/84]

BOOST_CHECK_EQUAL ( uint256(R1L) ,
R1L  )

◆ BOOST_CHECK_EQUAL() [65/84]

BOOST_CHECK_EQUAL ( uint256(ZeroL) ,
ZeroL  )

◆ BOOST_CHECK_EQUAL() [66/84]

BOOST_CHECK_EQUAL ( uint256::FromHex(R2L.ToString()).value() ,
R2L  )

◆ BOOST_CHECK_EQUAL() [67/84]

BOOST_CHECK_EQUAL ( uint256::FromHex(ZeroL.ToString()).value() ,
uint256()  )

◆ BOOST_CHECK_EQUAL() [68/84]

BOOST_CHECK_EQUAL ( uint256S(" 0x"+R1L.ToString()+" ") ,
R1L  )

◆ BOOST_CHECK_EQUAL() [69/84]

BOOST_CHECK_EQUAL ( uint256S(" 0x"+R1L.ToString()+"-trash;%^& ") ,
R1L  )

◆ BOOST_CHECK_EQUAL() [70/84]

BOOST_CHECK_EQUAL ( uint256S("") ,
ZeroL  )

◆ BOOST_CHECK_EQUAL() [71/84]

BOOST_CHECK_EQUAL ( uint256S("0x"+MaxL.ToString()) ,
MaxL  )

◆ BOOST_CHECK_EQUAL() [72/84]

BOOST_CHECK_EQUAL ( uint256S("0x"+OneL.ToString()) ,
OneL  )

◆ BOOST_CHECK_EQUAL() [73/84]

BOOST_CHECK_EQUAL ( uint256S("0x"+R1L.ToString()) ,
R1L  )

◆ BOOST_CHECK_EQUAL() [74/84]

BOOST_CHECK_EQUAL ( uint256S("0x"+R2L.ToString()) ,
R2L  )

◆ BOOST_CHECK_EQUAL() [75/84]

BOOST_CHECK_EQUAL ( uint256S("0x"+ZeroL.ToString()) ,
ZeroL  )

◆ BOOST_CHECK_EQUAL() [76/84]

BOOST_CHECK_EQUAL ( uint256S("1") ,
OneL  )

◆ BOOST_CHECK_EQUAL() [77/84]

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  )

◆ BOOST_CHECK_EQUAL() [78/84]

BOOST_CHECK_EQUAL ( uint256S(R1L.ToString()) ,
R1L  )

◆ BOOST_CHECK_EQUAL() [79/84]

BOOST_CHECK_EQUAL ( ZeroL ,
TmpL  )

◆ BOOST_CHECK_EQUAL() [80/84]

BOOST_CHECK_EQUAL ( ZeroL. size(),
32  )

◆ BOOST_CHECK_EQUAL() [81/84]

BOOST_CHECK_EQUAL ( ZeroL. ToString(),
ArrayToString(ZeroArray, 32)  )

◆ BOOST_CHECK_EQUAL() [82/84]

BOOST_CHECK_EQUAL ( ZeroS ,
TmpS  )

◆ BOOST_CHECK_EQUAL() [83/84]

BOOST_CHECK_EQUAL ( ZeroS. size(),
20  )

◆ BOOST_CHECK_EQUAL() [84/84]

BOOST_CHECK_EQUAL ( ZeroS. ToString(),
ArrayToString(ZeroArray, 20)  )

◆ BOOST_CHECK_EQUAL_COLLECTIONS() [1/10]

BOOST_CHECK_EQUAL_COLLECTIONS ( OneL. begin(),
OneL. end(),
OneArray ,
OneArray+ uint256::size() )

◆ BOOST_CHECK_EQUAL_COLLECTIONS() [2/10]

BOOST_CHECK_EQUAL_COLLECTIONS ( OneS. begin(),
OneS. end(),
OneArray ,
OneArray+ uint160::size() )

◆ BOOST_CHECK_EQUAL_COLLECTIONS() [3/10]

BOOST_CHECK_EQUAL_COLLECTIONS ( R1L. begin(),
R1L. end(),
R1Array ,
R1Array+ uint256::size() )
Here is the caller graph for this function:

◆ BOOST_CHECK_EQUAL_COLLECTIONS() [4/10]

BOOST_CHECK_EQUAL_COLLECTIONS ( R1S. begin(),
R1S. end(),
R1Array ,
R1Array+ uint160::size() )

◆ BOOST_CHECK_EQUAL_COLLECTIONS() [5/10]

BOOST_CHECK_EQUAL_COLLECTIONS ( R2L. begin(),
R2L. end(),
R2Array ,
R2Array+ uint256::size() )

◆ BOOST_CHECK_EQUAL_COLLECTIONS() [6/10]

BOOST_CHECK_EQUAL_COLLECTIONS ( R2S. begin(),
R2S. end(),
R2Array ,
R2Array+ uint160::size() )

◆ BOOST_CHECK_EQUAL_COLLECTIONS() [7/10]

BOOST_CHECK_EQUAL_COLLECTIONS ( TmpL. begin(),
TmpL. end(),
R1Array ,
R1Array+ uint256::size() )

◆ BOOST_CHECK_EQUAL_COLLECTIONS() [8/10]

BOOST_CHECK_EQUAL_COLLECTIONS ( TmpS. begin(),
TmpS. end(),
R1Array ,
R1Array+ uint160::size() )

◆ BOOST_CHECK_EQUAL_COLLECTIONS() [9/10]

BOOST_CHECK_EQUAL_COLLECTIONS ( ZeroL. begin(),
ZeroL. end(),
ZeroArray ,
ZeroArray+ uint256::size() )

◆ BOOST_CHECK_EQUAL_COLLECTIONS() [10/10]

BOOST_CHECK_EQUAL_COLLECTIONS ( ZeroS. begin(),
ZeroS. end(),
ZeroArray ,
ZeroArray+ uint160::size() )

◆ BOOST_CHECK_LT() [1/13]

BOOST_CHECK_LT ( OneL ,
MaxL  )

◆ BOOST_CHECK_LT() [2/13]

BOOST_CHECK_LT ( OneS ,
MaxS  )

◆ BOOST_CHECK_LT() [3/13]

BOOST_CHECK_LT ( R1L ,
MaxL  )

◆ BOOST_CHECK_LT() [4/13]

BOOST_CHECK_LT ( R1S ,
MaxS  )

◆ BOOST_CHECK_LT() [5/13]

BOOST_CHECK_LT ( R2L ,
MaxL  )

◆ BOOST_CHECK_LT() [6/13]

BOOST_CHECK_LT ( R2L ,
R1L  )

◆ BOOST_CHECK_LT() [7/13]

BOOST_CHECK_LT ( R2S ,
MaxS  )

◆ BOOST_CHECK_LT() [8/13]

BOOST_CHECK_LT ( R2S ,
R1S  )

◆ BOOST_CHECK_LT() [9/13]

BOOST_CHECK_LT ( uint256{"1000000000000000000000000000000000000000000000000000000000000000"} ,
uint256{"0000000000000000000000000000000000000000000000000000000000000001"}  )

◆ BOOST_CHECK_LT() [10/13]

BOOST_CHECK_LT ( ZeroL ,
OneL  )

◆ BOOST_CHECK_LT() [11/13]

BOOST_CHECK_LT ( ZeroL ,
R1L  )
Here is the caller graph for this function:

◆ BOOST_CHECK_LT() [12/13]

BOOST_CHECK_LT ( ZeroS ,
OneS  )

◆ BOOST_CHECK_LT() [13/13]

BOOST_CHECK_LT ( ZeroS ,
R1S  )

◆ BOOST_CHECK_NE() [1/10]

BOOST_CHECK_NE ( MaxL ,
ZeroL  )

◆ BOOST_CHECK_NE() [2/10]

BOOST_CHECK_NE ( MaxS ,
ZeroS  )

◆ BOOST_CHECK_NE() [3/10]

BOOST_CHECK_NE ( OneL ,
ZeroL  )

◆ BOOST_CHECK_NE() [4/10]

BOOST_CHECK_NE ( OneL. ToString(),
ArrayToString(ZeroArray, 32)  )
Here is the caller graph for this function:

◆ BOOST_CHECK_NE() [5/10]

BOOST_CHECK_NE ( OneS ,
ZeroS  )

◆ BOOST_CHECK_NE() [6/10]

BOOST_CHECK_NE ( OneS. ToString(),
ArrayToString(ZeroArray, 20)  )

◆ BOOST_CHECK_NE() [7/10]

BOOST_CHECK_NE ( R1L ,
R2L  )

◆ BOOST_CHECK_NE() [8/10]

BOOST_CHECK_NE ( R1S ,
R2S  )

◆ BOOST_CHECK_NE() [9/10]

BOOST_CHECK_NE ( ZeroL ,
OneL  )

◆ BOOST_CHECK_NE() [10/10]

BOOST_CHECK_NE ( ZeroS ,
OneS  )

◆ clear()

ss clear ( )
Here is the caller graph for this function:

◆ for()

for ( int i = 255; i >= 0; --i)

Definition at line 131 of file uint256_tests.cpp.

Here is the call graph for this function:

◆ SetHexDeprecated()

TmpL SetHexDeprecated ( "21" )

◆ TestFromHex()

template<typename T >
void TestFromHex ( )

Implemented as a templated function so it can be reused by other classes that have a FromHex() method that wraps base_blob::FromHex(), such as transaction_identifier::FromHex().

Definition at line 348 of file uint256_tests.cpp.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ uint160S()

uint160 uint160S ( std::string_view str)
inline

Definition at line 65 of file uint256_tests.cpp.

Here is the call graph for this function:

Variable Documentation

◆ LastS

uint160 LastS

Definition at line 145 of file uint256_tests.cpp.

◆ MaxArray

const unsigned char MaxArray[]
Initial value:
=
"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"

Definition at line 47 of file uint256_tests.cpp.

◆ MaxL

const uint256 MaxL = uint256(std::vector<unsigned char>(MaxArray,MaxArray+32))

Definition at line 50 of file uint256_tests.cpp.

◆ MaxS

const uint160 MaxS = uint160(std::vector<unsigned char>(MaxArray,MaxArray+20))

Definition at line 51 of file uint256_tests.cpp.

◆ OneArray

const unsigned char OneArray[]
Initial value:
=
"\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"

Definition at line 41 of file uint256_tests.cpp.

◆ OneL

const uint256 OneL = uint256(std::vector<unsigned char>(OneArray,OneArray+32))

Definition at line 44 of file uint256_tests.cpp.

◆ OneS

const uint160 OneS = uint160(std::vector<unsigned char>(OneArray,OneArray+20))

Definition at line 45 of file uint256_tests.cpp.

◆ R1Array

const unsigned char R1Array[]
Initial value:
=
"\x9c\x52\x4a\xdb\xcf\x56\x11\x12\x2b\x29\x12\x5e\x5d\x35\xd2\xd2"
"\x22\x81\xaa\xb5\x33\xf0\x08\x32\xd5\x56\xb1\xf9\xea\xe5\x1d\x7d"

Definition at line 22 of file uint256_tests.cpp.

◆ R1ArrayHex

const char R1ArrayHex[] = "7D1DE5EAF9B156D53208F033B5AA8122D2d2355d5e12292b121156cfdb4a529c"

Definition at line 25 of file uint256_tests.cpp.

◆ R1L

const uint256 R1L = uint256(std::vector<unsigned char>(R1Array,R1Array+32))

Definition at line 26 of file uint256_tests.cpp.

◆ R1S

const uint160 R1S = uint160(std::vector<unsigned char>(R1Array,R1Array+20))

Definition at line 27 of file uint256_tests.cpp.

◆ R2Array

const unsigned char R2Array[]
Initial value:
=
"\x70\x32\x1d\x7c\x47\xa5\x6b\x40\x26\x7e\x0a\xc3\xa6\x9c\xb6\xbf"
"\x13\x30\x47\xa3\x19\x2d\xda\x71\x49\x13\x72\xf0\xb4\xca\x81\xd7"

Definition at line 29 of file uint256_tests.cpp.

◆ R2L

const uint256 R2L = uint256(std::vector<unsigned char>(R2Array,R2Array+32))

Definition at line 32 of file uint256_tests.cpp.

◆ R2S

const uint160 R2S = uint160(std::vector<unsigned char>(R2Array,R2Array+20))

Definition at line 33 of file uint256_tests.cpp.

◆ ss

ss<< MaxS BOOST_CHECK_EQUAL(ss.str(), std::string(MaxArray, MaxArray+20)) ss > TmpS {}

Definition at line 204 of file uint256_tests.cpp.

◆ TmpL

ss<< MaxL; BOOST_CHECK_EQUAL(ss.str(), std::string(MaxArray,MaxArray+32)); ss > TmpL ( R1L ) = uint256::FromHex(R1L.ToString()).value()

Definition at line 184 of file uint256_tests.cpp.

◆ TmpS

ss<< MaxS; BOOST_CHECK_EQUAL(ss.str(), std::string(MaxArray,MaxArray+20)); ss > TmpS ( R1S ) = uint160::FromHex(R1S.ToString()).value()

Definition at line 230 of file uint256_tests.cpp.

◆ ZeroArray

const unsigned char ZeroArray[]
Initial value:
=
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"

Definition at line 35 of file uint256_tests.cpp.

◆ ZeroL

const uint256 ZeroL = uint256(std::vector<unsigned char>(ZeroArray,ZeroArray+32))

Definition at line 38 of file uint256_tests.cpp.

◆ ZeroS

const uint160 ZeroS = uint160(std::vector<unsigned char>(ZeroArray,ZeroArray+20))

Definition at line 39 of file uint256_tests.cpp.

Generated on Thu Oct 3 2024 09:20:15 for Bitcoin Core by doxygen 1.12.0