[VerusCoin.git] / src / test / util_tests.cpp

// Copyright (c) 2011-2014 The Bitcoin 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 "random.h"
#include "sync.h"
#include "utilstrencodings.h"
#include "utilmoneystr.h"

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

#include <boost/test/unit_test.hpp>

using namespace std;

BOOST_AUTO_TEST_SUITE(util_tests)

BOOST_AUTO_TEST_CASE(util_criticalsection)
{
    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)
{
    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);

    // 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_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)
{
    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");
}

BOOST_AUTO_TEST_CASE(util_ParseParameters)
{
    const char *argv_test[] = {"-ignored", "-a", "-b", "-ccc=argument", "-ccc=multiple", "f", "-d=e"};

    ParseParameters(0, (char**)argv_test);
    BOOST_CHECK(mapArgs.empty() && mapMultiArgs.empty());

    ParseParameters(1, (char**)argv_test);
    BOOST_CHECK(mapArgs.empty() && mapMultiArgs.empty());

    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(mapArgs.size() == 3 && mapMultiArgs.size() == 3);
    BOOST_CHECK(mapArgs.count("-a") && mapArgs.count("-b") && mapArgs.count("-ccc")
                && !mapArgs.count("f") && !mapArgs.count("-d"));
    BOOST_CHECK(mapMultiArgs.count("-a") && mapMultiArgs.count("-b") && mapMultiArgs.count("-ccc")
                && !mapMultiArgs.count("f") && !mapMultiArgs.count("-d"));

    BOOST_CHECK(mapArgs["-a"] == "" && mapArgs["-ccc"] == "multiple");
    BOOST_CHECK(mapMultiArgs["-ccc"].size() == 2);
}

BOOST_AUTO_TEST_CASE(util_GetArg)
{
    mapArgs.clear();
    mapArgs["strtest1"] = "string...";
    // strtest2 undefined on purpose
    mapArgs["inttest1"] = "12345";
    mapArgs["inttest2"] = "81985529216486895";
    // inttest3 undefined on purpose
    mapArgs["booltest1"] = "";
    // booltest2 undefined on purpose
    mapArgs["booltest3"] = "0";
    mapArgs["booltest4"] = "1";

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

BOOST_AUTO_TEST_CASE(util_FormatMoney)
{
    BOOST_CHECK_EQUAL(FormatMoney(0, false), "0.00");
    BOOST_CHECK_EQUAL(FormatMoney((COIN/10000)*123456789, false), "12345.6789");
    BOOST_CHECK_EQUAL(FormatMoney(COIN, true), "+1.00");
    BOOST_CHECK_EQUAL(FormatMoney(-COIN, false), "-1.00");
    BOOST_CHECK_EQUAL(FormatMoney(-COIN, true), "-1.00");

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

BOOST_AUTO_TEST_CASE(util_ParseMoney)
{
    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("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));
}

BOOST_AUTO_TEST_CASE(util_IsHex)
{
    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_seed_insecure_rand)
{
    int i;
    int count=0;

    seed_insecure_rand(true);

    for (int mod=2;mod<11;mod++)
    {
        int mask = 1;
        // Really rough binomal 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;

        count = 0;
        //How often does it get a zero from the uniform range [0,mod)?
        for (i=0;i<10000;i++)
        {
            uint32_t rval;
            do{
                rval=insecure_rand()&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)
{
    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)
{
    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)
{
    BOOST_CHECK((GetTime() & ~0xFFFFFFFFLL) == 0);
}

BOOST_AUTO_TEST_CASE(test_ParseInt32)
{
    int32_t n;
    // Valid values
    BOOST_CHECK(ParseInt32("1234", NULL));
    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 == -2147483648);
    BOOST_CHECK(ParseInt32("-1234", &n) && n == -1234);
    // Invalid values
    BOOST_CHECK(!ParseInt32("1a", &n));
    BOOST_CHECK(!ParseInt32("aap", &n));
    BOOST_CHECK(!ParseInt32("0x1", &n)); // no hex
    // Overflow and underflow
    BOOST_CHECK(!ParseInt32("-2147483649", NULL));
    BOOST_CHECK(!ParseInt32("2147483648", NULL));
    BOOST_CHECK(!ParseInt32("-32482348723847471234", NULL));
    BOOST_CHECK(!ParseInt32("32482348723847471234", NULL));
}

BOOST_AUTO_TEST_CASE(test_FormatParagraph)
{
    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");
    BOOST_CHECK_EQUAL(FormatParagraph("This is a very long test string. This is a second sentence in the very long test string."), "This is a very long test string. This is a second sentence in the very long\ntest string.");
}

BOOST_AUTO_TEST_CASE(test_FormatSubVersion)
{
    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(std::string("comment2"));
    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_SUITE_END()
Commit	Line	Data
3fc68461	1	// Copyright (c) 2011-2014 The Bitcoin Core developers
78253fcb	2	// Distributed under the MIT software license, see the accompanying
3fc68461 WL	3	// file COPYING or http://www.opensource.org/licenses/mit-license.php.
3fc68461 WL	4
51ed9ec9 BD	5	#include "util.h"
51ed9ec9 BD	6
71697f97	7	#include "clientversion.h"
d2270111	8	#include "primitives/transaction.h"
6354935c	9	#include "random.h"
51ed9ec9	10	#include "sync.h"
ad49c256 WL	11	#include "utilstrencodings.h"
ad49c256 WL	12	#include "utilmoneystr.h"
51ed9ec9 BD	13
51ed9ec9 BD	14	#include <stdint.h>
a8b95ce6	15	#include <vector>
a8b95ce6	16
51ed9ec9	17	#include <boost/test/unit_test.hpp>
a8b95ce6 WL	18
	19	using namespace std;
	20
	21	BOOST_AUTO_TEST_SUITE(util_tests)
	22
f873b84d CG	23	BOOST_AUTO_TEST_CASE(util_criticalsection)
	24	{
	25	CCriticalSection cs;
	26
	27	do {
f8dcd5ca PW	28	LOCK(cs);
f8dcd5ca PW	29	break;
f873b84d CG	30
	31	BOOST_ERROR("break was swallowed!");
	32	} while(0);
	33
	34	do {
f8dcd5ca PW	35	TRY_LOCK(cs, lockTest);
f8dcd5ca PW	36	if (lockTest)
f873b84d CG	37	break;
	38
	39	BOOST_ERROR("break was swallowed!");
	40	} while(0);
	41	}
	42
2f7f2a5f	43	static const unsigned char ParseHex_expected[65] = {
3260b4c0 PK	44	0x04, 0x67, 0x8a, 0xfd, 0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67, 0xf1, 0xa6, 0x71, 0x30, 0xb7,
	45	0x10, 0x5c, 0xd6, 0xa8, 0x28, 0xe0, 0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, 0xea, 0x1f, 0x61, 0xde,
	46	0xb6, 0x49, 0xf6, 0xbc, 0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04, 0xe5, 0x1e, 0xc1, 0x12,
	47	0xde, 0x5c, 0x38, 0x4d, 0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, 0x2b, 0x6b, 0xf1, 0x1d,
2f7f2a5f WL	48	0x5f
	49	};
	50	BOOST_AUTO_TEST_CASE(util_ParseHex)
	51	{
	52	std::vector<unsigned char> result;
	53	std::vector<unsigned char> expected(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected));
	54	// Basic test vector
	55	result = ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
	56	BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
	57
	58	// Spaces between bytes must be supported
	59	result = ParseHex("12 34 56 78");
	60	BOOST_CHECK(result.size() == 4 && result[0] == 0x12 && result[1] == 0x34 && result[2] == 0x56 && result[3] == 0x78);
	61
	62	// Stop parsing at invalid value
	63	result = ParseHex("1234 invalid 1234");
	64	BOOST_CHECK(result.size() == 2 && result[0] == 0x12 && result[1] == 0x34);
	65	}
	66
	67	BOOST_AUTO_TEST_CASE(util_HexStr)
	68	{
	69	BOOST_CHECK_EQUAL(
	70	HexStr(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected)),
	71	"04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
	72
	73	BOOST_CHECK_EQUAL(
	74	HexStr(ParseHex_expected, ParseHex_expected + 5, true),
	75	"04 67 8a fd b0");
88dc2d6c WL	76
	77	BOOST_CHECK_EQUAL(
	78	HexStr(ParseHex_expected, ParseHex_expected, true),
	79	"");
	80
	81	std::vector<unsigned char> ParseHex_vec(ParseHex_expected, ParseHex_expected + 5);
	82
	83	BOOST_CHECK_EQUAL(
	84	HexStr(ParseHex_vec, true),
	85	"04 67 8a fd b0");
2f7f2a5f WL	86	}
2f7f2a5f WL	87
88dc2d6c	88
2f7f2a5f WL	89	BOOST_AUTO_TEST_CASE(util_DateTimeStrFormat)
2f7f2a5f WL	90	{
ea978851 JG	91	BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 0), "1970-01-01 00:00:00");
ea978851 JG	92	BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 0x7FFFFFFF), "2038-01-19 03:14:07");
ea978851 JG	93	BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 1317425777), "2011-09-30 23:36:17");
ea978851 JG	94	BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M", 1317425777), "2011-09-30 23:36");
3e8ac6af	95	BOOST_CHECK_EQUAL(DateTimeStrFormat("%a, %d %b %Y %H:%M:%S +0000", 1317425777), "Fri, 30 Sep 2011 23:36:17 +0000");
2f7f2a5f WL	96	}
	97
	98	BOOST_AUTO_TEST_CASE(util_ParseParameters)
	99	{
	100	const char *argv_test[] = {"-ignored", "-a", "-b", "-ccc=argument", "-ccc=multiple", "f", "-d=e"};
	101
	102	ParseParameters(0, (char**)argv_test);
	103	BOOST_CHECK(mapArgs.empty() && mapMultiArgs.empty());
	104
	105	ParseParameters(1, (char**)argv_test);
	106	BOOST_CHECK(mapArgs.empty() && mapMultiArgs.empty());
	107
	108	ParseParameters(5, (char**)argv_test);
3260b4c0	109	// expectation: -ignored is ignored (program name argument),
2f7f2a5f WL	110	// -a, -b and -ccc end up in map, -d ignored because it is after
	111	// a non-option argument (non-GNU option parsing)
	112	BOOST_CHECK(mapArgs.size() == 3 && mapMultiArgs.size() == 3);
3260b4c0	113	BOOST_CHECK(mapArgs.count("-a") && mapArgs.count("-b") && mapArgs.count("-ccc")
2f7f2a5f	114	&& !mapArgs.count("f") && !mapArgs.count("-d"));
3260b4c0	115	BOOST_CHECK(mapMultiArgs.count("-a") && mapMultiArgs.count("-b") && mapMultiArgs.count("-ccc")
2f7f2a5f WL	116	&& !mapMultiArgs.count("f") && !mapMultiArgs.count("-d"));
	117
	118	BOOST_CHECK(mapArgs["-a"] == "" && mapArgs["-ccc"] == "multiple");
	119	BOOST_CHECK(mapMultiArgs["-ccc"].size() == 2);
	120	}
	121
	122	BOOST_AUTO_TEST_CASE(util_GetArg)
	123	{
	124	mapArgs.clear();
	125	mapArgs["strtest1"] = "string...";
	126	// strtest2 undefined on purpose
	127	mapArgs["inttest1"] = "12345";
	128	mapArgs["inttest2"] = "81985529216486895";
	129	// inttest3 undefined on purpose
	130	mapArgs["booltest1"] = "";
	131	// booltest2 undefined on purpose
	132	mapArgs["booltest3"] = "0";
	133	mapArgs["booltest4"] = "1";
	134
	135	BOOST_CHECK_EQUAL(GetArg("strtest1", "default"), "string...");
	136	BOOST_CHECK_EQUAL(GetArg("strtest2", "default"), "default");
	137	BOOST_CHECK_EQUAL(GetArg("inttest1", -1), 12345);
35048017	138	BOOST_CHECK_EQUAL(GetArg("inttest2", -1), 81985529216486895LL);
2f7f2a5f	139	BOOST_CHECK_EQUAL(GetArg("inttest3", -1), -1);
3260b4c0 PK	140	BOOST_CHECK_EQUAL(GetBoolArg("booltest1", false), true);
	141	BOOST_CHECK_EQUAL(GetBoolArg("booltest2", false), false);
	142	BOOST_CHECK_EQUAL(GetBoolArg("booltest3", false), false);
	143	BOOST_CHECK_EQUAL(GetBoolArg("booltest4", false), true);
2f7f2a5f WL	144	}
2f7f2a5f WL	145
2f7f2a5f WL	146	BOOST_AUTO_TEST_CASE(util_FormatMoney)
	147	{
	148	BOOST_CHECK_EQUAL(FormatMoney(0, false), "0.00");
	149	BOOST_CHECK_EQUAL(FormatMoney((COIN/10000)*123456789, false), "12345.6789");
	150	BOOST_CHECK_EQUAL(FormatMoney(COIN, true), "+1.00");
	151	BOOST_CHECK_EQUAL(FormatMoney(-COIN, false), "-1.00");
	152	BOOST_CHECK_EQUAL(FormatMoney(-COIN, true), "-1.00");
	153
	154	BOOST_CHECK_EQUAL(FormatMoney(COIN*100000000, false), "100000000.00");
	155	BOOST_CHECK_EQUAL(FormatMoney(COIN*10000000, false), "10000000.00");
	156	BOOST_CHECK_EQUAL(FormatMoney(COIN*1000000, false), "1000000.00");
	157	BOOST_CHECK_EQUAL(FormatMoney(COIN*100000, false), "100000.00");
	158	BOOST_CHECK_EQUAL(FormatMoney(COIN*10000, false), "10000.00");
	159	BOOST_CHECK_EQUAL(FormatMoney(COIN*1000, false), "1000.00");
	160	BOOST_CHECK_EQUAL(FormatMoney(COIN*100, false), "100.00");
	161	BOOST_CHECK_EQUAL(FormatMoney(COIN*10, false), "10.00");
	162	BOOST_CHECK_EQUAL(FormatMoney(COIN, false), "1.00");
	163	BOOST_CHECK_EQUAL(FormatMoney(COIN/10, false), "0.10");
	164	BOOST_CHECK_EQUAL(FormatMoney(COIN/100, false), "0.01");
	165	BOOST_CHECK_EQUAL(FormatMoney(COIN/1000, false), "0.001");
	166	BOOST_CHECK_EQUAL(FormatMoney(COIN/10000, false), "0.0001");
	167	BOOST_CHECK_EQUAL(FormatMoney(COIN/100000, false), "0.00001");
	168	BOOST_CHECK_EQUAL(FormatMoney(COIN/1000000, false), "0.000001");
	169	BOOST_CHECK_EQUAL(FormatMoney(COIN/10000000, false), "0.0000001");
	170	BOOST_CHECK_EQUAL(FormatMoney(COIN/100000000, false), "0.00000001");
	171	}
	172
	173	BOOST_AUTO_TEST_CASE(util_ParseMoney)
	174	{
a372168e	175	CAmount ret = 0;
2f7f2a5f WL	176	BOOST_CHECK(ParseMoney("0.0", ret));
	177	BOOST_CHECK_EQUAL(ret, 0);
	178
	179	BOOST_CHECK(ParseMoney("12345.6789", ret));
	180	BOOST_CHECK_EQUAL(ret, (COIN/10000)*123456789);
	181
	182	BOOST_CHECK(ParseMoney("100000000.00", ret));
	183	BOOST_CHECK_EQUAL(ret, COIN*100000000);
	184	BOOST_CHECK(ParseMoney("10000000.00", ret));
	185	BOOST_CHECK_EQUAL(ret, COIN*10000000);
	186	BOOST_CHECK(ParseMoney("1000000.00", ret));
	187	BOOST_CHECK_EQUAL(ret, COIN*1000000);
	188	BOOST_CHECK(ParseMoney("100000.00", ret));
	189	BOOST_CHECK_EQUAL(ret, COIN*100000);
	190	BOOST_CHECK(ParseMoney("10000.00", ret));
	191	BOOST_CHECK_EQUAL(ret, COIN*10000);
	192	BOOST_CHECK(ParseMoney("1000.00", ret));
	193	BOOST_CHECK_EQUAL(ret, COIN*1000);
	194	BOOST_CHECK(ParseMoney("100.00", ret));
	195	BOOST_CHECK_EQUAL(ret, COIN*100);
	196	BOOST_CHECK(ParseMoney("10.00", ret));
	197	BOOST_CHECK_EQUAL(ret, COIN*10);
	198	BOOST_CHECK(ParseMoney("1.00", ret));
	199	BOOST_CHECK_EQUAL(ret, COIN);
	200	BOOST_CHECK(ParseMoney("0.1", ret));
	201	BOOST_CHECK_EQUAL(ret, COIN/10);
	202	BOOST_CHECK(ParseMoney("0.01", ret));
	203	BOOST_CHECK_EQUAL(ret, COIN/100);
	204	BOOST_CHECK(ParseMoney("0.001", ret));
	205	BOOST_CHECK_EQUAL(ret, COIN/1000);
	206	BOOST_CHECK(ParseMoney("0.0001", ret));
	207	BOOST_CHECK_EQUAL(ret, COIN/10000);
	208	BOOST_CHECK(ParseMoney("0.00001", ret));
	209	BOOST_CHECK_EQUAL(ret, COIN/100000);
	210	BOOST_CHECK(ParseMoney("0.000001", ret));
	211	BOOST_CHECK_EQUAL(ret, COIN/1000000);
	212	BOOST_CHECK(ParseMoney("0.0000001", ret));
	213	BOOST_CHECK_EQUAL(ret, COIN/10000000);
	214	BOOST_CHECK(ParseMoney("0.00000001", ret));
	215	BOOST_CHECK_EQUAL(ret, COIN/100000000);
	216
	217	// Attempted 63 bit overflow should fail
	218	BOOST_CHECK(!ParseMoney("92233720368.54775808", ret));
a8b95ce6 WL	219	}
a8b95ce6 WL	220
922e8e29 GA	221	BOOST_AUTO_TEST_CASE(util_IsHex)
	222	{
	223	BOOST_CHECK(IsHex("00"));
	224	BOOST_CHECK(IsHex("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
	225	BOOST_CHECK(IsHex("ff"));
	226	BOOST_CHECK(IsHex("FF"));
	227
	228	BOOST_CHECK(!IsHex(""));
	229	BOOST_CHECK(!IsHex("0"));
	230	BOOST_CHECK(!IsHex("a"));
	231	BOOST_CHECK(!IsHex("eleven"));
	232	BOOST_CHECK(!IsHex("00xx00"));
	233	BOOST_CHECK(!IsHex("0x0000"));
	234	}
	235
907a2aa4 GM	236	BOOST_AUTO_TEST_CASE(util_seed_insecure_rand)
907a2aa4 GM	237	{
907a2aa4 GM	238	int i;
	239	int count=0;
	240
e5c4dfdf	241	seed_insecure_rand(true);
907a2aa4 GM	242
	243	for (int mod=2;mod<11;mod++)
	244	{
	245	int mask = 1;
	246	// Really rough binomal confidence approximation.
	247	int err = 3010000./modsqrt((1./mod*(1-1./mod))/10000.);
	248	//mask is 2^ceil(log2(mod))-1
	249	while(mask<mod-1)mask=(mask<<1)+1;
	250
	251	count = 0;
	252	//How often does it get a zero from the uniform range [0,mod)?
	253	for (i=0;i<10000;i++)
	254	{
	255	uint32_t rval;
	256	do{
	257	rval=insecure_rand()&mask;
	258	}while(rval>=(uint32_t)mod);
	259	count += rval==0;
	260	}
	261	BOOST_CHECK(count<=10000/mod+err);
	262	BOOST_CHECK(count>=10000/mod-err);
	263	}
907a2aa4 GM	264	}
907a2aa4 GM	265
42656ea2 GA	266	BOOST_AUTO_TEST_CASE(util_TimingResistantEqual)
	267	{
	268	BOOST_CHECK(TimingResistantEqual(std::string(""), std::string("")));
	269	BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("")));
	270	BOOST_CHECK(!TimingResistantEqual(std::string(""), std::string("abc")));
	271	BOOST_CHECK(!TimingResistantEqual(std::string("a"), std::string("aa")));
	272	BOOST_CHECK(!TimingResistantEqual(std::string("aa"), std::string("a")));
	273	BOOST_CHECK(TimingResistantEqual(std::string("abc"), std::string("abc")));
	274	BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("aba")));
	275	}
	276
c82788ef WL	277	/* Test strprintf formatting directives.
	278	* Put a string before and after to ensure sanity of element sizes on stack. */
	279	#define B "check_prefix"
	280	#define E "check_postfix"
	281	BOOST_AUTO_TEST_CASE(strprintf_numbers)
	282	{
	283	int64_t s64t = -9223372036854775807LL; /* signed 64 bit test value */
	284	uint64_t u64t = 18446744073709551615ULL; /* unsigned 64 bit test value */
f48742c2 WL	285	BOOST_CHECK(strprintf("%s %d %s", B, s64t, E) == B" -9223372036854775807 "E);
	286	BOOST_CHECK(strprintf("%s %u %s", B, u64t, E) == B" 18446744073709551615 "E);
	287	BOOST_CHECK(strprintf("%s %x %s", B, u64t, E) == B" ffffffffffffffff "E);
c82788ef WL	288
	289	size_t st = 12345678; /* unsigned size_t test value */
	290	ssize_t sst = -12345678; /* signed size_t test value */
783b182c WL	291	BOOST_CHECK(strprintf("%s %d %s", B, sst, E) == B" -12345678 "E);
	292	BOOST_CHECK(strprintf("%s %u %s", B, st, E) == B" 12345678 "E);
	293	BOOST_CHECK(strprintf("%s %x %s", B, st, E) == B" bc614e "E);
c82788ef WL	294
	295	ptrdiff_t pt = 87654321; /* positive ptrdiff_t test value */
	296	ptrdiff_t spt = -87654321; /* negative ptrdiff_t test value */
783b182c WL	297	BOOST_CHECK(strprintf("%s %d %s", B, spt, E) == B" -87654321 "E);
	298	BOOST_CHECK(strprintf("%s %u %s", B, pt, E) == B" 87654321 "E);
	299	BOOST_CHECK(strprintf("%s %x %s", B, pt, E) == B" 5397fb1 "E);
c82788ef WL	300	}
	301	#undef B
	302	#undef E
	303
eaafa23c WL	304	/* Check for mingw/wine issue #3494
	305	* Remove this test before time.ctime(0xffffffff) == 'Sun Feb 7 07:28:15 2106'
	306	*/
	307	BOOST_AUTO_TEST_CASE(gettime)
	308	{
	309	BOOST_CHECK((GetTime() & ~0xFFFFFFFFLL) == 0);
	310	}
	311
0d4ea1cf WL	312	BOOST_AUTO_TEST_CASE(test_ParseInt32)
	313	{
	314	int32_t n;
	315	// Valid values
	316	BOOST_CHECK(ParseInt32("1234", NULL));
	317	BOOST_CHECK(ParseInt32("0", &n) && n == 0);
	318	BOOST_CHECK(ParseInt32("1234", &n) && n == 1234);
	319	BOOST_CHECK(ParseInt32("01234", &n) && n == 1234); // no octal
	320	BOOST_CHECK(ParseInt32("2147483647", &n) && n == 2147483647);
	321	BOOST_CHECK(ParseInt32("-2147483648", &n) && n == -2147483648);
	322	BOOST_CHECK(ParseInt32("-1234", &n) && n == -1234);
	323	// Invalid values
	324	BOOST_CHECK(!ParseInt32("1a", &n));
	325	BOOST_CHECK(!ParseInt32("aap", &n));
	326	BOOST_CHECK(!ParseInt32("0x1", &n)); // no hex
	327	// Overflow and underflow
	328	BOOST_CHECK(!ParseInt32("-2147483649", NULL));
	329	BOOST_CHECK(!ParseInt32("2147483648", NULL));
	330	BOOST_CHECK(!ParseInt32("-32482348723847471234", NULL));
	331	BOOST_CHECK(!ParseInt32("32482348723847471234", NULL));
	332	}
	333
97789d37 WL	334	BOOST_AUTO_TEST_CASE(test_FormatParagraph)
	335	{
	336	BOOST_CHECK_EQUAL(FormatParagraph("", 79, 0), "");
	337	BOOST_CHECK_EQUAL(FormatParagraph("test", 79, 0), "test");
	338	BOOST_CHECK_EQUAL(FormatParagraph(" test", 79, 0), "test");
	339	BOOST_CHECK_EQUAL(FormatParagraph("test test", 79, 0), "test test");
	340	BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 0), "test\ntest");
	341	BOOST_CHECK_EQUAL(FormatParagraph("testerde test ", 4, 0), "testerde\ntest");
	342	BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 4), "test\n test");
a26bf478	343	BOOST_CHECK_EQUAL(FormatParagraph("This is a very long test string. This is a second sentence in the very long test string."), "This is a very long test string. This is a second sentence in the very long\ntest string.");
97789d37 WL	344	}
97789d37 WL	345
5f4bcf6b CF	346	BOOST_AUTO_TEST_CASE(test_FormatSubVersion)
	347	{
	348	std::vector<std::string> comments;
	349	comments.push_back(std::string("comment1"));
	350	std::vector<std::string> comments2;
	351	comments2.push_back(std::string("comment1"));
	352	comments2.push_back(std::string("comment2"));
	353	BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, std::vector<std::string>()),std::string("/Test:0.9.99/"));
	354	BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, comments),std::string("/Test:0.9.99(comment1)/"));
	355	BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, comments2),std::string("/Test:0.9.99(comment1; comment2)/"));
	356	}
a8b95ce6	357	BOOST_AUTO_TEST_SUITE_END()