LCOV - code coverage report
Current view: top level - src/test - util_tests.cpp (source / functions) Coverage Total Hit
Test: total_coverage.info Lines: 99.4 % 1321 1313
Test Date: 2025-04-28 05:00:59 Functions: 100.0 % 128 128
Branches: 50.0 % 7224 3612

             Branch data     Line data    Source code
       1                 :             : // Copyright (c) 2011-present 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 <clientversion.h>
       6                 :             : #include <common/signmessage.h> // For MessageSign(), MessageVerify(), MESSAGE_MAGIC
       7                 :             : #include <hash.h> // For Hash()
       8                 :             : #include <key.h>  // For CKey
       9                 :             : #include <script/parsing.h>
      10                 :             : #include <span.h>
      11                 :             : #include <sync.h>
      12                 :             : #include <test/util/random.h>
      13                 :             : #include <test/util/setup_common.h>
      14                 :             : #include <uint256.h>
      15                 :             : #include <util/bitdeque.h>
      16                 :             : #include <util/byte_units.h>
      17                 :             : #include <util/fs.h>
      18                 :             : #include <util/fs_helpers.h>
      19                 :             : #include <util/moneystr.h>
      20                 :             : #include <util/overflow.h>
      21                 :             : #include <util/readwritefile.h>
      22                 :             : #include <util/strencodings.h>
      23                 :             : #include <util/string.h>
      24                 :             : #include <util/time.h>
      25                 :             : #include <util/vector.h>
      26                 :             : 
      27                 :             : #include <array>
      28                 :             : #include <cmath>
      29                 :             : #include <fstream>
      30                 :             : #include <limits>
      31                 :             : #include <map>
      32                 :             : #include <optional>
      33                 :             : #include <stdint.h>
      34                 :             : #include <string.h>
      35                 :             : #include <thread>
      36                 :             : #include <univalue.h>
      37                 :             : #include <utility>
      38                 :             : #include <vector>
      39                 :             : 
      40                 :             : #include <sys/types.h>
      41                 :             : 
      42                 :             : #ifndef WIN32
      43                 :             : #include <signal.h>
      44                 :             : #include <sys/wait.h>
      45                 :             : #endif
      46                 :             : 
      47                 :             : #include <boost/test/unit_test.hpp>
      48                 :             : 
      49                 :             : using namespace std::literals;
      50                 :             : using namespace util::hex_literals;
      51                 :             : using util::ConstevalHexDigit;
      52                 :             : using util::Join;
      53                 :             : using util::RemovePrefix;
      54                 :             : using util::RemovePrefixView;
      55                 :             : using util::ReplaceAll;
      56                 :             : using util::Split;
      57                 :             : using util::SplitString;
      58                 :             : using util::TrimString;
      59                 :             : using util::TrimStringView;
      60                 :             : 
      61                 :             : static const std::string STRING_WITH_EMBEDDED_NULL_CHAR{"1"s "\0" "1"s};
      62                 :             : 
      63                 :             : /* defined in logging.cpp */
      64                 :             : namespace BCLog {
      65                 :             :     std::string LogEscapeMessage(std::string_view str);
      66                 :             : }
      67                 :             : 
      68                 :             : BOOST_FIXTURE_TEST_SUITE(util_tests, BasicTestingSetup)
      69                 :             : 
      70                 :             : namespace {
      71                 :             : class NoCopyOrMove
      72                 :             : {
      73                 :             : public:
      74                 :             :     int i;
      75                 :           2 :     explicit NoCopyOrMove(int i) : i{i} { }
      76                 :             : 
      77                 :             :     NoCopyOrMove() = delete;
      78                 :             :     NoCopyOrMove(const NoCopyOrMove&) = delete;
      79                 :             :     NoCopyOrMove(NoCopyOrMove&&) = delete;
      80                 :             :     NoCopyOrMove& operator=(const NoCopyOrMove&) = delete;
      81                 :             :     NoCopyOrMove& operator=(NoCopyOrMove&&) = delete;
      82                 :             : 
      83         [ -  + ]:           6 :     operator bool() const { return i != 0; }
      84                 :             : 
      85                 :           2 :     int get_ip1() { return i + 1; }
      86                 :           4 :     bool test()
      87                 :             :     {
      88                 :             :         // Check that Assume can be used within a lambda and still call methods
      89                 :           4 :         [&]() { Assume(get_ip1()); }();
      90                 :           4 :         return Assume(get_ip1() != 5);
      91                 :             :     }
      92                 :             : };
      93                 :             : } // namespace
      94                 :             : 
      95   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(util_check)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
      96                 :             : {
      97                 :             :     // Check that Assert can forward
      98         [ +  - ]:           2 :     const std::unique_ptr<int> p_two = Assert(std::make_unique<int>(2));
      99                 :             :     // Check that Assert works on lvalues and rvalues
     100   [ +  -  +  - ]:           2 :     const int two = *Assert(p_two);
     101         [ +  - ]:           2 :     Assert(two == 2);
     102         [ +  - ]:           2 :     Assert(true);
     103                 :             :     // Check that Assume can be used as unary expression
     104                 :           2 :     const bool result{Assume(two == 2)};
     105         [ +  - ]:           2 :     Assert(result);
     106                 :             : 
     107                 :             :     // Check that Assert doesn't require copy/move
     108                 :           2 :     NoCopyOrMove x{9};
     109         [ +  - ]:           2 :     Assert(x).i += 3;
     110         [ +  - ]:           2 :     Assert(x).test();
     111                 :             : 
     112                 :             :     // Check nested Asserts
     113   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(Assert((Assert(x).test() ? 3 : 0)), 3);
          -  +  +  -  +  
                      - ]
     114                 :             : 
     115                 :             :     // Check -Wdangling-gsl does not trigger when copying the int. (It would
     116                 :             :     // trigger on "const int&")
     117                 :           2 :     const int nine{*Assert(std::optional<int>{9})};
     118   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(9, nine);
     119                 :           2 : }
     120                 :             : 
     121   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(util_criticalsection)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     122                 :             : {
     123                 :           2 :     RecursiveMutex cs;
     124                 :             : 
     125                 :           4 :     do {
     126                 :           2 :         LOCK(cs);
     127         [ +  - ]:           2 :         break;
     128                 :             : 
     129                 :             :         BOOST_ERROR("break was swallowed!");
     130                 :           2 :     } while(0);
     131                 :             : 
     132                 :           2 :     do {
     133                 :           2 :         TRY_LOCK(cs, lockTest);
     134         [ +  - ]:           2 :         if (lockTest) {
     135   [ +  -  +  -  :           4 :             BOOST_CHECK(true); // Needed to suppress "Test case [...] did not check any assertions"
                   +  - ]
     136         [ +  - ]:           2 :             break;
     137                 :             :         }
     138                 :             : 
     139   [ #  #  #  #  :           0 :         BOOST_ERROR("break was swallowed!");
                   #  # ]
     140                 :           2 :     } while(0);
     141                 :           2 : }
     142                 :             : 
     143                 :             : constexpr char HEX_PARSE_INPUT[] = "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f";
     144                 :             : constexpr uint8_t HEX_PARSE_OUTPUT[] = {
     145                 :             :     0x04, 0x67, 0x8a, 0xfd, 0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67, 0xf1, 0xa6, 0x71, 0x30, 0xb7,
     146                 :             :     0x10, 0x5c, 0xd6, 0xa8, 0x28, 0xe0, 0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, 0xea, 0x1f, 0x61, 0xde,
     147                 :             :     0xb6, 0x49, 0xf6, 0xbc, 0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04, 0xe5, 0x1e, 0xc1, 0x12,
     148                 :             :     0xde, 0x5c, 0x38, 0x4d, 0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, 0x2b, 0x6b, 0xf1, 0x1d,
     149                 :             :     0x5f
     150                 :             : };
     151                 :             : static_assert((sizeof(HEX_PARSE_INPUT) - 1) == 2 * sizeof(HEX_PARSE_OUTPUT));
     152   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(parse_hex)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     153                 :             : {
     154                 :           2 :     std::vector<unsigned char> result;
     155                 :             : 
     156                 :             :     // Basic test vector
     157         [ +  - ]:           2 :     std::vector<unsigned char> expected(std::begin(HEX_PARSE_OUTPUT), std::end(HEX_PARSE_OUTPUT));
     158                 :           2 :     constexpr std::array<std::byte, 65> hex_literal_array{operator""_hex<util::detail::Hex(HEX_PARSE_INPUT)>()};
     159         [ +  - ]:           2 :     auto hex_literal_span{MakeUCharSpan(hex_literal_array)};
     160   [ +  -  +  -  :           4 :     BOOST_CHECK_EQUAL_COLLECTIONS(hex_literal_span.begin(), hex_literal_span.end(), expected.begin(), expected.end());
             +  -  +  - ]
     161                 :             : 
     162         [ +  - ]:           2 :     const std::vector<std::byte> hex_literal_vector{operator""_hex_v<util::detail::Hex(HEX_PARSE_INPUT)>()};
     163                 :           2 :     auto hex_literal_vec_span = MakeUCharSpan(hex_literal_vector);
     164   [ +  -  +  -  :           4 :     BOOST_CHECK_EQUAL_COLLECTIONS(hex_literal_vec_span.begin(), hex_literal_vec_span.end(), expected.begin(), expected.end());
             +  -  +  - ]
     165                 :             : 
     166                 :           2 :     constexpr std::array<uint8_t, 65> hex_literal_array_uint8{operator""_hex_u8<util::detail::Hex(HEX_PARSE_INPUT)>()};
     167   [ +  -  +  -  :           4 :     BOOST_CHECK_EQUAL_COLLECTIONS(hex_literal_array_uint8.begin(), hex_literal_array_uint8.end(), expected.begin(), expected.end());
             +  -  +  - ]
     168                 :             : 
     169         [ +  - ]:           4 :     result = operator""_hex_v_u8<util::detail::Hex(HEX_PARSE_INPUT)>();
     170   [ +  -  +  -  :           4 :     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
             +  -  +  - ]
     171                 :             : 
     172         [ +  - ]:           4 :     result = ParseHex(HEX_PARSE_INPUT);
     173   [ +  -  +  -  :           4 :     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
             +  -  +  - ]
     174                 :             : 
     175         [ +  - ]:           4 :     result = TryParseHex<uint8_t>(HEX_PARSE_INPUT).value();
     176   [ +  -  +  -  :           4 :     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
             +  -  +  - ]
     177                 :             : 
     178                 :             :     // Spaces between bytes must be supported
     179         [ +  - ]:           2 :     expected = {0x12, 0x34, 0x56, 0x78};
     180         [ +  - ]:           4 :     result = ParseHex("12 34 56 78");
     181   [ +  -  +  -  :           4 :     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
             +  -  +  - ]
     182         [ +  - ]:           4 :     result = TryParseHex<uint8_t>("12 34 56 78").value();
     183   [ +  -  +  -  :           4 :     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
             +  -  +  - ]
     184                 :             : 
     185                 :             :     // Leading space must be supported (used in BerkeleyEnvironment::Salvage)
     186         [ +  - ]:           2 :     expected = {0x89, 0x34, 0x56, 0x78};
     187         [ +  - ]:           4 :     result = ParseHex(" 89 34 56 78");
     188   [ +  -  +  -  :           4 :     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
             +  -  +  - ]
     189         [ +  - ]:           4 :     result = TryParseHex<uint8_t>(" 89 34 56 78").value();
     190   [ +  -  +  -  :           4 :     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
             +  -  +  - ]
     191                 :             : 
     192                 :             :     // Mixed case and spaces are supported
     193         [ +  - ]:           2 :     expected = {0xff, 0xaa};
     194         [ +  - ]:           4 :     result = ParseHex("     Ff        aA    ");
     195   [ +  -  +  -  :           4 :     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
             +  -  +  - ]
     196         [ +  - ]:           4 :     result = TryParseHex<uint8_t>("     Ff        aA    ").value();
     197   [ +  -  +  -  :           4 :     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
             +  -  +  - ]
     198                 :             : 
     199                 :             :     // Empty string is supported
     200                 :           2 :     static_assert(""_hex.empty());
     201                 :           2 :     static_assert(""_hex_u8.empty());
     202   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(""_hex_v.size(), 0);
                   +  - ]
     203   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(""_hex_v_u8.size(), 0);
                   +  - ]
     204   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(ParseHex("").size(), 0);
                   +  - ]
     205   [ +  -  +  -  :           4 :     BOOST_CHECK_EQUAL(TryParseHex<uint8_t>("").value().size(), 0);
                   +  - ]
     206                 :             : 
     207                 :             :     // Spaces between nibbles is treated as invalid
     208   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(ParseHex("AAF F").size(), 0);
                   +  - ]
     209   [ +  -  +  -  :           4 :     BOOST_CHECK(!TryParseHex("AAF F").has_value());
             +  -  +  - ]
     210                 :             : 
     211                 :             :     // Embedded null is treated as invalid
     212         [ +  - ]:           2 :     const std::string with_embedded_null{" 11 "s
     213                 :             :                                          " \0 "
     214                 :           2 :                                          " 22 "s};
     215   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(with_embedded_null.size(), 11);
     216   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(ParseHex(with_embedded_null).size(), 0);
                   +  - ]
     217   [ +  -  +  -  :           4 :     BOOST_CHECK(!TryParseHex(with_embedded_null).has_value());
             +  -  +  - ]
     218                 :             : 
     219                 :             :     // Non-hex is treated as invalid
     220   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(ParseHex("1234 invalid 1234").size(), 0);
                   +  - ]
     221   [ +  -  +  -  :           4 :     BOOST_CHECK(!TryParseHex("1234 invalid 1234").has_value());
             +  -  +  - ]
     222                 :             : 
     223                 :             :     // Truncated input is treated as invalid
     224   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(ParseHex("12 3").size(), 0);
                   +  - ]
     225   [ +  -  +  -  :           4 :     BOOST_CHECK(!TryParseHex("12 3").has_value());
                   +  - ]
     226                 :           2 : }
     227                 :             : 
     228   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(consteval_hex_digit)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     229                 :             : {
     230         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(ConstevalHexDigit('0'), 0);
     231         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(ConstevalHexDigit('9'), 9);
     232         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(ConstevalHexDigit('a'), 0xa);
     233         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(ConstevalHexDigit('f'), 0xf);
     234                 :           2 : }
     235                 :             : 
     236   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(util_HexStr)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     237                 :             : {
     238         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(HexStr(HEX_PARSE_OUTPUT), HEX_PARSE_INPUT);
     239         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(HexStr(std::span{HEX_PARSE_OUTPUT}.last(0)), "");
     240         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(HexStr(std::span{HEX_PARSE_OUTPUT}.first(0)), "");
     241                 :             : 
     242                 :           2 :     {
     243                 :           2 :         constexpr std::string_view out_exp{"04678afdb0"};
     244                 :           2 :         constexpr std::span in_s{HEX_PARSE_OUTPUT, out_exp.size() / 2};
     245                 :           2 :         const std::span<const uint8_t> in_u{MakeUCharSpan(in_s)};
     246                 :           2 :         const std::span<const std::byte> in_b{MakeByteSpan(in_s)};
     247                 :             : 
     248         [ +  - ]:           2 :         BOOST_CHECK_EQUAL(HexStr(in_u), out_exp);
     249         [ +  - ]:           2 :         BOOST_CHECK_EQUAL(HexStr(in_s), out_exp);
     250         [ +  - ]:           2 :         BOOST_CHECK_EQUAL(HexStr(in_b), out_exp);
     251                 :             :     }
     252                 :             : 
     253                 :           2 :     {
     254                 :           2 :         auto input = std::string();
     255         [ +  + ]:         514 :         for (size_t i=0; i<256; ++i) {
     256         [ +  - ]:         512 :             input.push_back(static_cast<char>(i));
     257                 :             :         }
     258                 :             : 
     259         [ +  - ]:           2 :         auto hex = HexStr(input);
     260   [ +  -  +  -  :           4 :         BOOST_TEST_REQUIRE(hex.size() == 512);
                   +  - ]
     261                 :           2 :         static constexpr auto hexmap = std::string_view("0123456789abcdef");
     262         [ +  + ]:         514 :         for (size_t i = 0; i < 256; ++i) {
     263         [ +  - ]:         512 :             auto upper = hexmap.find(hex[i * 2]);
     264         [ +  - ]:         512 :             auto lower = hexmap.find(hex[i * 2 + 1]);
     265   [ +  -  +  -  :        1024 :             BOOST_TEST_REQUIRE(upper != std::string_view::npos);
             +  -  +  - ]
     266   [ +  -  +  -  :        1024 :             BOOST_TEST_REQUIRE(lower != std::string_view::npos);
             +  -  +  - ]
     267   [ +  -  +  -  :        1024 :             BOOST_TEST_REQUIRE(i == upper*16 + lower);
                   +  - ]
     268                 :             :         }
     269                 :           2 :     }
     270                 :           2 : }
     271                 :             : 
     272   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(span_write_bytes)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     273                 :             : {
     274                 :           2 :     std::array mut_arr{uint8_t{0xaa}, uint8_t{0xbb}};
     275                 :           2 :     const auto mut_bytes{MakeWritableByteSpan(mut_arr)};
     276                 :           2 :     mut_bytes[1] = std::byte{0x11};
     277         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(mut_arr.at(0), 0xaa);
     278         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(mut_arr.at(1), 0x11);
     279                 :           2 : }
     280                 :             : 
     281   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(util_Join)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     282                 :             : {
     283                 :             :     // Normal version
     284   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(Join(std::vector<std::string>{}, ", "), "");
     285   [ +  -  +  -  :           6 :     BOOST_CHECK_EQUAL(Join(std::vector<std::string>{"foo"}, ", "), "foo");
          +  -  +  +  -  
                      - ]
     286   [ +  -  +  -  :           8 :     BOOST_CHECK_EQUAL(Join(std::vector<std::string>{"foo", "bar"}, ", "), "foo, bar");
          +  -  +  +  -  
                      - ]
     287                 :             : 
     288                 :             :     // Version with unary operator
     289                 :           8 :     const auto op_upper = [](const std::string& s) { return ToUpper(s); };
     290   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(Join(std::list<std::string>{}, ", ", op_upper), "");
     291   [ +  -  +  -  :           6 :     BOOST_CHECK_EQUAL(Join(std::list<std::string>{"foo"}, ", ", op_upper), "FOO");
          +  -  +  +  -  
                      - ]
     292   [ +  -  +  -  :           8 :     BOOST_CHECK_EQUAL(Join(std::list<std::string>{"foo", "bar"}, ", ", op_upper), "FOO, BAR");
          +  -  +  +  -  
                      - ]
     293   [ +  -  +  -  :          10 : }
          +  -  +  -  -  
                -  -  - ]
     294                 :             : 
     295   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(util_ReplaceAll)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     296                 :             : {
     297                 :           2 :     const std::string original("A test \"%s\" string '%s'.");
     298                 :          12 :     auto test_replaceall = [&original](const std::string& search, const std::string& substitute, const std::string& expected) {
     299                 :          10 :         auto test = original;
     300         [ +  - ]:          10 :         ReplaceAll(test, search, substitute);
     301   [ +  -  +  - ]:          10 :         BOOST_CHECK_EQUAL(test, expected);
     302                 :          12 :     };
     303                 :             : 
     304   [ +  -  +  -  :           4 :     test_replaceall("", "foo", original);
                   +  - ]
     305   [ +  -  +  -  :           4 :     test_replaceall(original, "foo", "foo");
                   +  - ]
     306   [ +  -  +  -  :           4 :     test_replaceall("%s", "foo", "A test \"foo\" string 'foo'.");
             +  -  +  - ]
     307   [ +  -  +  -  :           4 :     test_replaceall("\"", "foo", "A test foo%sfoo string '%s'.");
             +  -  +  - ]
     308   [ +  -  +  -  :           4 :     test_replaceall("'", "foo", "A test \"%s\" string foo%sfoo.");
             +  -  +  - ]
     309                 :           2 : }
     310                 :             : 
     311   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(util_TrimString)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     312                 :             : {
     313         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(TrimString(" foo bar "), "foo bar");
     314         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(TrimStringView("\t \n  \n \f\n\r\t\v\tfoo \n \f\n\r\t\v\tbar\t  \n \f\n\r\t\v\t\n "), "foo \n \f\n\r\t\v\tbar");
     315         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(TrimString("\t \n foo \n\tbar\t \n "), "foo \n\tbar");
     316         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(TrimStringView("\t \n foo \n\tbar\t \n ", "fobar"), "\t \n foo \n\tbar\t \n ");
     317         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(TrimString("foo bar"), "foo bar");
     318         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(TrimStringView("foo bar", "fobar"), " ");
     319   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(TrimString(std::string("\0 foo \0 ", 8)), std::string("\0 foo \0", 7));
                   +  - ]
     320   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(TrimStringView(std::string(" foo ", 5)), std::string("foo", 3));
                   +  - ]
     321   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(TrimString(std::string("\t\t\0\0\n\n", 6)), std::string("\0\0", 2));
                   +  - ]
     322   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(TrimStringView(std::string("\x05\x04\x03\x02\x01\x00", 6)), std::string("\x05\x04\x03\x02\x01\x00", 6));
                   +  - ]
     323   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(TrimString(std::string("\x05\x04\x03\x02\x01\x00", 6), std::string("\x05\x04\x03\x02\x01", 5)), std::string("\0", 1));
             +  -  +  - ]
     324   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(TrimStringView(std::string("\x05\x04\x03\x02\x01\x00", 6), std::string("\x05\x04\x03\x02\x01\x00", 6)), "");
                   +  - ]
     325                 :           2 : }
     326                 :             : 
     327   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(util_ParseISO8601DateTime)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     328                 :             : {
     329   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ParseISO8601DateTime("1969-12-31T23:59:59Z").value(), -1);
     330   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ParseISO8601DateTime("1970-01-01T00:00:00Z").value(), 0);
     331   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ParseISO8601DateTime("1970-01-01T00:00:01Z").value(), 1);
     332   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ParseISO8601DateTime("2000-01-01T00:00:01Z").value(), 946684801);
     333   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ParseISO8601DateTime("2011-09-30T23:36:17Z").value(), 1317425777);
     334   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ParseISO8601DateTime("2100-12-31T23:59:59Z").value(), 4133980799);
     335   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ParseISO8601DateTime("9999-12-31T23:59:59Z").value(), 253402300799);
     336                 :             : 
     337                 :             :     // Accept edge-cases, where the time overflows. They are not produced by
     338                 :             :     // FormatISO8601DateTime, so this can be changed in the future, if needed.
     339                 :             :     // For now, keep compatibility with the previous implementation.
     340   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ParseISO8601DateTime("2000-01-01T99:00:00Z").value(), 947041200);
     341   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ParseISO8601DateTime("2000-01-01T00:99:00Z").value(), 946690740);
     342   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ParseISO8601DateTime("2000-01-01T00:00:99Z").value(), 946684899);
     343   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ParseISO8601DateTime("2000-01-01T99:99:99Z").value(), 947047239);
     344                 :             : 
     345                 :             :     // Reject date overflows.
     346   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseISO8601DateTime("2000-99-01T00:00:00Z"));
     347   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseISO8601DateTime("2000-01-99T00:00:00Z"));
     348                 :             : 
     349                 :             :     // Reject out-of-range years
     350   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseISO8601DateTime("32768-12-31T23:59:59Z"));
     351   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseISO8601DateTime("32767-12-31T23:59:59Z"));
     352   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseISO8601DateTime("32767-12-31T00:00:00Z"));
     353   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseISO8601DateTime("999-12-31T00:00:00Z"));
     354                 :             : 
     355                 :             :     // Reject invalid format
     356                 :           2 :     const std::string valid{"2000-01-01T00:00:01Z"};
     357   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseISO8601DateTime(valid).has_value());
                   +  - ]
     358         [ +  + ]:          42 :     for (auto mut{0U}; mut < valid.size(); ++mut) {
     359         [ +  - ]:          40 :         std::string invalid{valid};
     360         [ +  - ]:          40 :         invalid[mut] = 'a';
     361   [ +  -  +  -  :          80 :         BOOST_CHECK(!ParseISO8601DateTime(invalid));
                   +  - ]
     362                 :          40 :     }
     363                 :           2 : }
     364                 :             : 
     365   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(util_FormatISO8601DateTime)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     366                 :             : {
     367         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatISO8601DateTime(971890963199), "32767-12-31T23:59:59Z");
     368         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatISO8601DateTime(971890876800), "32767-12-31T00:00:00Z");
     369                 :             : 
     370         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatISO8601DateTime(-1), "1969-12-31T23:59:59Z");
     371         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatISO8601DateTime(0), "1970-01-01T00:00:00Z");
     372         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatISO8601DateTime(1), "1970-01-01T00:00:01Z");
     373         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatISO8601DateTime(946684801), "2000-01-01T00:00:01Z");
     374         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatISO8601DateTime(1317425777), "2011-09-30T23:36:17Z");
     375         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatISO8601DateTime(4133980799), "2100-12-31T23:59:59Z");
     376         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatISO8601DateTime(253402300799), "9999-12-31T23:59:59Z");
     377                 :           2 : }
     378                 :             : 
     379   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(util_FormatISO8601Date)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     380                 :             : {
     381         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatISO8601Date(971890963199), "32767-12-31");
     382         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatISO8601Date(971890876800), "32767-12-31");
     383                 :             : 
     384         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatISO8601Date(0), "1970-01-01");
     385         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatISO8601Date(1317425777), "2011-09-30");
     386                 :           2 : }
     387                 :             : 
     388   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(util_FormatMoney)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     389                 :             : {
     390         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(0), "0.00");
     391         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney((COIN/10000)*123456789), "12345.6789");
     392         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(-COIN), "-1.00");
     393                 :             : 
     394         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(COIN*100000000), "100000000.00");
     395         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(COIN*10000000), "10000000.00");
     396         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(COIN*1000000), "1000000.00");
     397         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(COIN*100000), "100000.00");
     398         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(COIN*10000), "10000.00");
     399         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(COIN*1000), "1000.00");
     400         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(COIN*100), "100.00");
     401         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(COIN*10), "10.00");
     402         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(COIN), "1.00");
     403         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(COIN/10), "0.10");
     404         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(COIN/100), "0.01");
     405         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(COIN/1000), "0.001");
     406         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(COIN/10000), "0.0001");
     407         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(COIN/100000), "0.00001");
     408         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(COIN/1000000), "0.000001");
     409         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(COIN/10000000), "0.0000001");
     410         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(COIN/100000000), "0.00000001");
     411                 :             : 
     412         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(std::numeric_limits<CAmount>::max()), "92233720368.54775807");
     413         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(std::numeric_limits<CAmount>::max() - 1), "92233720368.54775806");
     414         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(std::numeric_limits<CAmount>::max() - 2), "92233720368.54775805");
     415         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(std::numeric_limits<CAmount>::max() - 3), "92233720368.54775804");
     416                 :             :     // ...
     417         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(std::numeric_limits<CAmount>::min() + 3), "-92233720368.54775805");
     418         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(std::numeric_limits<CAmount>::min() + 2), "-92233720368.54775806");
     419         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(std::numeric_limits<CAmount>::min() + 1), "-92233720368.54775807");
     420         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatMoney(std::numeric_limits<CAmount>::min()), "-92233720368.54775808");
     421                 :           2 : }
     422                 :             : 
     423   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(util_ParseMoney)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     424                 :             : {
     425   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("0.0").value(), 0);
     426   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney(".").value(), 0);
     427   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("0.").value(), 0);
     428   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney(".0").value(), 0);
     429   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney(".6789").value(), 6789'0000);
     430   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("12345.").value(), COIN * 12345);
     431                 :             : 
     432   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("12345.6789").value(), (COIN/10000)*123456789);
     433                 :             : 
     434   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("10000000.00").value(), COIN*10000000);
     435   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("1000000.00").value(), COIN*1000000);
     436   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("100000.00").value(), COIN*100000);
     437   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("10000.00").value(), COIN*10000);
     438   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("1000.00").value(), COIN*1000);
     439   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("100.00").value(), COIN*100);
     440   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("10.00").value(), COIN*10);
     441   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("1.00").value(), COIN);
     442   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("1").value(), COIN);
     443   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("   1").value(), COIN);
     444   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("1   ").value(), COIN);
     445   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("  1 ").value(), COIN);
     446   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("0.1").value(), COIN/10);
     447   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("0.01").value(), COIN/100);
     448   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("0.001").value(), COIN/1000);
     449   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("0.0001").value(), COIN/10000);
     450   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("0.00001").value(), COIN/100000);
     451   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("0.000001").value(), COIN/1000000);
     452   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("0.0000001").value(), COIN/10000000);
     453   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("0.00000001").value(), COIN/100000000);
     454   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney(" 0.00000001 ").value(), COIN/100000000);
     455   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney("0.00000001 ").value(), COIN/100000000);
     456   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(ParseMoney(" 0.00000001").value(), COIN/100000000);
     457                 :             : 
     458                 :             :     // Parsing amount that cannot be represented should fail
     459   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney("100000000.00"));
                   +  - ]
     460   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney("0.000000001"));
                   +  - ]
     461                 :             : 
     462                 :             :     // Parsing empty string should fail
     463   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney(""));
                   +  - ]
     464   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney(" "));
                   +  - ]
     465   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney("  "));
                   +  - ]
     466                 :             : 
     467                 :             :     // Parsing two numbers should fail
     468   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney(".."));
                   +  - ]
     469   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney("0..0"));
                   +  - ]
     470   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney("1 2"));
                   +  - ]
     471   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney(" 1 2 "));
                   +  - ]
     472   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney(" 1.2 3 "));
                   +  - ]
     473   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney(" 1 2.3 "));
                   +  - ]
     474                 :             : 
     475                 :             :     // Embedded whitespace should fail
     476   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney(" -1 .2  "));
                   +  - ]
     477   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney("  1 .2  "));
                   +  - ]
     478   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney(" +1 .2  "));
                   +  - ]
     479                 :             : 
     480                 :             :     // Attempted 63 bit overflow should fail
     481   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney("92233720368.54775808"));
                   +  - ]
     482                 :             : 
     483                 :             :     // Parsing negative amounts must fail
     484   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney("-1"));
                   +  - ]
     485                 :             : 
     486                 :             :     // Parsing strings with embedded NUL characters should fail
     487   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney("\0-1"s));
                   +  - ]
     488   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseMoney(STRING_WITH_EMBEDDED_NULL_CHAR));
     489   [ +  -  +  -  :           4 :     BOOST_CHECK(!ParseMoney("1\0"s));
                   +  - ]
     490                 :           2 : }
     491                 :             : 
     492   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(util_IsHex)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     493                 :             : {
     494   [ +  -  +  - ]:           4 :     BOOST_CHECK(IsHex("00"));
     495   [ +  -  +  - ]:           4 :     BOOST_CHECK(IsHex("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
     496   [ +  -  +  - ]:           4 :     BOOST_CHECK(IsHex("ff"));
     497   [ +  -  +  - ]:           4 :     BOOST_CHECK(IsHex("FF"));
     498                 :             : 
     499   [ +  -  +  - ]:           4 :     BOOST_CHECK(!IsHex(""));
     500   [ +  -  +  - ]:           4 :     BOOST_CHECK(!IsHex("0"));
     501   [ +  -  +  - ]:           4 :     BOOST_CHECK(!IsHex("a"));
     502   [ +  -  +  - ]:           4 :     BOOST_CHECK(!IsHex("eleven"));
     503   [ +  -  +  - ]:           4 :     BOOST_CHECK(!IsHex("00xx00"));
     504   [ +  -  +  - ]:           4 :     BOOST_CHECK(!IsHex("0x0000"));
     505                 :           2 : }
     506                 :             : 
     507   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(util_seed_insecure_rand)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     508                 :             : {
     509                 :           2 :     SeedRandomForTest(SeedRand::ZEROS);
     510         [ +  + ]:          20 :     for (int mod=2;mod<11;mod++)
     511                 :             :     {
     512                 :          18 :         int mask = 1;
     513                 :             :         // Really rough binomial confidence approximation.
     514                 :          18 :         int err = 30*10000./mod*sqrt((1./mod*(1-1./mod))/10000.);
     515                 :             :         //mask is 2^ceil(log2(mod))-1
     516         [ +  + ]:          50 :         while(mask<mod-1)mask=(mask<<1)+1;
     517                 :             : 
     518                 :             :         int count = 0;
     519                 :             :         //How often does it get a zero from the uniform range [0,mod)?
     520         [ +  + ]:      180018 :         for (int i = 0; i < 10000; i++) {
     521                 :      235594 :             uint32_t rval;
     522                 :      235594 :             do{
     523                 :      235594 :                 rval=m_rng.rand32()&mask;
     524         [ +  + ]:      235594 :             }while(rval>=(uint32_t)mod);
     525                 :      180000 :             count += rval==0;
     526                 :             :         }
     527         [ +  - ]:          36 :         BOOST_CHECK(count<=10000/mod+err);
     528         [ +  - ]:          36 :         BOOST_CHECK(count>=10000/mod-err);
     529                 :             :     }
     530                 :           2 : }
     531                 :             : 
     532   [ +  -  +  -  :          24 : BOOST_AUTO_TEST_CASE(util_TimingResistantEqual)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     533                 :             : {
     534   [ +  -  +  -  :           4 :     BOOST_CHECK(TimingResistantEqual(std::string(""), std::string("")));
                   +  - ]
     535   [ +  -  +  -  :           4 :     BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("")));
                   +  - ]
     536   [ +  -  +  -  :           4 :     BOOST_CHECK(!TimingResistantEqual(std::string(""), std::string("abc")));
                   +  - ]
     537   [ +  -  +  -  :           4 :     BOOST_CHECK(!TimingResistantEqual(std::string("a"), std::string("aa")));
                   +  - ]
     538   [ +  -  +  -  :           4 :     BOOST_CHECK(!TimingResistantEqual(std::string("aa"), std::string("a")));
                   +  - ]
     539   [ +  -  +  -  :           4 :     BOOST_CHECK(TimingResistantEqual(std::string("abc"), std::string("abc")));
                   +  - ]
     540   [ +  -  +  -  :           4 :     BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("aba")));
                   +  - ]
     541                 :           2 : }
     542                 :             : 
     543                 :             : /* Test strprintf formatting directives.
     544                 :             :  * Put a string before and after to ensure sanity of element sizes on stack. */
     545                 :             : #define B "check_prefix"
     546                 :             : #define E "check_postfix"
     547   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(strprintf_numbers)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     548                 :             : {
     549                 :           2 :     int64_t s64t = -9223372036854775807LL; /* signed 64 bit test value */
     550                 :           2 :     uint64_t u64t = 18446744073709551615ULL; /* unsigned 64 bit test value */
     551   [ +  -  +  - ]:           4 :     BOOST_CHECK(strprintf("%s %d %s", B, s64t, E) == B" -9223372036854775807 " E);
     552   [ +  -  +  - ]:           4 :     BOOST_CHECK(strprintf("%s %u %s", B, u64t, E) == B" 18446744073709551615 " E);
     553   [ +  -  +  - ]:           4 :     BOOST_CHECK(strprintf("%s %x %s", B, u64t, E) == B" ffffffffffffffff " E);
     554                 :             : 
     555                 :           2 :     size_t st = 12345678; /* unsigned size_t test value */
     556                 :           2 :     ssize_t sst = -12345678; /* signed size_t test value */
     557   [ +  -  +  - ]:           4 :     BOOST_CHECK(strprintf("%s %d %s", B, sst, E) == B" -12345678 " E);
     558   [ +  -  +  - ]:           4 :     BOOST_CHECK(strprintf("%s %u %s", B, st, E) == B" 12345678 " E);
     559   [ +  -  +  - ]:           4 :     BOOST_CHECK(strprintf("%s %x %s", B, st, E) == B" bc614e " E);
     560                 :             : 
     561                 :           2 :     ptrdiff_t pt = 87654321; /* positive ptrdiff_t test value */
     562                 :           2 :     ptrdiff_t spt = -87654321; /* negative ptrdiff_t test value */
     563   [ +  -  +  - ]:           4 :     BOOST_CHECK(strprintf("%s %d %s", B, spt, E) == B" -87654321 " E);
     564   [ +  -  +  - ]:           4 :     BOOST_CHECK(strprintf("%s %u %s", B, pt, E) == B" 87654321 " E);
     565   [ +  -  +  - ]:           4 :     BOOST_CHECK(strprintf("%s %x %s", B, pt, E) == B" 5397fb1 " E);
     566                 :           2 : }
     567                 :             : #undef B
     568                 :             : #undef E
     569                 :             : 
     570   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(util_mocktime)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     571                 :             : {
     572                 :           2 :     SetMockTime(111s);
     573                 :             :     // Check that mock time does not change after a sleep
     574         [ +  + ]:           6 :     for (const auto& num_sleep : {0ms, 1ms}) {
     575                 :           4 :         UninterruptibleSleep(num_sleep);
     576         [ +  - ]:           4 :         BOOST_CHECK_EQUAL(111, GetTime()); // Deprecated time getter
     577         [ +  - ]:           4 :         BOOST_CHECK_EQUAL(111, Now<NodeSeconds>().time_since_epoch().count());
     578         [ +  - ]:           4 :         BOOST_CHECK_EQUAL(111, TicksSinceEpoch<std::chrono::seconds>(NodeClock::now()));
     579         [ +  - ]:           4 :         BOOST_CHECK_EQUAL(111, TicksSinceEpoch<SecondsDouble>(Now<NodeSeconds>()));
     580         [ +  - ]:           4 :         BOOST_CHECK_EQUAL(111, GetTime<std::chrono::seconds>().count());
     581         [ +  - ]:           4 :         BOOST_CHECK_EQUAL(111000, GetTime<std::chrono::milliseconds>().count());
     582         [ +  - ]:           4 :         BOOST_CHECK_EQUAL(111000, TicksSinceEpoch<std::chrono::milliseconds>(NodeClock::now()));
     583         [ +  - ]:           4 :         BOOST_CHECK_EQUAL(111000000, GetTime<std::chrono::microseconds>().count());
     584                 :             :     }
     585                 :           2 :     SetMockTime(0s);
     586                 :           2 : }
     587                 :             : 
     588   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(test_IsDigit)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     589                 :             : {
     590         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(IsDigit('0'), true);
     591         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(IsDigit('1'), true);
     592         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(IsDigit('8'), true);
     593         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(IsDigit('9'), true);
     594                 :             : 
     595         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(IsDigit('0' - 1), false);
     596         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(IsDigit('9' + 1), false);
     597         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(IsDigit(0), false);
     598         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(IsDigit(1), false);
     599         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(IsDigit(8), false);
     600         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(IsDigit(9), false);
     601                 :           2 : }
     602                 :             : 
     603                 :             : /* Check for overflow */
     604                 :             : template <typename T>
     605                 :           4 : static void TestAddMatrixOverflow()
     606                 :             : {
     607                 :           4 :     constexpr T MAXI{std::numeric_limits<T>::max()};
     608         [ +  - ]:           8 :     BOOST_CHECK(!CheckedAdd(T{1}, MAXI));
     609         [ +  - ]:           8 :     BOOST_CHECK(!CheckedAdd(MAXI, MAXI));
     610         [ +  - ]:           4 :     BOOST_CHECK_EQUAL(MAXI, SaturatingAdd(T{1}, MAXI));
     611         [ +  - ]:           4 :     BOOST_CHECK_EQUAL(MAXI, SaturatingAdd(MAXI, MAXI));
     612                 :             : 
     613   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(0, CheckedAdd(T{0}, T{0}).value());
     614   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(MAXI, CheckedAdd(T{0}, MAXI).value());
     615   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(MAXI, CheckedAdd(T{1}, MAXI - 1).value());
     616   [ +  -  +  - ]:           4 :     BOOST_CHECK_EQUAL(MAXI - 1, CheckedAdd(T{1}, MAXI - 2).value());
     617         [ +  - ]:           4 :     BOOST_CHECK_EQUAL(0, SaturatingAdd(T{0}, T{0}));
     618         [ +  - ]:           4 :     BOOST_CHECK_EQUAL(MAXI, SaturatingAdd(T{0}, MAXI));
     619         [ +  - ]:           4 :     BOOST_CHECK_EQUAL(MAXI, SaturatingAdd(T{1}, MAXI - 1));
     620         [ +  - ]:           4 :     BOOST_CHECK_EQUAL(MAXI - 1, SaturatingAdd(T{1}, MAXI - 2));
     621                 :           4 : }
     622                 :             : 
     623                 :             : /* Check for overflow or underflow */
     624                 :             : template <typename T>
     625                 :           2 : static void TestAddMatrix()
     626                 :             : {
     627                 :           2 :     TestAddMatrixOverflow<T>();
     628                 :           2 :     constexpr T MINI{std::numeric_limits<T>::min()};
     629                 :           2 :     constexpr T MAXI{std::numeric_limits<T>::max()};
     630         [ +  - ]:           4 :     BOOST_CHECK(!CheckedAdd(T{-1}, MINI));
     631         [ +  - ]:           4 :     BOOST_CHECK(!CheckedAdd(MINI, MINI));
     632         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(MINI, SaturatingAdd(T{-1}, MINI));
     633         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(MINI, SaturatingAdd(MINI, MINI));
     634                 :             : 
     635   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(MINI, CheckedAdd(T{0}, MINI).value());
     636   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(MINI, CheckedAdd(T{-1}, MINI + 1).value());
     637   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(-1, CheckedAdd(MINI, MAXI).value());
     638   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(MINI + 1, CheckedAdd(T{-1}, MINI + 2).value());
     639         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(MINI, SaturatingAdd(T{0}, MINI));
     640         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(MINI, SaturatingAdd(T{-1}, MINI + 1));
     641         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(MINI + 1, SaturatingAdd(T{-1}, MINI + 2));
     642         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(-1, SaturatingAdd(MINI, MAXI));
     643                 :           2 : }
     644                 :             : 
     645   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(util_overflow)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     646                 :             : {
     647                 :           2 :     TestAddMatrixOverflow<unsigned>();
     648                 :           2 :     TestAddMatrix<signed>();
     649                 :           2 : }
     650                 :             : 
     651   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(test_ParseInt32)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     652                 :             : {
     653                 :           2 :     int32_t n;
     654                 :             :     // Valid values
     655   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseInt32("1234", nullptr));
     656   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt32("0", &n) && n == 0);
             -  +  +  - ]
     657   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt32("1234", &n) && n == 1234);
             -  +  +  - ]
     658   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt32("01234", &n) && n == 1234); // no octal
             -  +  +  - ]
     659   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt32("2147483647", &n) && n == 2147483647);
             -  +  +  - ]
     660   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt32("-2147483648", &n) && n == (-2147483647 - 1)); // (-2147483647 - 1) equals INT_MIN
             -  +  +  - ]
     661   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt32("-1234", &n) && n == -1234);
             -  +  +  - ]
     662   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt32("00000000000000001234", &n) && n == 1234);
             -  +  +  - ]
     663   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt32("-00000000000000001234", &n) && n == -1234);
             -  +  +  - ]
     664   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt32("00000000000000000000", &n) && n == 0);
             -  +  +  - ]
     665   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt32("-00000000000000000000", &n) && n == 0);
             -  +  +  - ]
     666                 :             :     // Invalid values
     667   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt32("", &n));
     668   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt32(" 1", &n)); // no padding inside
     669   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt32("1 ", &n));
     670   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt32("++1", &n));
     671   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt32("+-1", &n));
     672   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt32("-+1", &n));
     673   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt32("--1", &n));
     674   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt32("1a", &n));
     675   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt32("aap", &n));
     676   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt32("0x1", &n)); // no hex
     677   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt32(STRING_WITH_EMBEDDED_NULL_CHAR, &n));
     678                 :             :     // Overflow and underflow
     679   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt32("-2147483649", nullptr));
     680   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt32("2147483648", nullptr));
     681   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt32("-32482348723847471234", nullptr));
     682   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt32("32482348723847471234", nullptr));
     683                 :           2 : }
     684                 :             : 
     685                 :             : template <typename T>
     686                 :          16 : static void RunToIntegralTests()
     687                 :             : {
     688         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>(STRING_WITH_EMBEDDED_NULL_CHAR));
     689         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>(" 1"));
     690         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>("1 "));
     691         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>("1a"));
     692         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>("1.1"));
     693         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>("1.9"));
     694         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>("+01.9"));
     695         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>("-"));
     696         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>("+"));
     697         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>(" -1"));
     698         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>("-1 "));
     699         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>(" -1 "));
     700         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>("+1"));
     701         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>(" +1"));
     702         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>(" +1 "));
     703         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>("+-1"));
     704         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>("-+1"));
     705         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>("++1"));
     706         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>("--1"));
     707         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>(""));
     708         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>("aap"));
     709         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>("0x1"));
     710         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>("-32482348723847471234"));
     711         [ +  - ]:          32 :     BOOST_CHECK(!ToIntegral<T>("32482348723847471234"));
     712                 :          16 : }
     713                 :             : 
     714   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(test_ToIntegral)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     715                 :             : {
     716   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<int32_t>("1234").value(), 1'234);
     717   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<int32_t>("0").value(), 0);
     718   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<int32_t>("01234").value(), 1'234);
     719   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<int32_t>("00000000000000001234").value(), 1'234);
     720   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<int32_t>("-00000000000000001234").value(), -1'234);
     721   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<int32_t>("00000000000000000000").value(), 0);
     722   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<int32_t>("-00000000000000000000").value(), 0);
     723   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<int32_t>("-1234").value(), -1'234);
     724   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<int32_t>("-1").value(), -1);
     725                 :             : 
     726                 :           2 :     RunToIntegralTests<uint64_t>();
     727                 :           2 :     RunToIntegralTests<int64_t>();
     728                 :           2 :     RunToIntegralTests<uint32_t>();
     729                 :           2 :     RunToIntegralTests<int32_t>();
     730                 :           2 :     RunToIntegralTests<uint16_t>();
     731                 :           2 :     RunToIntegralTests<int16_t>();
     732                 :           2 :     RunToIntegralTests<uint8_t>();
     733                 :           2 :     RunToIntegralTests<int8_t>();
     734                 :             : 
     735         [ +  - ]:           4 :     BOOST_CHECK(!ToIntegral<int64_t>("-9223372036854775809"));
     736   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<int64_t>("-9223372036854775808").value(), -9'223'372'036'854'775'807LL - 1LL);
     737   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<int64_t>("9223372036854775807").value(), 9'223'372'036'854'775'807);
     738         [ +  - ]:           4 :     BOOST_CHECK(!ToIntegral<int64_t>("9223372036854775808"));
     739                 :             : 
     740         [ +  - ]:           4 :     BOOST_CHECK(!ToIntegral<uint64_t>("-1"));
     741   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<uint64_t>("0").value(), 0U);
     742   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<uint64_t>("18446744073709551615").value(), 18'446'744'073'709'551'615ULL);
     743         [ +  - ]:           4 :     BOOST_CHECK(!ToIntegral<uint64_t>("18446744073709551616"));
     744                 :             : 
     745         [ +  - ]:           4 :     BOOST_CHECK(!ToIntegral<int32_t>("-2147483649"));
     746   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<int32_t>("-2147483648").value(), -2'147'483'648LL);
     747   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<int32_t>("2147483647").value(), 2'147'483'647);
     748         [ +  - ]:           4 :     BOOST_CHECK(!ToIntegral<int32_t>("2147483648"));
     749                 :             : 
     750         [ +  - ]:           4 :     BOOST_CHECK(!ToIntegral<uint32_t>("-1"));
     751   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<uint32_t>("0").value(), 0U);
     752   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<uint32_t>("4294967295").value(), 4'294'967'295U);
     753         [ +  - ]:           4 :     BOOST_CHECK(!ToIntegral<uint32_t>("4294967296"));
     754                 :             : 
     755         [ +  - ]:           4 :     BOOST_CHECK(!ToIntegral<int16_t>("-32769"));
     756   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<int16_t>("-32768").value(), -32'768);
     757   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<int16_t>("32767").value(), 32'767);
     758         [ +  - ]:           4 :     BOOST_CHECK(!ToIntegral<int16_t>("32768"));
     759                 :             : 
     760         [ +  - ]:           4 :     BOOST_CHECK(!ToIntegral<uint16_t>("-1"));
     761   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<uint16_t>("0").value(), 0U);
     762   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<uint16_t>("65535").value(), 65'535U);
     763         [ +  - ]:           4 :     BOOST_CHECK(!ToIntegral<uint16_t>("65536"));
     764                 :             : 
     765         [ +  - ]:           4 :     BOOST_CHECK(!ToIntegral<int8_t>("-129"));
     766   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<int8_t>("-128").value(), -128);
     767   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<int8_t>("127").value(), 127);
     768         [ +  - ]:           4 :     BOOST_CHECK(!ToIntegral<int8_t>("128"));
     769                 :             : 
     770         [ +  - ]:           4 :     BOOST_CHECK(!ToIntegral<uint8_t>("-1"));
     771   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<uint8_t>("0").value(), 0U);
     772   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(ToIntegral<uint8_t>("255").value(), 255U);
     773         [ +  - ]:           4 :     BOOST_CHECK(!ToIntegral<uint8_t>("256"));
     774                 :           2 : }
     775                 :             : 
     776                 :          16 : int64_t atoi64_legacy(const std::string& str)
     777                 :             : {
     778                 :          16 :     return strtoll(str.c_str(), nullptr, 10);
     779                 :             : }
     780                 :             : 
     781   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(test_LocaleIndependentAtoi)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     782                 :             : {
     783         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("1234"), 1'234);
     784         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("0"), 0);
     785         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("01234"), 1'234);
     786         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("-1234"), -1'234);
     787         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>(" 1"), 1);
     788         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("1 "), 1);
     789         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("1a"), 1);
     790         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("1.1"), 1);
     791         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("1.9"), 1);
     792         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("+01.9"), 1);
     793         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("-1"), -1);
     794         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>(" -1"), -1);
     795         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("-1 "), -1);
     796         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>(" -1 "), -1);
     797         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("+1"), 1);
     798         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>(" +1"), 1);
     799         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>(" +1 "), 1);
     800                 :             : 
     801         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("+-1"), 0);
     802         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("-+1"), 0);
     803         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("++1"), 0);
     804         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("--1"), 0);
     805         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>(""), 0);
     806         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("aap"), 0);
     807         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("0x1"), 0);
     808         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("-32482348723847471234"), -2'147'483'647 - 1);
     809         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("32482348723847471234"), 2'147'483'647);
     810                 :             : 
     811         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int64_t>("-9223372036854775809"), -9'223'372'036'854'775'807LL - 1LL);
     812         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int64_t>("-9223372036854775808"), -9'223'372'036'854'775'807LL - 1LL);
     813         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int64_t>("9223372036854775807"), 9'223'372'036'854'775'807);
     814         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int64_t>("9223372036854775808"), 9'223'372'036'854'775'807);
     815                 :             : 
     816                 :           2 :     std::map<std::string, int64_t> atoi64_test_pairs = {
     817         [ +  - ]:           2 :         {"-9223372036854775809", std::numeric_limits<int64_t>::min()},
     818                 :           2 :         {"-9223372036854775808", -9'223'372'036'854'775'807LL - 1LL},
     819                 :           2 :         {"9223372036854775807", 9'223'372'036'854'775'807},
     820                 :           2 :         {"9223372036854775808", std::numeric_limits<int64_t>::max()},
     821                 :           2 :         {"+-", 0},
     822                 :           2 :         {"0x1", 0},
     823                 :           2 :         {"ox1", 0},
     824                 :           2 :         {"", 0},
     825   [ +  +  -  - ]:          18 :     };
     826                 :             : 
     827         [ +  + ]:          18 :     for (const auto& pair : atoi64_test_pairs) {
     828   [ +  -  +  -  :          16 :         BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int64_t>(pair.first), pair.second);
                   +  - ]
     829                 :             :     }
     830                 :             : 
     831                 :             :     // Ensure legacy compatibility with previous versions of Bitcoin Core's atoi64
     832         [ +  + ]:          18 :     for (const auto& pair : atoi64_test_pairs) {
     833   [ +  -  +  -  :          16 :         BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int64_t>(pair.first), atoi64_legacy(pair.first));
                   +  - ]
     834                 :             :     }
     835                 :             : 
     836   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint64_t>("-1"), 0U);
                   +  - ]
     837   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint64_t>("0"), 0U);
                   +  - ]
     838   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint64_t>("18446744073709551615"), 18'446'744'073'709'551'615ULL);
                   +  - ]
     839   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint64_t>("18446744073709551616"), 18'446'744'073'709'551'615ULL);
                   +  - ]
     840                 :             : 
     841   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("-2147483649"), -2'147'483'648LL);
                   +  - ]
     842   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("-2147483648"), -2'147'483'648LL);
                   +  - ]
     843   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("2147483647"), 2'147'483'647);
                   +  - ]
     844   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("2147483648"), 2'147'483'647);
                   +  - ]
     845                 :             : 
     846   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint32_t>("-1"), 0U);
                   +  - ]
     847   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint32_t>("0"), 0U);
                   +  - ]
     848   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint32_t>("4294967295"), 4'294'967'295U);
                   +  - ]
     849   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint32_t>("4294967296"), 4'294'967'295U);
                   +  - ]
     850                 :             : 
     851   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int16_t>("-32769"), -32'768);
                   +  - ]
     852   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int16_t>("-32768"), -32'768);
                   +  - ]
     853   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int16_t>("32767"), 32'767);
                   +  - ]
     854   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int16_t>("32768"), 32'767);
                   +  - ]
     855                 :             : 
     856   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint16_t>("-1"), 0U);
                   +  - ]
     857   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint16_t>("0"), 0U);
                   +  - ]
     858   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint16_t>("65535"), 65'535U);
                   +  - ]
     859   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint16_t>("65536"), 65'535U);
                   +  - ]
     860                 :             : 
     861   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int8_t>("-129"), -128);
                   +  - ]
     862   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int8_t>("-128"), -128);
                   +  - ]
     863   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int8_t>("127"), 127);
                   +  - ]
     864   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int8_t>("128"), 127);
                   +  - ]
     865                 :             : 
     866   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint8_t>("-1"), 0U);
                   +  - ]
     867   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint8_t>("0"), 0U);
                   +  - ]
     868   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint8_t>("255"), 255U);
                   +  - ]
     869   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint8_t>("256"), 255U);
                   +  - ]
     870   [ +  -  +  -  :           4 : }
          +  -  +  -  +  
          -  +  -  +  -  
             -  +  -  - ]
     871                 :             : 
     872   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(test_ParseInt64)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     873                 :             : {
     874                 :           2 :     int64_t n;
     875                 :             :     // Valid values
     876   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseInt64("1234", nullptr));
     877   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt64("0", &n) && n == 0LL);
             -  +  +  - ]
     878   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt64("1234", &n) && n == 1234LL);
             -  +  +  - ]
     879   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt64("01234", &n) && n == 1234LL); // no octal
             -  +  +  - ]
     880   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt64("2147483647", &n) && n == 2147483647LL);
             -  +  +  - ]
     881   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt64("-2147483648", &n) && n == -2147483648LL);
             -  +  +  - ]
     882   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt64("9223372036854775807", &n) && n == int64_t{9223372036854775807});
             -  +  +  - ]
     883   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt64("-9223372036854775808", &n) && n == int64_t{-9223372036854775807-1});
             -  +  +  - ]
     884   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseInt64("-1234", &n) && n == -1234LL);
             -  +  +  - ]
     885                 :             :     // Invalid values
     886   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt64("", &n));
     887   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt64(" 1", &n)); // no padding inside
     888   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt64("1 ", &n));
     889   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt64("1a", &n));
     890   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt64("aap", &n));
     891   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt64("0x1", &n)); // no hex
     892   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt64(STRING_WITH_EMBEDDED_NULL_CHAR, &n));
     893                 :             :     // Overflow and underflow
     894   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt64("-9223372036854775809", nullptr));
     895   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt64("9223372036854775808", nullptr));
     896   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt64("-32482348723847471234", nullptr));
     897   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseInt64("32482348723847471234", nullptr));
     898                 :           2 : }
     899                 :             : 
     900   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(test_ParseUInt8)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     901                 :             : {
     902                 :           2 :     uint8_t n;
     903                 :             :     // Valid values
     904   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseUInt8("255", nullptr));
     905   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt8("0", &n) && n == 0);
             -  +  +  - ]
     906   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt8("255", &n) && n == 255);
             -  +  +  - ]
     907   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt8("0255", &n) && n == 255); // no octal
             -  +  +  - ]
     908   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt8("255", &n) && n == static_cast<uint8_t>(255));
             -  +  +  - ]
     909   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt8("+255", &n) && n == 255);
             -  +  +  - ]
     910   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt8("00000000000000000012", &n) && n == 12);
             -  +  +  - ]
     911   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt8("00000000000000000000", &n) && n == 0);
             -  +  +  - ]
     912                 :             :     // Invalid values
     913   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8("-00000000000000000000", &n));
     914   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8("", &n));
     915   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8(" 1", &n)); // no padding inside
     916   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8(" -1", &n));
     917   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8("++1", &n));
     918   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8("+-1", &n));
     919   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8("-+1", &n));
     920   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8("--1", &n));
     921   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8("-1", &n));
     922   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8("1 ", &n));
     923   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8("1a", &n));
     924   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8("aap", &n));
     925   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8("0x1", &n)); // no hex
     926   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8(STRING_WITH_EMBEDDED_NULL_CHAR, &n));
     927                 :             :     // Overflow and underflow
     928   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8("-255", &n));
     929   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8("256", &n));
     930   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8("-123", &n));
     931   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8("-123", nullptr));
     932   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt8("256", nullptr));
     933                 :           2 : }
     934                 :             : 
     935   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(test_ParseUInt16)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     936                 :             : {
     937                 :           2 :     uint16_t n;
     938                 :             :     // Valid values
     939   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseUInt16("1234", nullptr));
     940   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt16("0", &n) && n == 0);
             -  +  +  - ]
     941   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt16("1234", &n) && n == 1234);
             -  +  +  - ]
     942   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt16("01234", &n) && n == 1234); // no octal
             -  +  +  - ]
     943   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt16("65535", &n) && n == static_cast<uint16_t>(65535));
             -  +  +  - ]
     944   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt16("+65535", &n) && n == 65535);
             -  +  +  - ]
     945   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt16("00000000000000000012", &n) && n == 12);
             -  +  +  - ]
     946   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt16("00000000000000000000", &n) && n == 0);
             -  +  +  - ]
     947                 :             :     // Invalid values
     948   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16("-00000000000000000000", &n));
     949   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16("", &n));
     950   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16(" 1", &n)); // no padding inside
     951   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16(" -1", &n));
     952   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16("++1", &n));
     953   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16("+-1", &n));
     954   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16("-+1", &n));
     955   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16("--1", &n));
     956   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16("-1", &n));
     957   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16("1 ", &n));
     958   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16("1a", &n));
     959   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16("aap", &n));
     960   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16("0x1", &n)); // no hex
     961   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16(STRING_WITH_EMBEDDED_NULL_CHAR, &n));
     962                 :             :     // Overflow and underflow
     963   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16("-65535", &n));
     964   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16("65536", &n));
     965   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16("-123", &n));
     966   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16("-123", nullptr));
     967   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt16("65536", nullptr));
     968                 :           2 : }
     969                 :             : 
     970   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(test_ParseUInt32)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     971                 :             : {
     972                 :           2 :     uint32_t n;
     973                 :             :     // Valid values
     974   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseUInt32("1234", nullptr));
     975   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt32("0", &n) && n == 0);
             -  +  +  - ]
     976   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt32("1234", &n) && n == 1234);
             -  +  +  - ]
     977   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt32("01234", &n) && n == 1234); // no octal
             -  +  +  - ]
     978   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt32("2147483647", &n) && n == 2147483647);
             -  +  +  - ]
     979   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt32("2147483648", &n) && n == uint32_t{2147483648});
             -  +  +  - ]
     980   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt32("4294967295", &n) && n == uint32_t{4294967295});
             -  +  +  - ]
     981   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt32("+1234", &n) && n == 1234);
             -  +  +  - ]
     982   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt32("00000000000000001234", &n) && n == 1234);
             -  +  +  - ]
     983   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt32("00000000000000000000", &n) && n == 0);
             -  +  +  - ]
     984                 :             :     // Invalid values
     985   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32("-00000000000000000000", &n));
     986   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32("", &n));
     987   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32(" 1", &n)); // no padding inside
     988   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32(" -1", &n));
     989   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32("++1", &n));
     990   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32("+-1", &n));
     991   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32("-+1", &n));
     992   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32("--1", &n));
     993   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32("-1", &n));
     994   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32("1 ", &n));
     995   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32("1a", &n));
     996   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32("aap", &n));
     997   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32("0x1", &n)); // no hex
     998   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32(STRING_WITH_EMBEDDED_NULL_CHAR, &n));
     999                 :             :     // Overflow and underflow
    1000   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32("-2147483648", &n));
    1001   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32("4294967296", &n));
    1002   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32("-1234", &n));
    1003   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32("-32482348723847471234", nullptr));
    1004   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt32("32482348723847471234", nullptr));
    1005                 :           2 : }
    1006                 :             : 
    1007   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(test_ParseUInt64)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1008                 :             : {
    1009                 :           2 :     uint64_t n;
    1010                 :             :     // Valid values
    1011   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseUInt64("1234", nullptr));
    1012   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt64("0", &n) && n == 0LL);
             -  +  +  - ]
    1013   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt64("1234", &n) && n == 1234LL);
             -  +  +  - ]
    1014   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt64("01234", &n) && n == 1234LL); // no octal
             -  +  +  - ]
    1015   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt64("2147483647", &n) && n == 2147483647LL);
             -  +  +  - ]
    1016   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt64("9223372036854775807", &n) && n == 9223372036854775807ULL);
             -  +  +  - ]
    1017   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt64("9223372036854775808", &n) && n == 9223372036854775808ULL);
             -  +  +  - ]
    1018   [ +  -  +  -  :           4 :     BOOST_CHECK(ParseUInt64("18446744073709551615", &n) && n == 18446744073709551615ULL);
             -  +  +  - ]
    1019                 :             :     // Invalid values
    1020   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt64("", &n));
    1021   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt64(" 1", &n)); // no padding inside
    1022   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt64(" -1", &n));
    1023   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt64("1 ", &n));
    1024   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt64("1a", &n));
    1025   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt64("aap", &n));
    1026   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt64("0x1", &n)); // no hex
    1027   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt64(STRING_WITH_EMBEDDED_NULL_CHAR, &n));
    1028                 :             :     // Overflow and underflow
    1029   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt64("-9223372036854775809", nullptr));
    1030   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt64("18446744073709551616", nullptr));
    1031   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt64("-32482348723847471234", nullptr));
    1032   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt64("-2147483648", &n));
    1033   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt64("-9223372036854775808", &n));
    1034   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseUInt64("-1234", &n));
    1035                 :           2 : }
    1036                 :             : 
    1037   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(test_FormatParagraph)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1038                 :             : {
    1039         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatParagraph("", 79, 0), "");
    1040         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatParagraph("test", 79, 0), "test");
    1041         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatParagraph(" test", 79, 0), " test");
    1042         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatParagraph("test test", 79, 0), "test test");
    1043         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 0), "test\ntest");
    1044         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatParagraph("testerde test", 4, 0), "testerde\ntest");
    1045         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 4), "test\n    test");
    1046                 :             : 
    1047                 :             :     // Make sure we don't indent a fully-new line following a too-long line ending
    1048         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatParagraph("test test\nabc", 4, 4), "test\n    test\nabc");
    1049                 :             : 
    1050         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatParagraph("This_is_a_very_long_test_string_without_any_spaces_so_it_should_just_get_returned_as_is_despite_the_length until it gets here", 79), "This_is_a_very_long_test_string_without_any_spaces_so_it_should_just_get_returned_as_is_despite_the_length\nuntil it gets here");
    1051                 :             : 
    1052                 :             :     // Test wrap length is exact
    1053         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatParagraph("a b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p", 79), "a b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de\nf g h i j k l m n o p");
    1054         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatParagraph("x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p", 79), "x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de\nf g h i j k l m n o p");
    1055                 :             :     // Indent should be included in length of lines
    1056         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatParagraph("x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9 a b c d e fg h i j k", 79, 4), "x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de\n    f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9 a b c d e fg\n    h i j k");
    1057                 :             : 
    1058         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatParagraph("This is a very long test string. This is a second sentence in the very long test string.", 79), "This is a very long test string. This is a second sentence in the very long\ntest string.");
    1059         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatParagraph("This is a very long test string.\nThis is a second sentence in the very long test string. This is a third sentence in the very long test string.", 79), "This is a very long test string.\nThis is a second sentence in the very long test string. This is a third\nsentence in the very long test string.");
    1060         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatParagraph("This is a very long test string.\n\nThis is a second sentence in the very long test string. This is a third sentence in the very long test string.", 79), "This is a very long test string.\n\nThis is a second sentence in the very long test string. This is a third\nsentence in the very long test string.");
    1061         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(FormatParagraph("Testing that normal newlines do not get indented.\nLike here.", 79), "Testing that normal newlines do not get indented.\nLike here.");
    1062                 :           2 : }
    1063                 :             : 
    1064   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(test_FormatSubVersion)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1065                 :             : {
    1066                 :           2 :     std::vector<std::string> comments;
    1067         [ +  - ]:           2 :     comments.emplace_back("comment1");
    1068                 :           2 :     std::vector<std::string> comments2;
    1069         [ +  - ]:           2 :     comments2.emplace_back("comment1");
    1070   [ +  -  +  - ]:           4 :     comments2.push_back(SanitizeString(std::string("Comment2; .,_?@-; !\"#$%&'()*+/<=>[]\\^`{|}~"), SAFE_CHARS_UA_COMMENT)); // Semicolon is discouraged but not forbidden by BIP-0014
    1071   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, std::vector<std::string>()),std::string("/Test:9.99.0/"));
          +  -  +  -  +  
                      - ]
    1072   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, comments),std::string("/Test:9.99.0(comment1)/"));
          +  -  +  -  +  
                      - ]
    1073   [ +  -  +  -  :           2 :     BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, comments2),std::string("/Test:9.99.0(comment1; Comment2; .,_?@-; )/"));
          +  -  +  -  +  
                      - ]
    1074                 :           2 : }
    1075                 :             : 
    1076   [ +  -  +  -  :          14 : BOOST_AUTO_TEST_CASE(test_ParseFixedPoint)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1077                 :             : {
    1078                 :           2 :     int64_t amount = 0;
    1079   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseFixedPoint("0", 8, &amount));
    1080         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(amount, 0LL);
    1081   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseFixedPoint("1", 8, &amount));
    1082         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(amount, 100000000LL);
    1083   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseFixedPoint("0.0", 8, &amount));
    1084         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(amount, 0LL);
    1085   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseFixedPoint("-0.1", 8, &amount));
    1086         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(amount, -10000000LL);
    1087   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseFixedPoint("1.1", 8, &amount));
    1088         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(amount, 110000000LL);
    1089   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseFixedPoint("1.10000000000000000", 8, &amount));
    1090         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(amount, 110000000LL);
    1091   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseFixedPoint("1.1e1", 8, &amount));
    1092         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(amount, 1100000000LL);
    1093   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseFixedPoint("1.1e-1", 8, &amount));
    1094         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(amount, 11000000LL);
    1095   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseFixedPoint("1000", 8, &amount));
    1096         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(amount, 100000000000LL);
    1097   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseFixedPoint("-1000", 8, &amount));
    1098         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(amount, -100000000000LL);
    1099   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseFixedPoint("0.00000001", 8, &amount));
    1100         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(amount, 1LL);
    1101   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseFixedPoint("0.0000000100000000", 8, &amount));
    1102         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(amount, 1LL);
    1103   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseFixedPoint("-0.00000001", 8, &amount));
    1104         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(amount, -1LL);
    1105   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseFixedPoint("1000000000.00000001", 8, &amount));
    1106         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(amount, 100000000000000001LL);
    1107   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseFixedPoint("9999999999.99999999", 8, &amount));
    1108         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(amount, 999999999999999999LL);
    1109   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseFixedPoint("-9999999999.99999999", 8, &amount));
    1110         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(amount, -999999999999999999LL);
    1111                 :             : 
    1112   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("", 8, &amount));
    1113   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("-", 8, &amount));
    1114   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("a-1000", 8, &amount));
    1115   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("-a1000", 8, &amount));
    1116   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("-1000a", 8, &amount));
    1117   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("-01000", 8, &amount));
    1118   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("00.1", 8, &amount));
    1119   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint(".1", 8, &amount));
    1120   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("--0.1", 8, &amount));
    1121   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("0.000000001", 8, &amount));
    1122   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("-0.000000001", 8, &amount));
    1123   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("0.00000001000000001", 8, &amount));
    1124   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("-10000000000.00000000", 8, &amount));
    1125   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("10000000000.00000000", 8, &amount));
    1126   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("-10000000000.00000001", 8, &amount));
    1127   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("10000000000.00000001", 8, &amount));
    1128   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("-10000000000.00000009", 8, &amount));
    1129   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("10000000000.00000009", 8, &amount));
    1130   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("-99999999999.99999999", 8, &amount));
    1131   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("99999909999.09999999", 8, &amount));
    1132   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("92233720368.54775807", 8, &amount));
    1133   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("92233720368.54775808", 8, &amount));
    1134   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("-92233720368.54775808", 8, &amount));
    1135   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("-92233720368.54775809", 8, &amount));
    1136   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("1.1e", 8, &amount));
    1137   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("1.1e-", 8, &amount));
    1138   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("1.", 8, &amount));
    1139                 :             : 
    1140                 :             :     // Test with 3 decimal places for fee rates in sat/vB.
    1141   [ +  -  +  - ]:           4 :     BOOST_CHECK(ParseFixedPoint("0.001", 3, &amount));
    1142         [ +  - ]:           2 :     BOOST_CHECK_EQUAL(amount, CAmount{1});
    1143   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("0.0009", 3, &amount));
    1144   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("31.00100001", 3, &amount));
    1145   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("31.0011", 3, &amount));
    1146   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("31.99999999", 3, &amount));
    1147   [ +  -  +  - ]:           4 :     BOOST_CHECK(!ParseFixedPoint("31.999999999999999999999", 3, &amount));
    1148                 :           2 : }
    1149                 :             : 
    1150                 :             : #ifndef WIN32 // Cannot do this test on WIN32 due to lack of fork()
    1151                 :             : static constexpr char LockCommand = 'L';
    1152                 :             : static constexpr char UnlockCommand = 'U';
    1153                 :             : static constexpr char ExitCommand = 'X';
    1154                 :             : enum : char {
    1155                 :             :     ResSuccess = 2, // Start with 2 to avoid accidental collision with common values 0 and 1
    1156                 :             :     ResErrorWrite,
    1157                 :             :     ResErrorLock,
    1158                 :             :     ResUnlockSuccess,
    1159                 :             : };
    1160                 :             : 
    1161                 :           1 : [[noreturn]] static void TestOtherProcess(fs::path dirname, fs::path lockname, int fd)
    1162                 :             : {
    1163                 :           6 :     char ch;
    1164                 :           6 :     while (true) {
    1165                 :           6 :         int rv = read(fd, &ch, 1); // Wait for command
    1166         [ -  + ]:           6 :         assert(rv == 1);
    1167   [ +  +  +  - ]:           6 :         switch (ch) {
    1168                 :           4 :         case LockCommand:
    1169                 :          12 :             ch = [&] {
    1170   [ +  +  -  + ]:           4 :                 switch (util::LockDirectory(dirname, lockname)) {
    1171                 :             :                 case util::LockResult::Success: return ResSuccess;
    1172                 :           1 :                 case util::LockResult::ErrorWrite: return ResErrorWrite;
    1173                 :           1 :                 case util::LockResult::ErrorLock: return ResErrorLock;
    1174                 :             :                 } // no default case, so the compiler can warn about missing cases
    1175                 :           0 :                 assert(false);
    1176                 :           4 :             }();
    1177                 :           4 :             rv = write(fd, &ch, 1);
    1178         [ +  - ]:           4 :             assert(rv == 1);
    1179                 :             :             break;
    1180                 :           1 :         case UnlockCommand:
    1181                 :           1 :             ReleaseDirectoryLocks();
    1182                 :           1 :             ch = ResUnlockSuccess; // Always succeeds
    1183                 :           1 :             rv = write(fd, &ch, 1);
    1184         [ +  - ]:           1 :             assert(rv == 1);
    1185                 :             :             break;
    1186                 :           1 :         case ExitCommand:
    1187                 :           1 :             close(fd);
    1188                 :           1 :             exit(0);
    1189                 :           0 :         default:
    1190                 :           0 :             assert(0);
    1191                 :             :         }
    1192                 :             :     }
    1193                 :             : }
    1194                 :             : #endif
    1195                 :             : 
    1196   [ +  -  +  -  :          12 : BOOST_AUTO_TEST_CASE(test_LockDirectory)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1197                 :             : {
    1198         [ +  - ]:           4 :     fs::path dirname = m_args.GetDataDirBase() / "lock_dir";
    1199         [ +  - ]:           2 :     const fs::path lockname = ".lock";
    1200                 :             : #ifndef WIN32
    1201                 :             :     // Revert SIGCHLD to default, otherwise boost.test will catch and fail on
    1202                 :             :     // it: there is BOOST_TEST_IGNORE_SIGCHLD but that only works when defined
    1203                 :             :     // at build-time of the boost library
    1204                 :           2 :     void (*old_handler)(int) = signal(SIGCHLD, SIG_DFL);
    1205                 :             : 
    1206                 :             :     // Fork another process for testing before creating the lock, so that we
    1207                 :             :     // won't fork while holding the lock (which might be undefined, and is not
    1208                 :             :     // relevant as test case as that is avoided with -daemonize).
    1209                 :           2 :     int fd[2];
    1210   [ +  -  +  - ]:           2 :     BOOST_CHECK_EQUAL(socketpair(AF_UNIX, SOCK_STREAM, 0, fd), 0);
    1211                 :           2 :     pid_t pid = fork();
    1212         [ +  + ]:           2 :     if (!pid) {
    1213   [ +  -  +  -  :           1 :         BOOST_CHECK_EQUAL(close(fd[1]), 0); // Child: close parent end
                   +  - ]
    1214   [ +  -  +  - ]:           1 :         TestOtherProcess(dirname, lockname, fd[0]);
    1215                 :             :     }
    1216   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(close(fd[0]), 0); // Parent: close child end
                   +  - ]
    1217                 :             : 
    1218                 :           1 :     char ch;
    1219                 :             :     // Lock on non-existent directory should fail
    1220   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
                   +  - ]
    1221   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
                   +  - ]
    1222   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(ch, ResErrorWrite);
    1223                 :             : #endif
    1224                 :             :     // Lock on non-existent directory should fail
    1225   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(util::LockDirectory(dirname, lockname), util::LockResult::ErrorWrite);
                   +  - ]
    1226                 :             : 
    1227         [ +  - ]:           1 :     fs::create_directories(dirname);
    1228                 :             : 
    1229                 :             :     // Probing lock on new directory should succeed
    1230   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(util::LockDirectory(dirname, lockname, true), util::LockResult::Success);
                   +  - ]
    1231                 :             : 
    1232                 :             :     // Persistent lock on new directory should succeed
    1233   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(util::LockDirectory(dirname, lockname), util::LockResult::Success);
                   +  - ]
    1234                 :             : 
    1235                 :             :     // Another lock on the directory from the same thread should succeed
    1236   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(util::LockDirectory(dirname, lockname), util::LockResult::Success);
                   +  - ]
    1237                 :             : 
    1238                 :             :     // Another lock on the directory from a different thread within the same process should succeed
    1239                 :           1 :     util::LockResult threadresult;
    1240         [ +  - ]:           2 :     std::thread thr([&] { threadresult = util::LockDirectory(dirname, lockname); });
    1241         [ +  - ]:           1 :     thr.join();
    1242   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(threadresult, util::LockResult::Success);
    1243                 :             : #ifndef WIN32
    1244                 :             :     // Try to acquire lock in child process while we're holding it, this should fail.
    1245   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
                   +  - ]
    1246   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
                   +  - ]
    1247   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(ch, ResErrorLock);
    1248                 :             : 
    1249                 :             :     // Give up our lock
    1250         [ +  - ]:           1 :     ReleaseDirectoryLocks();
    1251                 :             :     // Probing lock from our side now should succeed, but not hold on to the lock.
    1252   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(util::LockDirectory(dirname, lockname, true), util::LockResult::Success);
                   +  - ]
    1253                 :             : 
    1254                 :             :     // Try to acquire the lock in the child process, this should be successful.
    1255   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
                   +  - ]
    1256   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
                   +  - ]
    1257   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(ch, ResSuccess);
    1258                 :             : 
    1259                 :             :     // When we try to probe the lock now, it should fail.
    1260   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(util::LockDirectory(dirname, lockname, true), util::LockResult::ErrorLock);
                   +  - ]
    1261                 :             : 
    1262                 :             :     // Unlock the lock in the child process
    1263   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(write(fd[1], &UnlockCommand, 1), 1);
                   +  - ]
    1264   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
                   +  - ]
    1265   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(ch, ResUnlockSuccess);
    1266                 :             : 
    1267                 :             :     // When we try to probe the lock now, it should succeed.
    1268   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(util::LockDirectory(dirname, lockname, true), util::LockResult::Success);
                   +  - ]
    1269                 :             : 
    1270                 :             :     // Re-lock the lock in the child process, then wait for it to exit, check
    1271                 :             :     // successful return. After that, we check that exiting the process
    1272                 :             :     // has released the lock as we would expect by probing it.
    1273                 :           1 :     int processstatus;
    1274   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
                   +  - ]
    1275                 :             :     // The following line invokes the ~CNetCleanup dtor without
    1276                 :             :     // a paired SetupNetworking call. This is acceptable as long as
    1277                 :             :     // ~CNetCleanup is a no-op for non-Windows platforms.
    1278   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(write(fd[1], &ExitCommand, 1), 1);
                   +  - ]
    1279   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(waitpid(pid, &processstatus, 0), pid);
                   +  - ]
    1280   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(processstatus, 0);
    1281   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(util::LockDirectory(dirname, lockname, true), util::LockResult::Success);
                   +  - ]
    1282                 :             : 
    1283                 :             :     // Restore SIGCHLD
    1284                 :           1 :     signal(SIGCHLD, old_handler);
    1285   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(close(fd[1]), 0); // Close our side of the socketpair
                   +  - ]
    1286                 :             : #endif
    1287                 :             :     // Clean up
    1288         [ +  - ]:           1 :     ReleaseDirectoryLocks();
    1289         [ +  - ]:           1 :     fs::remove_all(dirname);
    1290                 :           3 : }
    1291                 :             : 
    1292   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(test_ToLower)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1293                 :             : {
    1294         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToLower('@'), '@');
    1295         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToLower('A'), 'a');
    1296         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToLower('Z'), 'z');
    1297         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToLower('['), '[');
    1298         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToLower(0), 0);
    1299         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToLower('\xff'), '\xff');
    1300                 :             : 
    1301         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToLower(""), "");
    1302         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToLower("#HODL"), "#hodl");
    1303         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToLower("\x00\xfe\xff"), "\x00\xfe\xff");
    1304                 :           1 : }
    1305                 :             : 
    1306   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(test_ToUpper)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1307                 :             : {
    1308         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToUpper('`'), '`');
    1309         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToUpper('a'), 'A');
    1310         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToUpper('z'), 'Z');
    1311         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToUpper('{'), '{');
    1312         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToUpper(0), 0);
    1313         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToUpper('\xff'), '\xff');
    1314                 :             : 
    1315         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToUpper(""), "");
    1316         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToUpper("#hodl"), "#HODL");
    1317         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(ToUpper("\x00\xfe\xff"), "\x00\xfe\xff");
    1318                 :           1 : }
    1319                 :             : 
    1320   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(test_Capitalize)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1321                 :             : {
    1322   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(Capitalize(""), "");
    1323   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(Capitalize("bitcoin"), "Bitcoin");
    1324   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(Capitalize("\x00\xfe\xff"), "\x00\xfe\xff");
    1325                 :           1 : }
    1326                 :             : 
    1327                 :          28 : static std::string SpanToStr(const std::span<const char>& span)
    1328                 :             : {
    1329                 :          28 :     return std::string(span.begin(), span.end());
    1330                 :             : }
    1331                 :             : 
    1332   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(test_script_parsing)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1333                 :             : {
    1334                 :           1 :     using namespace script;
    1335         [ +  - ]:           1 :     std::string input;
    1336                 :           1 :     std::span<const char> sp;
    1337                 :           1 :     bool success;
    1338                 :             : 
    1339                 :             :     // Const(...): parse a constant, update span to skip it if successful
    1340         [ +  - ]:           1 :     input = "MilkToastHoney";
    1341         [ +  - ]:           1 :     sp = input;
    1342   [ +  -  +  - ]:           1 :     success = Const("", sp); // empty
    1343   [ +  -  +  -  :           2 :     BOOST_CHECK(success);
                   +  - ]
    1344   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(sp), "MilkToastHoney");
                   +  - ]
    1345                 :             : 
    1346   [ +  -  +  - ]:           1 :     success = Const("Milk", sp);
    1347   [ +  -  +  -  :           2 :     BOOST_CHECK(success);
                   +  - ]
    1348   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(sp), "ToastHoney");
                   +  - ]
    1349                 :             : 
    1350   [ +  -  +  - ]:           1 :     success = Const("Bread", sp);
    1351   [ +  -  +  -  :           2 :     BOOST_CHECK(!success);
                   +  - ]
    1352                 :             : 
    1353   [ +  -  +  - ]:           1 :     success = Const("Toast", sp);
    1354   [ +  -  +  -  :           2 :     BOOST_CHECK(success);
                   +  - ]
    1355   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(sp), "Honey");
                   +  - ]
    1356                 :             : 
    1357   [ +  -  +  - ]:           1 :     success = Const("Honeybadger", sp);
    1358   [ +  -  +  -  :           2 :     BOOST_CHECK(!success);
                   +  - ]
    1359                 :             : 
    1360   [ +  -  +  - ]:           1 :     success = Const("Honey", sp);
    1361   [ +  -  +  -  :           2 :     BOOST_CHECK(success);
                   +  - ]
    1362   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(sp), "");
                   +  - ]
    1363                 :             : 
    1364                 :             :     // Func(...): parse a function call, update span to argument if successful
    1365         [ +  - ]:           1 :     input = "Foo(Bar(xy,z()))";
    1366         [ +  - ]:           1 :     sp = input;
    1367                 :             : 
    1368   [ +  -  +  - ]:           1 :     success = Func("FooBar", sp);
    1369   [ +  -  +  -  :           2 :     BOOST_CHECK(!success);
                   +  - ]
    1370                 :             : 
    1371   [ +  -  +  - ]:           1 :     success = Func("Foo(", sp);
    1372   [ +  -  +  -  :           2 :     BOOST_CHECK(!success);
                   +  - ]
    1373                 :             : 
    1374   [ +  -  +  - ]:           1 :     success = Func("Foo", sp);
    1375   [ +  -  +  -  :           2 :     BOOST_CHECK(success);
                   +  - ]
    1376   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(sp), "Bar(xy,z())");
                   +  - ]
    1377                 :             : 
    1378   [ +  -  +  - ]:           1 :     success = Func("Bar", sp);
    1379   [ +  -  +  -  :           2 :     BOOST_CHECK(success);
                   +  - ]
    1380   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(sp), "xy,z()");
                   +  - ]
    1381                 :             : 
    1382   [ +  -  +  - ]:           1 :     success = Func("xy", sp);
    1383   [ +  -  +  -  :           2 :     BOOST_CHECK(!success);
                   +  - ]
    1384                 :             : 
    1385                 :             :     // Expr(...): return expression that span begins with, update span to skip it
    1386                 :           1 :     std::span<const char> result;
    1387                 :             : 
    1388         [ +  - ]:           1 :     input = "(n*(n-1))/2";
    1389         [ +  - ]:           1 :     sp = input;
    1390         [ +  - ]:           1 :     result = Expr(sp);
    1391   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(result), "(n*(n-1))/2");
                   +  - ]
    1392   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(sp), "");
                   +  - ]
    1393                 :             : 
    1394         [ +  - ]:           1 :     input = "foo,bar";
    1395         [ +  - ]:           1 :     sp = input;
    1396         [ +  - ]:           1 :     result = Expr(sp);
    1397   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(result), "foo");
                   +  - ]
    1398   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(sp), ",bar");
                   +  - ]
    1399                 :             : 
    1400         [ +  - ]:           1 :     input = "(aaaaa,bbbbb()),c";
    1401         [ +  - ]:           1 :     sp = input;
    1402         [ +  - ]:           1 :     result = Expr(sp);
    1403   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(result), "(aaaaa,bbbbb())");
                   +  - ]
    1404   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(sp), ",c");
                   +  - ]
    1405                 :             : 
    1406         [ +  - ]:           1 :     input = "xyz)foo";
    1407         [ +  - ]:           1 :     sp = input;
    1408         [ +  - ]:           1 :     result = Expr(sp);
    1409   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(result), "xyz");
                   +  - ]
    1410   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(sp), ")foo");
                   +  - ]
    1411                 :             : 
    1412         [ +  - ]:           1 :     input = "((a),(b),(c)),xxx";
    1413         [ +  - ]:           1 :     sp = input;
    1414         [ +  - ]:           1 :     result = Expr(sp);
    1415   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(result), "((a),(b),(c))");
                   +  - ]
    1416   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(sp), ",xxx");
                   +  - ]
    1417                 :             : 
    1418                 :             :     // Split(...): split a string on every instance of sep, return vector
    1419                 :           1 :     std::vector<std::span<const char>> results;
    1420                 :             : 
    1421         [ +  - ]:           1 :     input = "xxx";
    1422         [ +  - ]:           2 :     results = Split(input, 'x');
    1423   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(results.size(), 4U);
    1424   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(results[0]), "");
                   +  - ]
    1425   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(results[1]), "");
                   +  - ]
    1426   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(results[2]), "");
                   +  - ]
    1427   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(results[3]), "");
                   +  - ]
    1428                 :             : 
    1429         [ +  - ]:           1 :     input = "one#two#three";
    1430         [ +  - ]:           2 :     results = Split(input, '-');
    1431   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(results.size(), 1U);
    1432   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(results[0]), "one#two#three");
                   +  - ]
    1433                 :             : 
    1434         [ +  - ]:           1 :     input = "one#two#three";
    1435         [ +  - ]:           2 :     results = Split(input, '#');
    1436   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(results.size(), 3U);
    1437   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(results[0]), "one");
                   +  - ]
    1438   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(results[1]), "two");
                   +  - ]
    1439   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(results[2]), "three");
                   +  - ]
    1440                 :             : 
    1441         [ +  - ]:           1 :     input = "*foo*bar*";
    1442         [ +  - ]:           2 :     results = Split(input, '*');
    1443   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(results.size(), 4U);
    1444   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(results[0]), "");
                   +  - ]
    1445   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(results[1]), "foo");
                   +  - ]
    1446   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(results[2]), "bar");
                   +  - ]
    1447   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(SpanToStr(results[3]), "");
                   +  - ]
    1448                 :           1 : }
    1449                 :             : 
    1450   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(test_SplitString)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1451                 :             : {
    1452                 :             :     // Empty string.
    1453                 :           1 :     {
    1454                 :           1 :         std::vector<std::string> result = SplitString("", '-');
    1455   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(result.size(), 1);
    1456   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(result[0], "");
    1457                 :           1 :     }
    1458                 :             : 
    1459                 :             :     // Empty items.
    1460                 :           1 :     {
    1461                 :           1 :         std::vector<std::string> result = SplitString("-", '-');
    1462   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(result.size(), 2);
    1463   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(result[0], "");
    1464   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(result[1], "");
    1465                 :           1 :     }
    1466                 :             : 
    1467                 :             :     // More empty items.
    1468                 :           1 :     {
    1469                 :           1 :         std::vector<std::string> result = SplitString("--", '-');
    1470   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(result.size(), 3);
    1471   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(result[0], "");
    1472   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(result[1], "");
    1473   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(result[2], "");
    1474                 :           1 :     }
    1475                 :             : 
    1476                 :             :     // Separator is not present.
    1477                 :           1 :     {
    1478                 :           1 :         std::vector<std::string> result = SplitString("abc", '-');
    1479   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(result.size(), 1);
    1480   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(result[0], "abc");
    1481                 :           1 :     }
    1482                 :             : 
    1483                 :             :     // Basic behavior.
    1484                 :           1 :     {
    1485                 :           1 :         std::vector<std::string> result = SplitString("a-b", '-');
    1486   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(result.size(), 2);
    1487   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(result[0], "a");
    1488   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(result[1], "b");
    1489                 :           1 :     }
    1490                 :             : 
    1491                 :             :     // Case-sensitivity of the separator.
    1492                 :           1 :     {
    1493                 :           1 :         std::vector<std::string> result = SplitString("AAA", 'a');
    1494   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(result.size(), 1);
    1495   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(result[0], "AAA");
    1496                 :           1 :     }
    1497                 :             : 
    1498                 :             :     // multiple split characters
    1499                 :           1 :     {
    1500                 :           1 :         using V = std::vector<std::string>;
    1501   [ +  -  +  -  :           7 :         BOOST_TEST(SplitString("a,b.c:d;e", ",;") == V({"a", "b.c:d", "e"}));
          +  -  +  -  +  
             -  +  +  -  
                      - ]
    1502   [ +  -  +  -  :           9 :         BOOST_TEST(SplitString("a,b.c:d;e", ",;:.") == V({"a", "b", "c", "d", "e"}));
          +  -  +  -  +  
             -  +  +  -  
                      - ]
    1503   [ +  -  +  -  :           4 :         BOOST_TEST(SplitString("a,b.c:d;e", "") == V({"a,b.c:d;e"}));
          +  -  +  -  +  
             -  +  +  -  
                      - ]
    1504   [ +  -  +  -  :           4 :         BOOST_TEST(SplitString("aaa", "bcdefg") == V({"aaa"}));
          +  -  +  -  +  
             -  +  +  -  
                      - ]
    1505   [ +  -  +  -  :           7 :         BOOST_TEST(SplitString("x\0a,b"s, "\0"s) == V({"x", "a,b"}));
          +  -  +  -  +  
          -  +  -  +  +  
                   -  - ]
    1506   [ +  -  +  -  :           7 :         BOOST_TEST(SplitString("x\0a,b"s, '\0') == V({"x", "a,b"}));
          +  -  +  -  +  
             -  +  +  -  
                      - ]
    1507   [ +  -  +  -  :           8 :         BOOST_TEST(SplitString("x\0a,b"s, "\0,"s) == V({"x", "a", "b"}));
          +  -  +  -  +  
          -  +  -  +  +  
                   -  - ]
    1508   [ +  -  +  -  :           8 :         BOOST_TEST(SplitString("abcdefg", "bcd") == V({"a", "", "", "efg"}));
          +  -  +  -  +  
             -  +  +  -  
                      - ]
    1509                 :             :     }
    1510   [ +  -  +  -  :           9 : }
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  -  -  
          -  -  -  -  -  
             -  -  -  -  
                      - ]
    1511                 :             : 
    1512   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(test_LogEscapeMessage)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1513                 :             : {
    1514                 :             :     // ASCII and UTF-8 must pass through unaltered.
    1515         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(BCLog::LogEscapeMessage("Valid log message貓"), "Valid log message貓");
    1516                 :             :     // Newlines must pass through unaltered.
    1517         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(BCLog::LogEscapeMessage("Message\n with newlines\n"), "Message\n with newlines\n");
    1518                 :             :     // Other control characters are escaped in C syntax.
    1519         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(BCLog::LogEscapeMessage("\x01\x7f Corrupted log message\x0d"), R"(\x01\x7f Corrupted log message\x0d)");
    1520                 :             :     // Embedded NULL characters are escaped too.
    1521                 :           1 :     const std::string NUL("O\x00O", 3);
    1522   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(BCLog::LogEscapeMessage(NUL), R"(O\x00O)");
                   +  - ]
    1523                 :           1 : }
    1524                 :             : 
    1525                 :             : namespace {
    1526                 :             : 
    1527                 :             : struct Tracker
    1528                 :             : {
    1529                 :             :     //! Points to the original object (possibly itself) we moved/copied from
    1530                 :             :     const Tracker* origin;
    1531                 :             :     //! How many copies where involved between the original object and this one (moves are not counted)
    1532                 :             :     int copies{0};
    1533                 :             : 
    1534                 :           1 :     Tracker() noexcept : origin(this) {}
    1535                 :          10 :     Tracker(const Tracker& t) noexcept : origin(t.origin), copies(t.copies + 1) {}
    1536                 :          13 :     Tracker(Tracker&& t) noexcept : origin(t.origin), copies(t.copies) {}
    1537                 :             :     Tracker& operator=(const Tracker& t) noexcept
    1538                 :             :     {
    1539                 :             :         if (this != &t) {
    1540                 :             :             origin = t.origin;
    1541                 :             :             copies = t.copies + 1;
    1542                 :             :         }
    1543                 :             :         return *this;
    1544                 :             :     }
    1545                 :             : };
    1546                 :             : 
    1547                 :             : }
    1548                 :             : 
    1549   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(test_tracked_vector)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1550                 :             : {
    1551                 :           1 :     Tracker t1;
    1552                 :           1 :     Tracker t2;
    1553                 :           1 :     Tracker t3;
    1554                 :             : 
    1555         [ +  - ]:           2 :     BOOST_CHECK(t1.origin == &t1);
    1556         [ +  - ]:           2 :     BOOST_CHECK(t2.origin == &t2);
    1557         [ +  - ]:           2 :     BOOST_CHECK(t3.origin == &t3);
    1558                 :             : 
    1559                 :           1 :     auto v1 = Vector(t1);
    1560   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v1.size(), 1U);
    1561   [ +  -  +  -  :           2 :     BOOST_CHECK(v1[0].origin == &t1);
                   +  - ]
    1562   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v1[0].copies, 1);
    1563                 :             : 
    1564         [ +  - ]:           1 :     auto v2 = Vector(std::move(t2));
    1565   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v2.size(), 1U);
    1566   [ +  -  +  -  :           2 :     BOOST_CHECK(v2[0].origin == &t2); // NOLINT(*-use-after-move)
                   +  - ]
    1567   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v2[0].copies, 0);
    1568                 :             : 
    1569         [ +  - ]:           1 :     auto v3 = Vector(t1, std::move(t2));
    1570   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v3.size(), 2U);
    1571   [ +  -  +  -  :           2 :     BOOST_CHECK(v3[0].origin == &t1);
                   +  - ]
    1572   [ +  -  +  -  :           2 :     BOOST_CHECK(v3[1].origin == &t2); // NOLINT(*-use-after-move)
                   +  - ]
    1573   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v3[0].copies, 1);
    1574   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v3[1].copies, 0);
    1575                 :             : 
    1576         [ +  - ]:           1 :     auto v4 = Vector(std::move(v3[0]), v3[1], std::move(t3));
    1577   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v4.size(), 3U);
    1578   [ +  -  +  -  :           2 :     BOOST_CHECK(v4[0].origin == &t1);
                   +  - ]
    1579   [ +  -  +  -  :           2 :     BOOST_CHECK(v4[1].origin == &t2);
                   +  - ]
    1580   [ +  -  +  -  :           2 :     BOOST_CHECK(v4[2].origin == &t3); // NOLINT(*-use-after-move)
                   +  - ]
    1581   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v4[0].copies, 1);
    1582   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v4[1].copies, 1);
    1583   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v4[2].copies, 0);
    1584                 :             : 
    1585   [ +  -  +  - ]:           1 :     auto v5 = Cat(v1, v4);
    1586   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v5.size(), 4U);
    1587   [ +  -  +  -  :           2 :     BOOST_CHECK(v5[0].origin == &t1);
                   +  - ]
    1588   [ +  -  +  -  :           2 :     BOOST_CHECK(v5[1].origin == &t1);
                   +  - ]
    1589   [ +  -  +  -  :           2 :     BOOST_CHECK(v5[2].origin == &t2);
                   +  - ]
    1590   [ +  -  +  -  :           2 :     BOOST_CHECK(v5[3].origin == &t3);
                   +  - ]
    1591   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v5[0].copies, 2);
    1592   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v5[1].copies, 2);
    1593   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v5[2].copies, 2);
    1594   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v5[3].copies, 1);
    1595                 :             : 
    1596         [ +  - ]:           1 :     auto v6 = Cat(std::move(v1), v3);
    1597   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v6.size(), 3U);
    1598   [ +  -  +  -  :           2 :     BOOST_CHECK(v6[0].origin == &t1);
                   +  - ]
    1599   [ +  -  +  -  :           2 :     BOOST_CHECK(v6[1].origin == &t1);
                   +  - ]
    1600   [ +  -  +  -  :           2 :     BOOST_CHECK(v6[2].origin == &t2);
                   +  - ]
    1601   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v6[0].copies, 1);
    1602   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v6[1].copies, 2);
    1603   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v6[2].copies, 1);
    1604                 :             : 
    1605   [ +  -  +  - ]:           1 :     auto v7 = Cat(v2, std::move(v4));
    1606   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v7.size(), 4U);
    1607   [ +  -  +  -  :           2 :     BOOST_CHECK(v7[0].origin == &t2);
                   +  - ]
    1608   [ +  -  +  -  :           2 :     BOOST_CHECK(v7[1].origin == &t1);
                   +  - ]
    1609   [ +  -  +  -  :           2 :     BOOST_CHECK(v7[2].origin == &t2);
                   +  - ]
    1610   [ +  -  +  -  :           2 :     BOOST_CHECK(v7[3].origin == &t3);
                   +  - ]
    1611   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v7[0].copies, 1);
    1612   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v7[1].copies, 1);
    1613   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v7[2].copies, 1);
    1614   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v7[3].copies, 0);
    1615                 :             : 
    1616         [ +  - ]:           1 :     auto v8 = Cat(std::move(v2), std::move(v3));
    1617   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v8.size(), 3U);
    1618   [ +  -  +  -  :           2 :     BOOST_CHECK(v8[0].origin == &t2);
                   +  - ]
    1619   [ +  -  +  -  :           2 :     BOOST_CHECK(v8[1].origin == &t1);
                   +  - ]
    1620   [ +  -  +  -  :           2 :     BOOST_CHECK(v8[2].origin == &t2);
                   +  - ]
    1621   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v8[0].copies, 0);
    1622   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v8[1].copies, 1);
    1623   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(v8[2].copies, 0);
    1624                 :           1 : }
    1625                 :             : 
    1626   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(message_sign)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1627                 :             : {
    1628                 :           1 :     const std::array<unsigned char, 32> privkey_bytes = {
    1629                 :             :         // just some random data
    1630                 :             :         // derived address from this private key: 15CRxFdyRpGZLW9w8HnHvVduizdL5jKNbs
    1631                 :             :         0xD9, 0x7F, 0x51, 0x08, 0xF1, 0x1C, 0xDA, 0x6E,
    1632                 :             :         0xEE, 0xBA, 0xAA, 0x42, 0x0F, 0xEF, 0x07, 0x26,
    1633                 :             :         0xB1, 0xF8, 0x98, 0x06, 0x0B, 0x98, 0x48, 0x9F,
    1634                 :             :         0xA3, 0x09, 0x84, 0x63, 0xC0, 0x03, 0x28, 0x66
    1635                 :             :     };
    1636                 :             : 
    1637                 :           1 :     const std::string message = "Trust no one";
    1638                 :             : 
    1639         [ +  - ]:           1 :     const std::string expected_signature =
    1640         [ +  - ]:           1 :         "IPojfrX2dfPnH26UegfbGQQLrdK844DlHq5157/P6h57WyuS/Qsl+h/WSVGDF4MUi4rWSswW38oimDYfNNUBUOk=";
    1641                 :             : 
    1642                 :           1 :     CKey privkey;
    1643         [ +  - ]:           1 :     std::string generated_signature;
    1644                 :             : 
    1645   [ +  -  +  -  :           2 :     BOOST_REQUIRE_MESSAGE(!privkey.IsValid(),
                   +  - ]
    1646                 :             :         "Confirm the private key is invalid");
    1647                 :             : 
    1648   [ +  -  +  -  :           2 :     BOOST_CHECK_MESSAGE(!MessageSign(privkey, message, generated_signature),
             +  -  +  - ]
    1649                 :             :         "Sign with an invalid private key");
    1650                 :             : 
    1651         [ +  - ]:           1 :     privkey.Set(privkey_bytes.begin(), privkey_bytes.end(), true);
    1652                 :             : 
    1653   [ +  -  +  -  :           2 :     BOOST_REQUIRE_MESSAGE(privkey.IsValid(),
                   +  - ]
    1654                 :             :         "Confirm the private key is valid");
    1655                 :             : 
    1656   [ +  -  +  -  :           2 :     BOOST_CHECK_MESSAGE(MessageSign(privkey, message, generated_signature),
             +  -  +  - ]
    1657                 :             :         "Sign with a valid private key");
    1658                 :             : 
    1659   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(expected_signature, generated_signature);
    1660                 :           1 : }
    1661                 :             : 
    1662   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(message_verify)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1663                 :             : {
    1664   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(
             +  -  +  - ]
    1665                 :             :         MessageVerify(
    1666                 :             :             "invalid address",
    1667                 :             :             "signature should be irrelevant",
    1668                 :             :             "message too"),
    1669                 :             :         MessageVerificationResult::ERR_INVALID_ADDRESS);
    1670                 :             : 
    1671   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(
             +  -  +  - ]
    1672                 :             :         MessageVerify(
    1673                 :             :             "3B5fQsEXEaV8v6U3ejYc8XaKXAkyQj2MjV",
    1674                 :             :             "signature should be irrelevant",
    1675                 :             :             "message too"),
    1676                 :             :         MessageVerificationResult::ERR_ADDRESS_NO_KEY);
    1677                 :             : 
    1678   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(
             +  -  +  - ]
    1679                 :             :         MessageVerify(
    1680                 :             :             "1KqbBpLy5FARmTPD4VZnDDpYjkUvkr82Pm",
    1681                 :             :             "invalid signature, not in base64 encoding",
    1682                 :             :             "message should be irrelevant"),
    1683                 :             :         MessageVerificationResult::ERR_MALFORMED_SIGNATURE);
    1684                 :             : 
    1685   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(
             +  -  +  - ]
    1686                 :             :         MessageVerify(
    1687                 :             :             "1KqbBpLy5FARmTPD4VZnDDpYjkUvkr82Pm",
    1688                 :             :             "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
    1689                 :             :             "message should be irrelevant"),
    1690                 :             :         MessageVerificationResult::ERR_PUBKEY_NOT_RECOVERED);
    1691                 :             : 
    1692   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(
             +  -  +  - ]
    1693                 :             :         MessageVerify(
    1694                 :             :             "15CRxFdyRpGZLW9w8HnHvVduizdL5jKNbs",
    1695                 :             :             "IPojfrX2dfPnH26UegfbGQQLrdK844DlHq5157/P6h57WyuS/Qsl+h/WSVGDF4MUi4rWSswW38oimDYfNNUBUOk=",
    1696                 :             :             "I never signed this"),
    1697                 :             :         MessageVerificationResult::ERR_NOT_SIGNED);
    1698                 :             : 
    1699   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(
             +  -  +  - ]
    1700                 :             :         MessageVerify(
    1701                 :             :             "15CRxFdyRpGZLW9w8HnHvVduizdL5jKNbs",
    1702                 :             :             "IPojfrX2dfPnH26UegfbGQQLrdK844DlHq5157/P6h57WyuS/Qsl+h/WSVGDF4MUi4rWSswW38oimDYfNNUBUOk=",
    1703                 :             :             "Trust no one"),
    1704                 :             :         MessageVerificationResult::OK);
    1705                 :             : 
    1706   [ +  -  +  -  :           1 :     BOOST_CHECK_EQUAL(
             +  -  +  - ]
    1707                 :             :         MessageVerify(
    1708                 :             :             "11canuhp9X2NocwCq7xNrQYTmUgZAnLK3",
    1709                 :             :             "IIcaIENoYW5jZWxsb3Igb24gYnJpbmsgb2Ygc2Vjb25kIGJhaWxvdXQgZm9yIGJhbmtzIAaHRtbCeDZINyavx14=",
    1710                 :             :             "Trust me"),
    1711                 :             :         MessageVerificationResult::OK);
    1712                 :           1 : }
    1713                 :             : 
    1714   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(message_hash)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1715                 :             : {
    1716                 :           1 :     const std::string unsigned_tx = "...";
    1717         [ +  - ]:           1 :     const std::string prefixed_message =
    1718         [ +  - ]:           2 :         std::string(1, (char)MESSAGE_MAGIC.length()) +
    1719         [ +  - ]:           2 :         MESSAGE_MAGIC +
    1720   [ +  -  +  -  :           2 :         std::string(1, (char)unsigned_tx.length()) +
                   +  - ]
    1721         [ +  - ]:           1 :         unsigned_tx;
    1722                 :             : 
    1723         [ +  - ]:           1 :     const uint256 signature_hash = Hash(unsigned_tx);
    1724         [ +  - ]:           1 :     const uint256 message_hash1 = Hash(prefixed_message);
    1725         [ +  - ]:           1 :     const uint256 message_hash2 = MessageHash(unsigned_tx);
    1726                 :             : 
    1727   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(message_hash1, message_hash2);
    1728   [ +  -  +  - ]:           1 :     BOOST_CHECK_NE(message_hash1, signature_hash);
    1729                 :           1 : }
    1730                 :             : 
    1731   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(remove_prefix)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1732                 :             : {
    1733         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(RemovePrefix("./common/system.h", "./"), "common/system.h");
    1734         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(RemovePrefixView("foo", "foo"), "");
    1735         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(RemovePrefix("foo", "fo"), "o");
    1736         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(RemovePrefixView("foo", "f"), "oo");
    1737         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(RemovePrefix("foo", ""), "foo");
    1738         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(RemovePrefixView("fo", "foo"), "fo");
    1739         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(RemovePrefix("f", "foo"), "f");
    1740         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(RemovePrefixView("", "foo"), "");
    1741         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(RemovePrefix("", ""), "");
    1742                 :           1 : }
    1743                 :             : 
    1744   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(util_ParseByteUnits)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1745                 :             : {
    1746                 :           1 :     auto noop = ByteUnit::NOOP;
    1747                 :             : 
    1748                 :             :     // no multiplier
    1749   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(ParseByteUnits("1", noop).value(), 1);
    1750   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(ParseByteUnits("0", noop).value(), 0);
    1751                 :             : 
    1752   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(ParseByteUnits("1k", noop).value(), 1000ULL);
    1753   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(ParseByteUnits("1K", noop).value(), 1ULL << 10);
    1754                 :             : 
    1755   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(ParseByteUnits("2m", noop).value(), 2'000'000ULL);
    1756   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(ParseByteUnits("2M", noop).value(), 2ULL << 20);
    1757                 :             : 
    1758   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(ParseByteUnits("3g", noop).value(), 3'000'000'000ULL);
    1759   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(ParseByteUnits("3G", noop).value(), 3ULL << 30);
    1760                 :             : 
    1761   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(ParseByteUnits("4t", noop).value(), 4'000'000'000'000ULL);
    1762   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(ParseByteUnits("4T", noop).value(), 4ULL << 40);
    1763                 :             : 
    1764                 :             :     // check default multiplier
    1765   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(ParseByteUnits("5", ByteUnit::K).value(), 5ULL << 10);
    1766                 :             : 
    1767                 :             :     // NaN
    1768   [ +  -  +  - ]:           2 :     BOOST_CHECK(!ParseByteUnits("", noop));
    1769   [ +  -  +  - ]:           2 :     BOOST_CHECK(!ParseByteUnits("foo", noop));
    1770                 :             : 
    1771                 :             :     // whitespace
    1772   [ +  -  +  - ]:           2 :     BOOST_CHECK(!ParseByteUnits("123m ", noop));
    1773   [ +  -  +  - ]:           2 :     BOOST_CHECK(!ParseByteUnits(" 123m", noop));
    1774                 :             : 
    1775                 :             :     // no +-
    1776   [ +  -  +  - ]:           2 :     BOOST_CHECK(!ParseByteUnits("-123m", noop));
    1777   [ +  -  +  - ]:           2 :     BOOST_CHECK(!ParseByteUnits("+123m", noop));
    1778                 :             : 
    1779                 :             :     // zero padding
    1780   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(ParseByteUnits("020M", noop).value(), 20ULL << 20);
    1781                 :             : 
    1782                 :             :     // fractions not allowed
    1783   [ +  -  +  - ]:           2 :     BOOST_CHECK(!ParseByteUnits("0.5T", noop));
    1784                 :             : 
    1785                 :             :     // overflow
    1786   [ +  -  +  - ]:           2 :     BOOST_CHECK(!ParseByteUnits("18446744073709551615g", noop));
    1787                 :             : 
    1788                 :             :     // invalid unit
    1789   [ +  -  +  - ]:           2 :     BOOST_CHECK(!ParseByteUnits("1x", noop));
    1790                 :           1 : }
    1791                 :             : 
    1792   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(util_ReadBinaryFile)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1793                 :             : {
    1794                 :           1 :     fs::path tmpfolder = m_args.GetDataDirBase();
    1795   [ +  -  +  - ]:           2 :     fs::path tmpfile = tmpfolder / "read_binary.dat";
    1796                 :           1 :     std::string expected_text;
    1797         [ +  + ]:          31 :     for (int i = 0; i < 30; i++) {
    1798         [ +  - ]:          30 :         expected_text += "0123456789";
    1799                 :             :     }
    1800                 :           1 :     {
    1801         [ +  - ]:           1 :         std::ofstream file{tmpfile};
    1802         [ +  - ]:           1 :         file << expected_text;
    1803                 :           1 :     }
    1804                 :           1 :     {
    1805                 :             :         // read all contents in file
    1806   [ +  -  +  - ]:           1 :         auto [valid, text] = ReadBinaryFile(tmpfile);
    1807   [ +  -  +  -  :           2 :         BOOST_CHECK(valid);
                   +  - ]
    1808   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(text, expected_text);
    1809                 :           0 :     }
    1810                 :           1 :     {
    1811                 :             :         // read half contents in file
    1812   [ +  -  +  - ]:           1 :         auto [valid, text] = ReadBinaryFile(tmpfile, expected_text.size() / 2);
    1813   [ +  -  +  -  :           2 :         BOOST_CHECK(valid);
                   +  - ]
    1814   [ +  -  +  -  :           1 :         BOOST_CHECK_EQUAL(text, expected_text.substr(0, expected_text.size() / 2));
                   +  - ]
    1815                 :           0 :     }
    1816                 :           1 :     {
    1817                 :             :         // read from non-existent file
    1818   [ +  -  +  - ]:           2 :         fs::path invalid_file = tmpfolder / "invalid_binary.dat";
    1819         [ +  - ]:           1 :         auto [valid, text] = ReadBinaryFile(invalid_file);
    1820   [ +  -  +  -  :           2 :         BOOST_CHECK(!valid);
                   +  - ]
    1821   [ +  -  +  - ]:           2 :         BOOST_CHECK(text.empty());
    1822                 :           2 :     }
    1823                 :           3 : }
    1824                 :             : 
    1825   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(util_WriteBinaryFile)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1826                 :             : {
    1827                 :           1 :     fs::path tmpfolder = m_args.GetDataDirBase();
    1828   [ +  -  +  - ]:           2 :     fs::path tmpfile = tmpfolder / "write_binary.dat";
    1829         [ +  - ]:           1 :     std::string expected_text = "bitcoin";
    1830         [ +  - ]:           1 :     auto valid = WriteBinaryFile(tmpfile, expected_text);
    1831         [ +  - ]:           1 :     std::string actual_text;
    1832         [ +  - ]:           1 :     std::ifstream file{tmpfile};
    1833         [ +  - ]:           1 :     file >> actual_text;
    1834   [ +  -  +  -  :           2 :     BOOST_CHECK(valid);
                   +  - ]
    1835   [ +  -  +  - ]:           1 :     BOOST_CHECK_EQUAL(actual_text, expected_text);
    1836                 :           3 : }
    1837                 :             : 
    1838   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(clearshrink_test)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1839                 :             : {
    1840                 :           1 :     {
    1841                 :           1 :         std::vector<uint8_t> v = {1, 2, 3};
    1842                 :           1 :         ClearShrink(v);
    1843   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(v.size(), 0);
    1844   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(v.capacity(), 0);
    1845                 :           0 :     }
    1846                 :             : 
    1847                 :           1 :     {
    1848                 :           1 :         std::vector<bool> v = {false, true, false, false, true, true};
    1849                 :           1 :         ClearShrink(v);
    1850   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(v.size(), 0);
    1851   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(v.capacity(), 0);
    1852                 :           0 :     }
    1853                 :             : 
    1854                 :           1 :     {
    1855                 :           1 :         std::deque<int> v = {1, 3, 3, 7};
    1856                 :           1 :         ClearShrink(v);
    1857   [ +  -  +  - ]:           1 :         BOOST_CHECK_EQUAL(v.size(), 0);
    1858                 :             :         // std::deque has no capacity() we can observe.
    1859                 :           1 :     }
    1860                 :           1 : }
    1861                 :             : 
    1862                 :             : template <typename T>
    1863                 :           5 : void TestCheckedLeftShift()
    1864                 :             : {
    1865                 :           5 :     constexpr auto MAX{std::numeric_limits<T>::max()};
    1866                 :             : 
    1867                 :             :     // Basic operations
    1868         [ +  - ]:           5 :     BOOST_CHECK_EQUAL(CheckedLeftShift<T>(0, 1), 0);
    1869         [ +  - ]:           5 :     BOOST_CHECK_EQUAL(CheckedLeftShift<T>(0, 127), 0);
    1870         [ +  - ]:           5 :     BOOST_CHECK_EQUAL(CheckedLeftShift<T>(1, 1), 2);
    1871         [ +  - ]:           5 :     BOOST_CHECK_EQUAL(CheckedLeftShift<T>(2, 2), 8);
    1872         [ +  - ]:           5 :     BOOST_CHECK_EQUAL(CheckedLeftShift<T>(MAX >> 1, 1), MAX - 1);
    1873                 :             : 
    1874                 :             :     // Max left shift
    1875         [ +  - ]:           5 :     BOOST_CHECK_EQUAL(CheckedLeftShift<T>(1, std::numeric_limits<T>::digits - 1), MAX / 2 + 1);
    1876                 :             : 
    1877                 :             :     // Overflow cases
    1878         [ +  - ]:          10 :     BOOST_CHECK(!CheckedLeftShift<T>((MAX >> 1) + 1, 1));
    1879         [ +  - ]:          10 :     BOOST_CHECK(!CheckedLeftShift<T>(MAX, 1));
    1880         [ +  - ]:          10 :     BOOST_CHECK(!CheckedLeftShift<T>(1, std::numeric_limits<T>::digits));
    1881         [ +  - ]:          10 :     BOOST_CHECK(!CheckedLeftShift<T>(1, std::numeric_limits<T>::digits + 1));
    1882                 :             : 
    1883                 :             :     if constexpr (std::is_signed_v<T>) {
    1884                 :           2 :         constexpr auto MIN{std::numeric_limits<T>::min()};
    1885                 :             :         // Negative input
    1886         [ +  - ]:           2 :         BOOST_CHECK_EQUAL(CheckedLeftShift<T>(-1, 1), -2);
    1887         [ +  - ]:           2 :         BOOST_CHECK_EQUAL(CheckedLeftShift<T>((MIN >> 2), 1), MIN / 2);
    1888         [ +  - ]:           2 :         BOOST_CHECK_EQUAL(CheckedLeftShift<T>((MIN >> 1) + 1, 1), MIN + 2);
    1889         [ +  - ]:           2 :         BOOST_CHECK_EQUAL(CheckedLeftShift<T>(MIN >> 1, 1), MIN);
    1890                 :             :         // Overflow negative
    1891         [ +  - ]:           4 :         BOOST_CHECK(!CheckedLeftShift<T>((MIN >> 1) - 1, 1));
    1892         [ +  - ]:           4 :         BOOST_CHECK(!CheckedLeftShift<T>(MIN >> 1, 2));
    1893         [ +  - ]:           4 :         BOOST_CHECK(!CheckedLeftShift<T>(-1, 100));
    1894                 :             :     }
    1895                 :           5 : }
    1896                 :             : 
    1897                 :             : template <typename T>
    1898                 :           5 : void TestSaturatingLeftShift()
    1899                 :             : {
    1900                 :           5 :     constexpr auto MAX{std::numeric_limits<T>::max()};
    1901                 :             : 
    1902                 :             :     // Basic operations
    1903         [ +  - ]:           5 :     BOOST_CHECK_EQUAL(SaturatingLeftShift<T>(0, 1), 0);
    1904         [ +  - ]:           5 :     BOOST_CHECK_EQUAL(SaturatingLeftShift<T>(0, 127), 0);
    1905         [ +  - ]:           5 :     BOOST_CHECK_EQUAL(SaturatingLeftShift<T>(1, 1), 2);
    1906         [ +  - ]:           5 :     BOOST_CHECK_EQUAL(SaturatingLeftShift<T>(2, 2), 8);
    1907         [ +  - ]:           5 :     BOOST_CHECK_EQUAL(SaturatingLeftShift<T>(MAX >> 1, 1), MAX - 1);
    1908                 :             : 
    1909                 :             :     // Max left shift
    1910         [ +  - ]:           5 :     BOOST_CHECK_EQUAL(SaturatingLeftShift<T>(1, std::numeric_limits<T>::digits - 1), MAX / 2 + 1);
    1911                 :             : 
    1912                 :             :     // Saturation cases
    1913         [ +  - ]:           5 :     BOOST_CHECK_EQUAL(SaturatingLeftShift<T>((MAX >> 1) + 1, 1), MAX);
    1914         [ +  - ]:           5 :     BOOST_CHECK_EQUAL(SaturatingLeftShift<T>(MAX, 1), MAX);
    1915         [ +  - ]:           5 :     BOOST_CHECK_EQUAL(SaturatingLeftShift<T>(1, std::numeric_limits<T>::digits), MAX);
    1916         [ +  - ]:           5 :     BOOST_CHECK_EQUAL(SaturatingLeftShift<T>(1, std::numeric_limits<T>::digits + 1), MAX);
    1917                 :             : 
    1918                 :             :     if constexpr (std::is_signed_v<T>) {
    1919                 :           2 :         constexpr auto MIN{std::numeric_limits<T>::min()};
    1920                 :             :         // Negative input
    1921         [ +  - ]:           2 :         BOOST_CHECK_EQUAL(SaturatingLeftShift<T>(-1, 1), -2);
    1922         [ +  - ]:           2 :         BOOST_CHECK_EQUAL(SaturatingLeftShift<T>((MIN >> 2), 1), MIN / 2);
    1923         [ +  - ]:           2 :         BOOST_CHECK_EQUAL(SaturatingLeftShift<T>((MIN >> 1) + 1, 1), MIN + 2);
    1924         [ +  - ]:           2 :         BOOST_CHECK_EQUAL(SaturatingLeftShift<T>(MIN >> 1, 1), MIN);
    1925                 :             :         // Saturation negative
    1926         [ +  - ]:           2 :         BOOST_CHECK_EQUAL(SaturatingLeftShift<T>((MIN >> 1) - 1, 1), MIN);
    1927         [ +  - ]:           2 :         BOOST_CHECK_EQUAL(SaturatingLeftShift<T>(MIN >> 1, 2), MIN);
    1928         [ +  - ]:           2 :         BOOST_CHECK_EQUAL(SaturatingLeftShift<T>(-1, 100), MIN);
    1929                 :             :     }
    1930                 :           5 : }
    1931                 :             : 
    1932   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(checked_left_shift_test)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1933                 :             : {
    1934                 :           1 :     TestCheckedLeftShift<uint8_t>();
    1935                 :           1 :     TestCheckedLeftShift<int8_t>();
    1936                 :           1 :     TestCheckedLeftShift<size_t>();
    1937                 :           1 :     TestCheckedLeftShift<uint64_t>();
    1938                 :           1 :     TestCheckedLeftShift<int64_t>();
    1939                 :           1 : }
    1940                 :             : 
    1941   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(saturating_left_shift_test)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1942                 :             : {
    1943                 :           1 :     TestSaturatingLeftShift<uint8_t>();
    1944                 :           1 :     TestSaturatingLeftShift<int8_t>();
    1945                 :           1 :     TestSaturatingLeftShift<size_t>();
    1946                 :           1 :     TestSaturatingLeftShift<uint64_t>();
    1947                 :           1 :     TestSaturatingLeftShift<int64_t>();
    1948                 :           1 : }
    1949                 :             : 
    1950   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(mib_string_literal_test)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
    1951                 :             : {
    1952         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(0_MiB, 0);
    1953         [ +  - ]:           1 :     BOOST_CHECK_EQUAL(1_MiB, 1024 * 1024);
    1954                 :           1 :     const auto max_mib{std::numeric_limits<size_t>::max() >> 20};
    1955   [ +  -  -  +  :           2 :     BOOST_CHECK_EXCEPTION(operator""_MiB(static_cast<unsigned long long>(max_mib) + 1), std::overflow_error, HasReason("MiB value too large for size_t byte conversion"));
          -  -  -  -  -  
          +  +  -  +  -  
                   +  - ]
    1956                 :           1 : }
    1957                 :             : 
    1958                 :             : BOOST_AUTO_TEST_SUITE_END()
        

Generated by: LCOV version 2.0-1