src/test/util_tests.cpp

   1 #include <vector>
   2 #include <boost/test/unit_test.hpp>
   3 #include <boost/foreach.hpp>
   4
   5 #include "main.h"
   6 #include "wallet.h"
   7 #include "util.h"
   8
   9 using namespace std;
  10
  11 BOOST_AUTO_TEST_SUITE(util_tests)
  12
  13 BOOST_AUTO_TEST_CASE(util_criticalsection)
  14 {
  15     CCriticalSection cs;
  16
  17     do {
  18         LOCK(cs);
  19         break;
  20
  21         BOOST_ERROR("break was swallowed!");
  22     } while(0);
  23
  24     do {
  25         TRY_LOCK(cs, lockTest);
  26         if (lockTest)
  27             break;
  28
  29         BOOST_ERROR("break was swallowed!");
  30     } while(0);
  31 }
  32
  33 BOOST_AUTO_TEST_CASE(util_MedianFilter)
  34 {
  35     CMedianFilter<int> filter(5, 15);
  36
  37     BOOST_CHECK_EQUAL(filter.median(), 15);
  38
  39     filter.input(20); // [15 20]
  40     BOOST_CHECK_EQUAL(filter.median(), 17);
  41
  42     filter.input(30); // [15 20 30]
  43     BOOST_CHECK_EQUAL(filter.median(), 20);
  44
  45     filter.input(3); // [3 15 20 30]
  46     BOOST_CHECK_EQUAL(filter.median(), 17);
  47
  48     filter.input(7); // [3 7 15 20 30]
  49     BOOST_CHECK_EQUAL(filter.median(), 15);
  50
  51     filter.input(18); // [3 7 18 20 30]
  52     BOOST_CHECK_EQUAL(filter.median(), 18);
  53
  54     filter.input(0); // [0 3 7 18 30]
  55     BOOST_CHECK_EQUAL(filter.median(), 7);
  56 }
  57
  58 static const unsigned char ParseHex_expected[65] = {
  59     0x04, 0x67, 0x8a, 0xfd, 0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67, 0xf1, 0xa6, 0x71, 0x30, 0xb7,
  60     0x10, 0x5c, 0xd6, 0xa8, 0x28, 0xe0, 0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, 0xea, 0x1f, 0x61, 0xde,
  61     0xb6, 0x49, 0xf6, 0xbc, 0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04, 0xe5, 0x1e, 0xc1, 0x12,
  62     0xde, 0x5c, 0x38, 0x4d, 0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, 0x2b, 0x6b, 0xf1, 0x1d,
  63     0x5f
  64 };
  65 BOOST_AUTO_TEST_CASE(util_ParseHex)
  66 {
  67     std::vector<unsigned char> result;
  68     std::vector<unsigned char> expected(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected));
  69     // Basic test vector
  70     result = ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
  71     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
  72
  73     // Spaces between bytes must be supported
  74     result = ParseHex("12 34 56 78");
  75     BOOST_CHECK(result.size() == 4 && result[0] == 0x12 && result[1] == 0x34 && result[2] == 0x56 && result[3] == 0x78);
  76
  77     // Stop parsing at invalid value
  78     result = ParseHex("1234 invalid 1234");
  79     BOOST_CHECK(result.size() == 2 && result[0] == 0x12 && result[1] == 0x34);
  80 }
  81
  82 BOOST_AUTO_TEST_CASE(util_HexStr)
  83 {
  84     BOOST_CHECK_EQUAL(
  85         HexStr(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected)),
  86         "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
  87
  88     BOOST_CHECK_EQUAL(
  89         HexStr(ParseHex_expected, ParseHex_expected + 5, true),
  90         "04 67 8a fd b0");
  91
  92     BOOST_CHECK_EQUAL(
  93         HexStr(ParseHex_expected, ParseHex_expected, true),
  94         "");
  95
  96     std::vector<unsigned char> ParseHex_vec(ParseHex_expected, ParseHex_expected + 5);
  97
  98     BOOST_CHECK_EQUAL(
  99         HexStr(ParseHex_vec, true),
 100         "04 67 8a fd b0");
 101 }
 102
 103
 104 BOOST_AUTO_TEST_CASE(util_DateTimeStrFormat)
 105 {
 106 /*These are platform-dependant and thus removed to avoid useless test failures
 107     BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 0), "1970-01-01 00:00:00");
 108     BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 0x7FFFFFFF), "2038-01-19 03:14:07");
 109     // Formats used within Bitcoin
 110     BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 1317425777), "2011-09-30 23:36:17");
 111     BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M", 1317425777), "2011-09-30 23:36");
 112 */
 113 }
 114
 115 BOOST_AUTO_TEST_CASE(util_ParseParameters)
 116 {
 117     const char *argv_test[] = {"-ignored", "-a", "-b", "-ccc=argument", "-ccc=multiple", "f", "-d=e"};
 118
 119     ParseParameters(0, (char**)argv_test);
 120     BOOST_CHECK(mapArgs.empty() && mapMultiArgs.empty());
 121
 122     ParseParameters(1, (char**)argv_test);
 123     BOOST_CHECK(mapArgs.empty() && mapMultiArgs.empty());
 124
 125     ParseParameters(5, (char**)argv_test);
 126     // expectation: -ignored is ignored (program name argument),
 127     // -a, -b and -ccc end up in map, -d ignored because it is after
 128     // a non-option argument (non-GNU option parsing)
 129     BOOST_CHECK(mapArgs.size() == 3 && mapMultiArgs.size() == 3);
 130     BOOST_CHECK(mapArgs.count("-a") && mapArgs.count("-b") && mapArgs.count("-ccc")
 131                 && !mapArgs.count("f") && !mapArgs.count("-d"));
 132     BOOST_CHECK(mapMultiArgs.count("-a") && mapMultiArgs.count("-b") && mapMultiArgs.count("-ccc")
 133                 && !mapMultiArgs.count("f") && !mapMultiArgs.count("-d"));
 134
 135     BOOST_CHECK(mapArgs["-a"] == "" && mapArgs["-ccc"] == "multiple");
 136     BOOST_CHECK(mapMultiArgs["-ccc"].size() == 2);
 137 }
 138
 139 BOOST_AUTO_TEST_CASE(util_GetArg)
 140 {
 141     mapArgs.clear();
 142     mapArgs["strtest1"] = "string...";
 143     // strtest2 undefined on purpose
 144     mapArgs["inttest1"] = "12345";
 145     mapArgs["inttest2"] = "81985529216486895";
 146     // inttest3 undefined on purpose
 147     mapArgs["booltest1"] = "";
 148     // booltest2 undefined on purpose
 149     mapArgs["booltest3"] = "0";
 150     mapArgs["booltest4"] = "1";
 151
 152     BOOST_CHECK_EQUAL(GetArg("strtest1", "default"), "string...");
 153     BOOST_CHECK_EQUAL(GetArg("strtest2", "default"), "default");
 154     BOOST_CHECK_EQUAL(GetArg("inttest1", -1), 12345);
 155     BOOST_CHECK_EQUAL(GetArg("inttest2", -1), 81985529216486895LL);
 156     BOOST_CHECK_EQUAL(GetArg("inttest3", -1), -1);
 157     BOOST_CHECK_EQUAL(GetBoolArg("booltest1", false), true);
 158     BOOST_CHECK_EQUAL(GetBoolArg("booltest2", false), false);
 159     BOOST_CHECK_EQUAL(GetBoolArg("booltest3", false), false);
 160     BOOST_CHECK_EQUAL(GetBoolArg("booltest4", false), true);
 161 }
 162
 163 BOOST_AUTO_TEST_CASE(util_WildcardMatch)
 164 {
 165     BOOST_CHECK(WildcardMatch("127.0.0.1", "*"));
 166     BOOST_CHECK(WildcardMatch("127.0.0.1", "127.*"));
 167     BOOST_CHECK(WildcardMatch("abcdef", "a?cde?"));
 168     BOOST_CHECK(!WildcardMatch("abcdef", "a?cde??"));
 169     BOOST_CHECK(WildcardMatch("abcdef", "a*f"));
 170     BOOST_CHECK(!WildcardMatch("abcdef", "a*x"));
 171     BOOST_CHECK(WildcardMatch("", "*"));
 172 }
 173
 174 BOOST_AUTO_TEST_CASE(util_FormatMoney)
 175 {
 176     BOOST_CHECK_EQUAL(FormatMoney(0, false), "0.00");
 177     BOOST_CHECK_EQUAL(FormatMoney((COIN/10000)*123456789, false), "12345.6789");
 178     BOOST_CHECK_EQUAL(FormatMoney(COIN, true), "+1.00");
 179     BOOST_CHECK_EQUAL(FormatMoney(-COIN, false), "-1.00");
 180     BOOST_CHECK_EQUAL(FormatMoney(-COIN, true), "-1.00");
 181
 182     BOOST_CHECK_EQUAL(FormatMoney(COIN*100000000, false), "100000000.00");
 183     BOOST_CHECK_EQUAL(FormatMoney(COIN*10000000, false), "10000000.00");
 184     BOOST_CHECK_EQUAL(FormatMoney(COIN*1000000, false), "1000000.00");
 185     BOOST_CHECK_EQUAL(FormatMoney(COIN*100000, false), "100000.00");
 186     BOOST_CHECK_EQUAL(FormatMoney(COIN*10000, false), "10000.00");
 187     BOOST_CHECK_EQUAL(FormatMoney(COIN*1000, false), "1000.00");
 188     BOOST_CHECK_EQUAL(FormatMoney(COIN*100, false), "100.00");
 189     BOOST_CHECK_EQUAL(FormatMoney(COIN*10, false), "10.00");
 190     BOOST_CHECK_EQUAL(FormatMoney(COIN, false), "1.00");
 191     BOOST_CHECK_EQUAL(FormatMoney(COIN/10, false), "0.10");
 192     BOOST_CHECK_EQUAL(FormatMoney(COIN/100, false), "0.01");
 193     BOOST_CHECK_EQUAL(FormatMoney(COIN/1000, false), "0.001");
 194     BOOST_CHECK_EQUAL(FormatMoney(COIN/10000, false), "0.0001");
 195     BOOST_CHECK_EQUAL(FormatMoney(COIN/100000, false), "0.00001");
 196     BOOST_CHECK_EQUAL(FormatMoney(COIN/1000000, false), "0.000001");
 197     BOOST_CHECK_EQUAL(FormatMoney(COIN/10000000, false), "0.0000001");
 198     BOOST_CHECK_EQUAL(FormatMoney(COIN/100000000, false), "0.00000001");
 199 }
 200
 201 BOOST_AUTO_TEST_CASE(util_ParseMoney)
 202 {
 203     int64 ret = 0;
 204     BOOST_CHECK(ParseMoney("0.0", ret));
 205     BOOST_CHECK_EQUAL(ret, 0);
 206
 207     BOOST_CHECK(ParseMoney("12345.6789", ret));
 208     BOOST_CHECK_EQUAL(ret, (COIN/10000)*123456789);
 209
 210     BOOST_CHECK(ParseMoney("100000000.00", ret));
 211     BOOST_CHECK_EQUAL(ret, COIN*100000000);
 212     BOOST_CHECK(ParseMoney("10000000.00", ret));
 213     BOOST_CHECK_EQUAL(ret, COIN*10000000);
 214     BOOST_CHECK(ParseMoney("1000000.00", ret));
 215     BOOST_CHECK_EQUAL(ret, COIN*1000000);
 216     BOOST_CHECK(ParseMoney("100000.00", ret));
 217     BOOST_CHECK_EQUAL(ret, COIN*100000);
 218     BOOST_CHECK(ParseMoney("10000.00", ret));
 219     BOOST_CHECK_EQUAL(ret, COIN*10000);
 220     BOOST_CHECK(ParseMoney("1000.00", ret));
 221     BOOST_CHECK_EQUAL(ret, COIN*1000);
 222     BOOST_CHECK(ParseMoney("100.00", ret));
 223     BOOST_CHECK_EQUAL(ret, COIN*100);
 224     BOOST_CHECK(ParseMoney("10.00", ret));
 225     BOOST_CHECK_EQUAL(ret, COIN*10);
 226     BOOST_CHECK(ParseMoney("1.00", ret));
 227     BOOST_CHECK_EQUAL(ret, COIN);
 228     BOOST_CHECK(ParseMoney("0.1", ret));
 229     BOOST_CHECK_EQUAL(ret, COIN/10);
 230     BOOST_CHECK(ParseMoney("0.01", ret));
 231     BOOST_CHECK_EQUAL(ret, COIN/100);
 232     BOOST_CHECK(ParseMoney("0.001", ret));
 233     BOOST_CHECK_EQUAL(ret, COIN/1000);
 234     BOOST_CHECK(ParseMoney("0.0001", ret));
 235     BOOST_CHECK_EQUAL(ret, COIN/10000);
 236     BOOST_CHECK(ParseMoney("0.00001", ret));
 237     BOOST_CHECK_EQUAL(ret, COIN/100000);
 238     BOOST_CHECK(ParseMoney("0.000001", ret));
 239     BOOST_CHECK_EQUAL(ret, COIN/1000000);
 240     BOOST_CHECK(ParseMoney("0.0000001", ret));
 241     BOOST_CHECK_EQUAL(ret, COIN/10000000);
 242     BOOST_CHECK(ParseMoney("0.00000001", ret));
 243     BOOST_CHECK_EQUAL(ret, COIN/100000000);
 244
 245     // Attempted 63 bit overflow should fail
 246     BOOST_CHECK(!ParseMoney("92233720368.54775808", ret));
 247 }
 248
 249 BOOST_AUTO_TEST_CASE(util_IsHex)
 250 {
 251     BOOST_CHECK(IsHex("00"));
 252     BOOST_CHECK(IsHex("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
 253     BOOST_CHECK(IsHex("ff"));
 254     BOOST_CHECK(IsHex("FF"));
 255
 256     BOOST_CHECK(!IsHex(""));
 257     BOOST_CHECK(!IsHex("0"));
 258     BOOST_CHECK(!IsHex("a"));
 259     BOOST_CHECK(!IsHex("eleven"));
 260     BOOST_CHECK(!IsHex("00xx00"));
 261     BOOST_CHECK(!IsHex("0x0000"));
 262 }
 263
 264 BOOST_AUTO_TEST_CASE(util_seed_insecure_rand)
 265 {
 266     // Expected results for the determinstic seed.
 267     const uint32_t exp_vals[11] = {  91632771U,1889679809U,3842137544U,3256031132U,
 268                                    1761911779U, 489223532U,2692793790U,2737472863U,
 269                                    2796262275U,1309899767U,840571781U};
 270     // Expected 0s in rand()%(idx+2) for the determinstic seed.
 271     const int exp_count[9] = {5013,3346,2415,1972,1644,1386,1176,1096,1009};
 272     int i;
 273     int count=0;
 274
 275     seed_insecure_rand();
 276
 277     //Does the non-determistic rand give us results that look too like the determinstic one?
 278     for (i=0;i<10;i++)
 279     {
 280         int match = 0;
 281         uint32_t rval = insecure_rand();
 282         for (int j=0;j<11;j++)match |= rval==exp_vals[j];
 283         count += match;
 284     }
 285     // sum(binomial(10,i)*(11/(2^32))^i*(1-(11/(2^32)))^(10-i),i,0,4) ~= 1-1/2^134.73
 286     // So _very_ unlikely to throw a false failure here.
 287     BOOST_CHECK(count<=4);
 288
 289     for (int mod=2;mod<11;mod++)
 290     {
 291         int mask = 1;
 292         // Really rough binomal confidence approximation.
 293         int err = 30*10000./mod*sqrt((1./mod*(1-1./mod))/10000.);
 294         //mask is 2^ceil(log2(mod))-1
 295         while(mask<mod-1)mask=(mask<<1)+1;
 296
 297         count = 0;
 298         //How often does it get a zero from the uniform range [0,mod)?
 299         for (i=0;i<10000;i++)
 300         {
 301             uint32_t rval;
 302             do{
 303                 rval=insecure_rand()&mask;
 304             }while(rval>=(uint32_t)mod);
 305             count += rval==0;
 306         }
 307         BOOST_CHECK(count<=10000/mod+err);
 308         BOOST_CHECK(count>=10000/mod-err);
 309     }
 310
 311     seed_insecure_rand(true);
 312
 313     for (i=0;i<11;i++)
 314     {
 315         BOOST_CHECK_EQUAL(insecure_rand(),exp_vals[i]);
 316     }
 317
 318     for (int mod=2;mod<11;mod++)
 319     {
 320         count = 0;
 321         for (i=0;i<10000;i++) count += insecure_rand()%mod==0;
 322         BOOST_CHECK_EQUAL(count,exp_count[mod-2]);
 323     }
 324 }
 325
 326 BOOST_AUTO_TEST_SUITE_END()