src/test/util_tests.cpp

   1 // Copyright (c) 2011-2014 The Bitcoin Core developers
   2 // Distributed under the MIT/X11 software license, see the accompanying
   3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   4
   5 #include "util.h"
   6
   7 #include "clientversion.h"
   8 #include "primitives/transaction.h"
   9 #include "random.h"
  10 #include "sync.h"
  11 #include "utilstrencodings.h"
  12 #include "utilmoneystr.h"
  13
  14 #include <stdint.h>
  15 #include <vector>
  16
  17 #include <boost/test/unit_test.hpp>
  18
  19 using namespace std;
  20
  21 BOOST_AUTO_TEST_SUITE(util_tests)
  22
  23 BOOST_AUTO_TEST_CASE(util_criticalsection)
  24 {
  25     CCriticalSection cs;
  26
  27     do {
  28         LOCK(cs);
  29         break;
  30
  31         BOOST_ERROR("break was swallowed!");
  32     } while(0);
  33
  34     do {
  35         TRY_LOCK(cs, lockTest);
  36         if (lockTest)
  37             break;
  38
  39         BOOST_ERROR("break was swallowed!");
  40     } while(0);
  41 }
  42
  43 static const unsigned char ParseHex_expected[65] = {
  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,
  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");
  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");
  86 }
  87
  88
  89 BOOST_AUTO_TEST_CASE(util_DateTimeStrFormat)
  90 {
  91     BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 0), "1970-01-01 00:00:00");
  92     BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 0x7FFFFFFF), "2038-01-19 03:14:07");
  93     BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 1317425777), "2011-09-30 23:36:17");
  94     BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M", 1317425777), "2011-09-30 23:36");
  95     BOOST_CHECK_EQUAL(DateTimeStrFormat("%a, %d %b %Y %H:%M:%S +0000", 1317425777), "Fri, 30 Sep 2011 23:36:17 +0000");
  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);
 109     // expectation: -ignored is ignored (program name argument),
 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);
 113     BOOST_CHECK(mapArgs.count("-a") && mapArgs.count("-b") && mapArgs.count("-ccc")
 114                 && !mapArgs.count("f") && !mapArgs.count("-d"));
 115     BOOST_CHECK(mapMultiArgs.count("-a") && mapMultiArgs.count("-b") && mapMultiArgs.count("-ccc")
 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);
 138     BOOST_CHECK_EQUAL(GetArg("inttest2", -1), 81985529216486895LL);
 139     BOOST_CHECK_EQUAL(GetArg("inttest3", -1), -1);
 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);
 144 }
 145
 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 {
 175     CAmount ret = 0;
 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));
 219 }
 220
 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
 236 BOOST_AUTO_TEST_CASE(util_seed_insecure_rand)
 237 {
 238     int i;
 239     int count=0;
 240
 241     seed_insecure_rand(true);
 242
 243     for (int mod=2;mod<11;mod++)
 244     {
 245         int mask = 1;
 246         // Really rough binomal confidence approximation.
 247         int err = 30*10000./mod*sqrt((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     }
 264 }
 265
 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
 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 */
 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);
 288
 289     size_t st = 12345678; /* unsigned size_t test value */
 290     ssize_t sst = -12345678; /* signed size_t test value */
 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);
 294
 295     ptrdiff_t pt = 87654321; /* positive ptrdiff_t test value */
 296     ptrdiff_t spt = -87654321; /* negative ptrdiff_t test value */
 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);
 300 }
 301 #undef B
 302 #undef E
 303
 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
 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
 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");
 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.");
 344 }
 345
 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 }
 357 BOOST_AUTO_TEST_SUITE_END()