util_tests.cpp

// Copyright (c) 2011-2016 The Bitcoin Core developers
// Copyright (c) 2017-2020 The Raven Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include "util.h"

#include "clientversion.h"
#include "primitives/transaction.h"
#include "sync.h"
#include "utilstrencodings.h"
#include "utilmoneystr.h"
#include "test/test_raven.h"

#include <stdint.h>
#include <vector>

#include <boost/test/unit_test.hpp>

BOOST_FIXTURE_TEST_SUITE(util_tests, BasicTestingSetup)

    BOOST_AUTO_TEST_CASE(util_criticalsection_test)
    {
        BOOST_TEST_MESSAGE("Running Util CrriticalSection Test");

        CCriticalSection cs;

        do
        {
            LOCK(cs);
            break;

            BOOST_ERROR("break was swallowed!");
        } while (0);

        do
        {
            TRY_LOCK(cs, lockTest);
            if (lockTest)
                break;

            BOOST_ERROR("break was swallowed!");
        } while (0);
    }

    static const unsigned char ParseHex_expected[65] = {
            0x04, 0x67, 0x8a, 0xfd, 0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67, 0xf1, 0xa6, 0x71, 0x30, 0xb7,
            0x10, 0x5c, 0xd6, 0xa8, 0x28, 0xe0, 0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, 0xea, 0x1f, 0x61, 0xde,
            0xb6, 0x49, 0xf6, 0xbc, 0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04, 0xe5, 0x1e, 0xc1, 0x12,
            0xde, 0x5c, 0x38, 0x4d, 0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, 0x2b, 0x6b, 0xf1, 0x1d,
            0x5f
    };

    BOOST_AUTO_TEST_CASE(util_ParseHex_test)
    {
        BOOST_TEST_MESSAGE("Running Util ParseHex Test");

        std::vector<unsigned char> result;
        std::vector<unsigned char> expected(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected));
        // Basic test vector
        result = ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
        BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());

        // Spaces between bytes must be supported
        result = ParseHex("12 34 56 78");
        BOOST_CHECK(result.size() == 4 && result[0] == 0x12 && result[1] == 0x34 && result[2] == 0x56 && result[3] == 0x78);

        // Leading space must be supported (used in CDBEnv::Salvage)
        result = ParseHex(" 89 34 56 78");
        BOOST_CHECK(result.size() == 4 && result[0] == 0x89 && result[1] == 0x34 && result[2] == 0x56 && result[3] == 0x78);

        // Stop parsing at invalid value
        result = ParseHex("1234 invalid 1234");
        BOOST_CHECK(result.size() == 2 && result[0] == 0x12 && result[1] == 0x34);
    }

    BOOST_AUTO_TEST_CASE(util_HexStr)
    {
        BOOST_TEST_MESSAGE("Running Util ParseHex Test");

        BOOST_CHECK_EQUAL(
                HexStr(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected)),
                "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");

        BOOST_CHECK_EQUAL(
                HexStr(ParseHex_expected, ParseHex_expected + 5, true),
                "04 67 8a fd b0");

        BOOST_CHECK_EQUAL(
                HexStr(ParseHex_expected, ParseHex_expected, true),
                "");

        std::vector<unsigned char> ParseHex_vec(ParseHex_expected, ParseHex_expected + 5);

        BOOST_CHECK_EQUAL(
                HexStr(ParseHex_vec, true),
                "04 67 8a fd b0");
    }


    BOOST_AUTO_TEST_CASE(util_DateTimeStrFormat_test)
    {
        BOOST_TEST_MESSAGE("Running Util DateTimeStrFormat Test");

        BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 0), "1970-01-01 00:00:00");
        BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 0x7FFFFFFF), "2038-01-19 03:14:07");
        BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 1317425777), "2011-09-30 23:36:17");
        BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M", 1317425777), "2011-09-30 23:36");
        BOOST_CHECK_EQUAL(DateTimeStrFormat("%a, %d %b %Y %H:%M:%S +0000", 1317425777), "Fri, 30 Sep 2011 23:36:17 +0000");
    }

    class TestArgsManager : public ArgsManager
    {
    public:
        std::map<std::string, std::string> &GetMapArgs()
        {
            return mapArgs;
        };

        const std::map<std::string, std::vector<std::string> > &GetMapMultiArgs()
        {
            return mapMultiArgs;
        };
    };

    BOOST_AUTO_TEST_CASE(util_ParseParameters_test)
    {
        BOOST_TEST_MESSAGE("Running Util ParseParameters Test");

        TestArgsManager testArgs;
        const char *argv_test[] = {"-ignored", "-a", "-b", "-ccc=argument", "-ccc=multiple", "f", "-d=e"};

        testArgs.ParseParameters(0, (char **) argv_test);
        BOOST_CHECK(testArgs.GetMapArgs().empty() && testArgs.GetMapMultiArgs().empty());

        testArgs.ParseParameters(1, (char **) argv_test);
        BOOST_CHECK(testArgs.GetMapArgs().empty() && testArgs.GetMapMultiArgs().empty());

        testArgs.ParseParameters(5, (char **) argv_test);
        // expectation: -ignored is ignored (program name argument),
        // -a, -b and -ccc end up in map, -d ignored because it is after
        // a non-option argument (non-GNU option parsing)
        BOOST_CHECK(testArgs.GetMapArgs().size() == 3 && testArgs.GetMapMultiArgs().size() == 3);
        BOOST_CHECK(testArgs.IsArgSet("-a") && testArgs.IsArgSet("-b") && testArgs.IsArgSet("-ccc")
                    && !testArgs.IsArgSet("f") && !testArgs.IsArgSet("-d"));
        BOOST_CHECK(testArgs.GetMapMultiArgs().count("-a") && testArgs.GetMapMultiArgs().count("-b") && testArgs.GetMapMultiArgs().count("-ccc")
                    && !testArgs.GetMapMultiArgs().count("f") && !testArgs.GetMapMultiArgs().count("-d"));

        BOOST_CHECK(testArgs.GetMapArgs()["-a"] == "" && testArgs.GetMapArgs()["-ccc"] == "multiple");
        BOOST_CHECK(testArgs.GetArgs("-ccc").size() == 2);
    }

    BOOST_AUTO_TEST_CASE(util_GetArg_test)
    {
        BOOST_TEST_MESSAGE("Running Util GetArg Test");

        TestArgsManager testArgs;
        testArgs.GetMapArgs().clear();
        testArgs.GetMapArgs()["strtest1"] = "string...";
        // strtest2 undefined on purpose
        testArgs.GetMapArgs()["inttest1"] = "12345";
        testArgs.GetMapArgs()["inttest2"] = "81985529216486895";
        // inttest3 undefined on purpose
        testArgs.GetMapArgs()["booltest1"] = "";
        // booltest2 undefined on purpose
        testArgs.GetMapArgs()["booltest3"] = "0";
        testArgs.GetMapArgs()["booltest4"] = "1";

        BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "string...");
        BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "default");
        BOOST_CHECK_EQUAL(testArgs.GetArg("inttest1", -1), 12345);
        BOOST_CHECK_EQUAL(testArgs.GetArg("inttest2", -1), 81985529216486895LL);
        BOOST_CHECK_EQUAL(testArgs.GetArg("inttest3", -1), -1);
        BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", false), true);
        BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest2", false), false);
        BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest3", false), false);
        BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest4", false), true);
    }

    BOOST_AUTO_TEST_CASE(util_FormatMoney_test)
    {
        BOOST_TEST_MESSAGE("Running Util FormatMoney Test");

        BOOST_CHECK_EQUAL(FormatMoney(0), "0.00");
        BOOST_CHECK_EQUAL(FormatMoney((COIN / 10000) * 123456789), "12345.6789");
        BOOST_CHECK_EQUAL(FormatMoney(-COIN), "-1.00");

        BOOST_CHECK_EQUAL(FormatMoney(COIN * 100000000), "100000000.00");
        BOOST_CHECK_EQUAL(FormatMoney(COIN * 10000000), "10000000.00");
        BOOST_CHECK_EQUAL(FormatMoney(COIN * 1000000), "1000000.00");
        BOOST_CHECK_EQUAL(FormatMoney(COIN * 100000), "100000.00");
        BOOST_CHECK_EQUAL(FormatMoney(COIN * 10000), "10000.00");
        BOOST_CHECK_EQUAL(FormatMoney(COIN * 1000), "1000.00");
        BOOST_CHECK_EQUAL(FormatMoney(COIN * 100), "100.00");
        BOOST_CHECK_EQUAL(FormatMoney(COIN * 10), "10.00");
        BOOST_CHECK_EQUAL(FormatMoney(COIN), "1.00");
        BOOST_CHECK_EQUAL(FormatMoney(COIN / 10), "0.10");
        BOOST_CHECK_EQUAL(FormatMoney(COIN / 100), "0.01");
        BOOST_CHECK_EQUAL(FormatMoney(COIN / 1000), "0.001");
        BOOST_CHECK_EQUAL(FormatMoney(COIN / 10000), "0.0001");
        BOOST_CHECK_EQUAL(FormatMoney(COIN / 100000), "0.00001");
        BOOST_CHECK_EQUAL(FormatMoney(COIN / 1000000), "0.000001");
        BOOST_CHECK_EQUAL(FormatMoney(COIN / 10000000), "0.0000001");
        BOOST_CHECK_EQUAL(FormatMoney(COIN / 100000000), "0.00000001");
    }

    BOOST_AUTO_TEST_CASE(util_ParseMoney_test)
    {
        BOOST_TEST_MESSAGE("Running Util ParseMoney Test");

        CAmount ret = 0;
        BOOST_CHECK(ParseMoney("0.0", ret));
        BOOST_CHECK_EQUAL(ret, 0);

        BOOST_CHECK(ParseMoney("12345.6789", ret));
        BOOST_CHECK_EQUAL(ret, (COIN / 10000) * 123456789);

        BOOST_CHECK(ParseMoney("100000000.00", ret));
        BOOST_CHECK_EQUAL(ret, COIN * 100000000);
        BOOST_CHECK(ParseMoney("10000000.00", ret));
        BOOST_CHECK_EQUAL(ret, COIN * 10000000);
        BOOST_CHECK(ParseMoney("1000000.00", ret));
        BOOST_CHECK_EQUAL(ret, COIN * 1000000);
        BOOST_CHECK(ParseMoney("100000.00", ret));
        BOOST_CHECK_EQUAL(ret, COIN * 100000);
        BOOST_CHECK(ParseMoney("10000.00", ret));
        BOOST_CHECK_EQUAL(ret, COIN * 10000);
        BOOST_CHECK(ParseMoney("1000.00", ret));
        BOOST_CHECK_EQUAL(ret, COIN * 1000);
        BOOST_CHECK(ParseMoney("100.00", ret));
        BOOST_CHECK_EQUAL(ret, COIN * 100);
        BOOST_CHECK(ParseMoney("10.00", ret));
        BOOST_CHECK_EQUAL(ret, COIN * 10);
        BOOST_CHECK(ParseMoney("1.00", ret));
        BOOST_CHECK_EQUAL(ret, COIN);
        BOOST_CHECK(ParseMoney("1", ret));
        BOOST_CHECK_EQUAL(ret, COIN);
        BOOST_CHECK(ParseMoney("0.1", ret));
        BOOST_CHECK_EQUAL(ret, COIN / 10);
        BOOST_CHECK(ParseMoney("0.01", ret));
        BOOST_CHECK_EQUAL(ret, COIN / 100);
        BOOST_CHECK(ParseMoney("0.001", ret));
        BOOST_CHECK_EQUAL(ret, COIN / 1000);
        BOOST_CHECK(ParseMoney("0.0001", ret));
        BOOST_CHECK_EQUAL(ret, COIN / 10000);
        BOOST_CHECK(ParseMoney("0.00001", ret));
        BOOST_CHECK_EQUAL(ret, COIN / 100000);
        BOOST_CHECK(ParseMoney("0.000001", ret));
        BOOST_CHECK_EQUAL(ret, COIN / 1000000);
        BOOST_CHECK(ParseMoney("0.0000001", ret));
        BOOST_CHECK_EQUAL(ret, COIN / 10000000);
        BOOST_CHECK(ParseMoney("0.00000001", ret));
        BOOST_CHECK_EQUAL(ret, COIN / 100000000);

        // Attempted 63 bit overflow should fail
        BOOST_CHECK(!ParseMoney("92233720368.54775808", ret));

        // Parsing negative amounts must fail
        BOOST_CHECK(!ParseMoney("-1", ret));
    }

    BOOST_AUTO_TEST_CASE(util_IsHex_test)
    {
        BOOST_TEST_MESSAGE("Running Util_IsHex Test");

        BOOST_CHECK(IsHex("00"));
        BOOST_CHECK(IsHex("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
        BOOST_CHECK(IsHex("ff"));
        BOOST_CHECK(IsHex("FF"));

        BOOST_CHECK(!IsHex(""));
        BOOST_CHECK(!IsHex("0"));
        BOOST_CHECK(!IsHex("a"));
        BOOST_CHECK(!IsHex("eleven"));
        BOOST_CHECK(!IsHex("00xx00"));
        BOOST_CHECK(!IsHex("0x0000"));
    }

    BOOST_AUTO_TEST_CASE(util_IsHexNumber_test)
    {
        BOOST_TEST_MESSAGE("Running IsHexNumber Test");

        BOOST_CHECK(IsHexNumber("0x0"));
        BOOST_CHECK(IsHexNumber("0"));
        BOOST_CHECK(IsHexNumber("0x10"));
        BOOST_CHECK(IsHexNumber("10"));
        BOOST_CHECK(IsHexNumber("0xff"));
        BOOST_CHECK(IsHexNumber("ff"));
        BOOST_CHECK(IsHexNumber("0xFfa"));
        BOOST_CHECK(IsHexNumber("Ffa"));
        BOOST_CHECK(IsHexNumber("0x00112233445566778899aabbccddeeffAABBCCDDEEFF"));
        BOOST_CHECK(IsHexNumber("00112233445566778899aabbccddeeffAABBCCDDEEFF"));

        BOOST_CHECK(!IsHexNumber(""));   // empty string not allowed
        BOOST_CHECK(!IsHexNumber("0x")); // empty string after prefix not allowed
        BOOST_CHECK(!IsHexNumber("0x0 ")); // no spaces at end,
        BOOST_CHECK(!IsHexNumber(" 0x0")); // or beginning,
        BOOST_CHECK(!IsHexNumber("0x 0")); // or middle,
        BOOST_CHECK(!IsHexNumber(" "));    // etc.
        BOOST_CHECK(!IsHexNumber("0x0ga")); // invalid character
        BOOST_CHECK(!IsHexNumber("x0"));    // broken prefix
        BOOST_CHECK(!IsHexNumber("0x0x00")); // two prefixes not allowed

    }

    BOOST_AUTO_TEST_CASE(util_seed_insecure_rand_test)
    {
        BOOST_TEST_MESSAGE("Running Util Seed Insecure Rand Test");

        SeedInsecureRand(true);
        for (int mod = 2; mod < 11; mod++)
        {
            int mask = 1;
            // Really rough binomial confidence approximation.
            int err = 30 * 10000. / mod * sqrt((1. / mod * (1 - 1. / mod)) / 10000.);
            //mask is 2^ceil(log2(mod))-1
            while (mask < mod - 1)mask = (mask << 1) + 1;

            int count = 0;
            //How often does it get a zero from the uniform range [0,mod)?
            for (int i = 0; i < 10000; i++)
            {
                uint32_t rval;
                do
                {
                    rval = InsecureRand32() & mask;
                } while (rval >= (uint32_t) mod);
                count += rval == 0;
            }
            BOOST_CHECK(count <= 10000 / mod + err);
            BOOST_CHECK(count >= 10000 / mod - err);
        }
    }

    BOOST_AUTO_TEST_CASE(util_TimingResistantEqual_test)
    {
        BOOST_TEST_MESSAGE("Running TimingResistantEqual Test");

        BOOST_CHECK(TimingResistantEqual(std::string(""), std::string("")));
        BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("")));
        BOOST_CHECK(!TimingResistantEqual(std::string(""), std::string("abc")));
        BOOST_CHECK(!TimingResistantEqual(std::string("a"), std::string("aa")));
        BOOST_CHECK(!TimingResistantEqual(std::string("aa"), std::string("a")));
        BOOST_CHECK(TimingResistantEqual(std::string("abc"), std::string("abc")));
        BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("aba")));
    }

/* Test strprintf formatting directives.
 * Put a string before and after to ensure sanity of element sizes on stack. */
#define B "check_prefix"
#define E "check_postfix"

    BOOST_AUTO_TEST_CASE(strprintf_numbers_test)
    {
        BOOST_TEST_MESSAGE("Running StrPrintf Numbers Test");

        int64_t s64t = -9223372036854775807LL; /* signed 64 bit test value */
        uint64_t u64t = 18446744073709551615ULL; /* unsigned 64 bit test value */
        BOOST_CHECK(strprintf("%s %d %s", B, s64t, E) == B" -9223372036854775807 " E);
        BOOST_CHECK(strprintf("%s %u %s", B, u64t, E) == B" 18446744073709551615 " E);
        BOOST_CHECK(strprintf("%s %x %s", B, u64t, E) == B" ffffffffffffffff " E);

        size_t st = 12345678; /* unsigned size_t test value */
        ssize_t sst = -12345678; /* signed size_t test value */
        BOOST_CHECK(strprintf("%s %d %s", B, sst, E) == B" -12345678 " E);
        BOOST_CHECK(strprintf("%s %u %s", B, st, E) == B" 12345678 " E);
        BOOST_CHECK(strprintf("%s %x %s", B, st, E) == B" bc614e " E);

        ptrdiff_t pt = 87654321; /* positive ptrdiff_t test value */
        ptrdiff_t spt = -87654321; /* negative ptrdiff_t test value */
        BOOST_CHECK(strprintf("%s %d %s", B, spt, E) == B" -87654321 " E);
        BOOST_CHECK(strprintf("%s %u %s", B, pt, E) == B" 87654321 " E);
        BOOST_CHECK(strprintf("%s %x %s", B, pt, E) == B" 5397fb1 " E);
    }

#undef B
#undef E

    /* Check for mingw/wine issue #3494
     * Remove this test before time.ctime(0xffffffff) == 'Sun Feb  7 07:28:15 2106'
     */
    BOOST_AUTO_TEST_CASE(gettime_test)
    {
        BOOST_TEST_MESSAGE("Running GetTime Test");

        BOOST_CHECK((GetTime() & ~0xFFFFFFFFLL) == 0);
    }

    BOOST_AUTO_TEST_CASE(ParseInt32_test)
    {
        BOOST_TEST_MESSAGE("Running ParseInt32 Test");

        int32_t n;
        // Valid values
        BOOST_CHECK(ParseInt32("1234", nullptr));
        BOOST_CHECK(ParseInt32("0", &n) && n == 0);
        BOOST_CHECK(ParseInt32("1234", &n) && n == 1234);
        BOOST_CHECK(ParseInt32("01234", &n) && n == 1234); // no octal
        BOOST_CHECK(ParseInt32("2147483647", &n) && n == 2147483647);
        BOOST_CHECK(ParseInt32("-2147483648", &n) && n == (-2147483647 - 1)); // (-2147483647 - 1) equals INT_MIN
        BOOST_CHECK(ParseInt32("-1234", &n) && n == -1234);
        // Invalid values
        BOOST_CHECK(!ParseInt32("", &n));
        BOOST_CHECK(!ParseInt32(" 1", &n)); // no padding inside
        BOOST_CHECK(!ParseInt32("1 ", &n));
        BOOST_CHECK(!ParseInt32("1a", &n));
        BOOST_CHECK(!ParseInt32("aap", &n));
        BOOST_CHECK(!ParseInt32("0x1", &n)); // no hex
        BOOST_CHECK(!ParseInt32("0x1", &n)); // no hex
        const char test_bytes[] = {'1', 0, '1'};
        std::string teststr(test_bytes, sizeof(test_bytes));
        BOOST_CHECK(!ParseInt32(teststr, &n)); // no embedded NULs
        // Overflow and underflow
        BOOST_CHECK(!ParseInt32("-2147483649", nullptr));
        BOOST_CHECK(!ParseInt32("2147483648", nullptr));
        BOOST_CHECK(!ParseInt32("-32482348723847471234", nullptr));
        BOOST_CHECK(!ParseInt32("32482348723847471234", nullptr));
    }

    BOOST_AUTO_TEST_CASE(ParseInt64_test)
    {
        BOOST_TEST_MESSAGE("Running ParseInt64 Test");

        int64_t n;
        // Valid values
        BOOST_CHECK(ParseInt64("1234", nullptr));
        BOOST_CHECK(ParseInt64("0", &n) && n == 0LL);
        BOOST_CHECK(ParseInt64("1234", &n) && n == 1234LL);
        BOOST_CHECK(ParseInt64("01234", &n) && n == 1234LL); // no octal
        BOOST_CHECK(ParseInt64("2147483647", &n) && n == 2147483647LL);
        BOOST_CHECK(ParseInt64("-2147483648", &n) && n == -2147483648LL);
        BOOST_CHECK(ParseInt64("9223372036854775807", &n) && n == (int64_t) 9223372036854775807);
        BOOST_CHECK(ParseInt64("-9223372036854775808", &n) && n == (int64_t) -9223372036854775807 - 1);
        BOOST_CHECK(ParseInt64("-1234", &n) && n == -1234LL);
        // Invalid values
        BOOST_CHECK(!ParseInt64("", &n));
        BOOST_CHECK(!ParseInt64(" 1", &n)); // no padding inside
        BOOST_CHECK(!ParseInt64("1 ", &n));
        BOOST_CHECK(!ParseInt64("1a", &n));
        BOOST_CHECK(!ParseInt64("aap", &n));
        BOOST_CHECK(!ParseInt64("0x1", &n)); // no hex
        const char test_bytes[] = {'1', 0, '1'};
        std::string teststr(test_bytes, sizeof(test_bytes));
        BOOST_CHECK(!ParseInt64(teststr, &n)); // no embedded NULs
        // Overflow and underflow
        BOOST_CHECK(!ParseInt64("-9223372036854775809", nullptr));
        BOOST_CHECK(!ParseInt64("9223372036854775808", nullptr));
        BOOST_CHECK(!ParseInt64("-32482348723847471234", nullptr));
        BOOST_CHECK(!ParseInt64("32482348723847471234", nullptr));
    }

    BOOST_AUTO_TEST_CASE(ParseUInt32_test)
    {
        BOOST_TEST_MESSAGE("Running ParseUInt32 Test");

        uint32_t n;
        // Valid values
        BOOST_CHECK(ParseUInt32("1234", nullptr));
        BOOST_CHECK(ParseUInt32("0", &n) && n == 0);
        BOOST_CHECK(ParseUInt32("1234", &n) && n == 1234);
        BOOST_CHECK(ParseUInt32("01234", &n) && n == 1234); // no octal
        BOOST_CHECK(ParseUInt32("2147483647", &n) && n == 2147483647);
        BOOST_CHECK(ParseUInt32("2147483648", &n) && n == (uint32_t) 2147483648);
        BOOST_CHECK(ParseUInt32("4294967295", &n) && n == (uint32_t) 4294967295);
        // Invalid values
        BOOST_CHECK(!ParseUInt32("", &n));
        BOOST_CHECK(!ParseUInt32(" 1", &n)); // no padding inside
        BOOST_CHECK(!ParseUInt32(" -1", &n));
        BOOST_CHECK(!ParseUInt32("1 ", &n));
        BOOST_CHECK(!ParseUInt32("1a", &n));
        BOOST_CHECK(!ParseUInt32("aap", &n));
        BOOST_CHECK(!ParseUInt32("0x1", &n)); // no hex
        BOOST_CHECK(!ParseUInt32("0x1", &n)); // no hex
        const char test_bytes[] = {'1', 0, '1'};
        std::string teststr(test_bytes, sizeof(test_bytes));
        BOOST_CHECK(!ParseUInt32(teststr, &n)); // no embedded NULs
        // Overflow and underflow
        BOOST_CHECK(!ParseUInt32("-2147483648", &n));
        BOOST_CHECK(!ParseUInt32("4294967296", &n));
        BOOST_CHECK(!ParseUInt32("-1234", &n));
        BOOST_CHECK(!ParseUInt32("-32482348723847471234", nullptr));
        BOOST_CHECK(!ParseUInt32("32482348723847471234", nullptr));
    }

    BOOST_AUTO_TEST_CASE(ParseUInt64_test)
    {
        BOOST_TEST_MESSAGE("Running ParseUInt64 Test");

        uint64_t n;
        // Valid values
        BOOST_CHECK(ParseUInt64("1234", nullptr));
        BOOST_CHECK(ParseUInt64("0", &n) && n == 0LL);
        BOOST_CHECK(ParseUInt64("1234", &n) && n == 1234LL);
        BOOST_CHECK(ParseUInt64("01234", &n) && n == 1234LL); // no octal
        BOOST_CHECK(ParseUInt64("2147483647", &n) && n == 2147483647LL);
        BOOST_CHECK(ParseUInt64("9223372036854775807", &n) && n == 9223372036854775807ULL);
        BOOST_CHECK(ParseUInt64("9223372036854775808", &n) && n == 9223372036854775808ULL);
        BOOST_CHECK(ParseUInt64("18446744073709551615", &n) && n == 18446744073709551615ULL);
        // Invalid values
        BOOST_CHECK(!ParseUInt64("", &n));
        BOOST_CHECK(!ParseUInt64(" 1", &n)); // no padding inside
        BOOST_CHECK(!ParseUInt64(" -1", &n));
        BOOST_CHECK(!ParseUInt64("1 ", &n));
        BOOST_CHECK(!ParseUInt64("1a", &n));
        BOOST_CHECK(!ParseUInt64("aap", &n));
        BOOST_CHECK(!ParseUInt64("0x1", &n)); // no hex
        const char test_bytes[] = {'1', 0, '1'};
        std::string teststr(test_bytes, sizeof(test_bytes));
        BOOST_CHECK(!ParseUInt64(teststr, &n)); // no embedded NULs
        // Overflow and underflow
        BOOST_CHECK(!ParseUInt64("-9223372036854775809", nullptr));
        BOOST_CHECK(!ParseUInt64("18446744073709551616", nullptr));
        BOOST_CHECK(!ParseUInt64("-32482348723847471234", nullptr));
        BOOST_CHECK(!ParseUInt64("-2147483648", &n));
        BOOST_CHECK(!ParseUInt64("-9223372036854775808", &n));
        BOOST_CHECK(!ParseUInt64("-1234", &n));


        // HEX Tests (base 16)
        BOOST_CHECK(ParseUInt64("0x7FFFFFFFFFFFFFFF", &n, 16) && n == 9223372036854775807ULL);
        BOOST_CHECK(ParseUInt64("0x8000000000000000", &n, 16) && n == 9223372036854775808ULL);
        BOOST_CHECK(ParseUInt64("0xFFFFFFFFFFFFFFFF", &n, 16) && n == 18446744073709551615ULL);
        BOOST_CHECK(ParseUInt64("0x04D2", nullptr, 16));
        BOOST_CHECK(ParseUInt64("0x0", &n, 16) && n == 0LL);
        BOOST_CHECK(ParseUInt64("0x04D2", &n, 16) && n == 1234LL);
        BOOST_CHECK(ParseUInt64("0x7FFFFFFF", &n, 16) && n == 2147483647LL);
        BOOST_CHECK(!ParseUInt64("9223372036854775807", &n, 16)); //no base 10 when base 16,

    }

    BOOST_AUTO_TEST_CASE(ParseDouble_test)
    {
        BOOST_TEST_MESSAGE("Running ParseDouble Test");

        double n;
        // Valid values
        BOOST_CHECK(ParseDouble("1234", nullptr));
        BOOST_CHECK(ParseDouble("0", &n) && n == 0.0);
        BOOST_CHECK(ParseDouble("1234", &n) && n == 1234.0);
        BOOST_CHECK(ParseDouble("01234", &n) && n == 1234.0); // no octal
        BOOST_CHECK(ParseDouble("2147483647", &n) && n == 2147483647.0);
        BOOST_CHECK(ParseDouble("-2147483648", &n) && n == -2147483648.0);
        BOOST_CHECK(ParseDouble("-1234", &n) && n == -1234.0);
        BOOST_CHECK(ParseDouble("1e6", &n) && n == 1e6);
        BOOST_CHECK(ParseDouble("-1e6", &n) && n == -1e6);
        // Invalid values
        BOOST_CHECK(!ParseDouble("", &n));
        BOOST_CHECK(!ParseDouble(" 1", &n)); // no padding inside
        BOOST_CHECK(!ParseDouble("1 ", &n));
        BOOST_CHECK(!ParseDouble("1a", &n));
        BOOST_CHECK(!ParseDouble("aap", &n));
        BOOST_CHECK(!ParseDouble("0x1", &n)); // no hex
        const char test_bytes[] = {'1', 0, '1'};
        std::string teststr(test_bytes, sizeof(test_bytes));
        BOOST_CHECK(!ParseDouble(teststr, &n)); // no embedded NULs
        // Overflow and underflow
        BOOST_CHECK(!ParseDouble("-1e10000", nullptr));
        BOOST_CHECK(!ParseDouble("1e10000", nullptr));
    }

    BOOST_AUTO_TEST_CASE(FormatParagraph_test)
    {
        BOOST_TEST_MESSAGE("Running FormatParagraph Test");
        BOOST_CHECK_EQUAL(FormatParagraph("", 79, 0), "");
        BOOST_CHECK_EQUAL(FormatParagraph("test", 79, 0), "test");
        BOOST_CHECK_EQUAL(FormatParagraph(" test", 79, 0), " test");
        BOOST_CHECK_EQUAL(FormatParagraph("test test", 79, 0), "test test");
        BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 0), "test\ntest");
        BOOST_CHECK_EQUAL(FormatParagraph("testerde test", 4, 0), "testerde\ntest");
        BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 4), "test\n    test");

        // Make sure we don't indent a fully-new line following a too-long line ending
        BOOST_CHECK_EQUAL(FormatParagraph("test test\nabc", 4, 4), "test\n    test\nabc");

        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");

        // Test wrap length is exact
        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");
        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");
        // Indent should be included in length of lines
        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");

        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.");
        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.");
        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.");
        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.");
    }

    BOOST_AUTO_TEST_CASE(FormatSubVersion_Test)
    {
        BOOST_TEST_MESSAGE("Running FormatSubVersion Test");

        std::vector<std::string> comments;
        comments.push_back(std::string("comment1"));
        std::vector<std::string> comments2;
        comments2.push_back(std::string("comment1"));
        comments2.push_back(SanitizeString(std::string("Comment2; .,_?@-; !\"#$%&'()*+/<=>[]\\^`{|}~"), SAFE_CHARS_UA_COMMENT)); // Semicolon is discouraged but not forbidden by BIP-0014
        BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, std::vector<std::string>()), std::string("/Test:0.9.99/"));
        BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, comments), std::string("/Test:0.9.99(comment1)/"));
        BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, comments2), std::string("/Test:0.9.99(comment1; Comment2; .,_?@-; )/"));
    }

    BOOST_AUTO_TEST_CASE(ParseFixedPoint_test)
    {
        BOOST_TEST_MESSAGE("Running ParseFixedPoint Test");

        int64_t amount = 0;
        BOOST_CHECK(ParseFixedPoint("0", 8, &amount));
        BOOST_CHECK_EQUAL(amount, 0LL);
        BOOST_CHECK(ParseFixedPoint("1", 8, &amount));
        BOOST_CHECK_EQUAL(amount, 100000000LL);
        BOOST_CHECK(ParseFixedPoint("0.0", 8, &amount));
        BOOST_CHECK_EQUAL(amount, 0LL);
        BOOST_CHECK(ParseFixedPoint("-0.1", 8, &amount));
        BOOST_CHECK_EQUAL(amount, -10000000LL);
        BOOST_CHECK(ParseFixedPoint("1.1", 8, &amount));
        BOOST_CHECK_EQUAL(amount, 110000000LL);
        BOOST_CHECK(ParseFixedPoint("1.10000000000000000", 8, &amount));
        BOOST_CHECK_EQUAL(amount, 110000000LL);
        BOOST_CHECK(ParseFixedPoint("1.1e1", 8, &amount));
        BOOST_CHECK_EQUAL(amount, 1100000000LL);
        BOOST_CHECK(ParseFixedPoint("1.1e-1", 8, &amount));
        BOOST_CHECK_EQUAL(amount, 11000000LL);
        BOOST_CHECK(ParseFixedPoint("1000", 8, &amount));
        BOOST_CHECK_EQUAL(amount, 100000000000LL);
        BOOST_CHECK(ParseFixedPoint("-1000", 8, &amount));
        BOOST_CHECK_EQUAL(amount, -100000000000LL);
        BOOST_CHECK(ParseFixedPoint("0.00000001", 8, &amount));
        BOOST_CHECK_EQUAL(amount, 1LL);
        BOOST_CHECK(ParseFixedPoint("0.0000000100000000", 8, &amount));
        BOOST_CHECK_EQUAL(amount, 1LL);
        BOOST_CHECK(ParseFixedPoint("-0.00000001", 8, &amount));
        BOOST_CHECK_EQUAL(amount, -1LL);
        BOOST_CHECK(ParseFixedPoint("1000000000.00000001", 8, &amount));
        BOOST_CHECK_EQUAL(amount, 100000000000000001LL);
        BOOST_CHECK(ParseFixedPoint("9999999999.99999999", 8, &amount));
        BOOST_CHECK_EQUAL(amount, 999999999999999999LL);
        BOOST_CHECK(ParseFixedPoint("-9999999999.99999999", 8, &amount));
        BOOST_CHECK_EQUAL(amount, -999999999999999999LL);

        BOOST_CHECK(!ParseFixedPoint("", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("-", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("a-1000", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("-a1000", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("-1000a", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("-01000", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("00.1", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint(".1", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("--0.1", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("0.000000001", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("-0.000000001", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("0.00000001000000001", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("-10000000000.00000000", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("10000000000.00000000", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("-10000000000.00000001", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("10000000000.00000001", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("-10000000000.00000009", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("10000000000.00000009", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("-99999999999.99999999", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("99999909999.09999999", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("92233720368.54775807", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("92233720368.54775808", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("-92233720368.54775808", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("-92233720368.54775809", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("1.1e", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("1.1e-", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("1.", 8, &amount));

        BOOST_CHECK(ParseFixedPoint("21000000000", 8, &amount));
        BOOST_CHECK(ParseFixedPoint("42000000000", 8, &amount));
        BOOST_CHECK(!ParseFixedPoint("42000000001", 8, &amount));
    }

BOOST_AUTO_TEST_SUITE_END()