src/test/util_tests.cpp

   1 #include <stdint.h>
   2
   3 #include <vector>
   4 #include <boost/test/unit_test.hpp>
   5 #include <boost/foreach.hpp>
   6
   7 #include "main.h"
   8 #include "wallet.h"
   9 #include "util.h"
  10
  11 using namespace std;
  12
  13 BOOST_AUTO_TEST_SUITE(util_tests)
  14
  15 BOOST_AUTO_TEST_CASE(util_criticalsection)
  16 {
  17     CCriticalSection cs;
  18
  19     do {
  20         CRITICAL_BLOCK(cs)
  21             break;
  22
  23         BOOST_ERROR("break was swallowed!");
  24     } while(0);
  25
  26     do {
  27         TRY_CRITICAL_BLOCK(cs)
  28             break;
  29
  30         BOOST_ERROR("break was swallowed!");
  31     } while(0);
  32 }
  33
  34 BOOST_AUTO_TEST_CASE(util_MedianFilter)
  35 {
  36     CMedianFilter<int> filter(5, 15);
  37
  38     BOOST_CHECK_EQUAL(filter.median(), 15);
  39
  40     filter.input(20); // [15 20]
  41     BOOST_CHECK_EQUAL(filter.median(), 17);
  42
  43     filter.input(30); // [15 20 30]
  44     BOOST_CHECK_EQUAL(filter.median(), 20);
  45
  46     filter.input(3); // [3 15 20 30]
  47     BOOST_CHECK_EQUAL(filter.median(), 17);
  48
  49     filter.input(7); // [3 7 15 20 30]
  50     BOOST_CHECK_EQUAL(filter.median(), 15);
  51
  52     filter.input(18); // [3 7 18 20 30]
  53     BOOST_CHECK_EQUAL(filter.median(), 18);
  54
  55     filter.input(0); // [0 3 7 18 30]
  56     BOOST_CHECK_EQUAL(filter.median(), 7);
  57 }
  58
  59 static const unsigned char ParseHex_expected[65] = {
  60     0x04, 0x67, 0x8a, 0xfd, 0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67, 0xf1, 0xa6, 0x71, 0x30, 0xb7,
  61     0x10, 0x5c, 0xd6, 0xa8, 0x28, 0xe0, 0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, 0xea, 0x1f, 0x61, 0xde,
  62     0xb6, 0x49, 0xf6, 0xbc, 0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04, 0xe5, 0x1e, 0xc1, 0x12,
  63     0xde, 0x5c, 0x38, 0x4d, 0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, 0x2b, 0x6b, 0xf1, 0x1d,
  64     0x5f
  65 };
  66 BOOST_AUTO_TEST_CASE(util_ParseHex)
  67 {
  68     std::vector<unsigned char> result;
  69     std::vector<unsigned char> expected(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected));
  70     // Basic test vector
  71     result = ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
  72     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
  73
  74     // Spaces between bytes must be supported
  75     result = ParseHex("12 34 56 78");
  76     BOOST_CHECK(result.size() == 4 && result[0] == 0x12 && result[1] == 0x34 && result[2] == 0x56 && result[3] == 0x78);
  77
  78     // Stop parsing at invalid value
  79     result = ParseHex("1234 invalid 1234");
  80     BOOST_CHECK(result.size() == 2 && result[0] == 0x12 && result[1] == 0x34);
  81 }
  82
  83 BOOST_AUTO_TEST_CASE(util_HexStr)
  84 {
  85     BOOST_CHECK_EQUAL(
  86         HexStr(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected)),
  87         "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
  88
  89     BOOST_CHECK_EQUAL(
  90         HexStr(ParseHex_expected, ParseHex_expected + 5, true),
  91         "04 67 8a fd b0");
  92 }
  93
  94 BOOST_AUTO_TEST_CASE(util_DateTimeStrFormat)
  95 {
  96     BOOST_CHECK_EQUAL(DateTimeStrFormat("%x %H:%M:%S", 0), "01/01/70 00:00:00");
  97     BOOST_CHECK_EQUAL(DateTimeStrFormat("%x %H:%M:%S", 0x7FFFFFFF), "01/19/38 03:14:07");
  98     // Formats used within bitcoin
  99     BOOST_CHECK_EQUAL(DateTimeStrFormat("%x %H:%M:%S", 1317425777), "09/30/11 23:36:17");
 100     BOOST_CHECK_EQUAL(DateTimeStrFormat("%x %H:%M", 1317425777), "09/30/11 23:36");
 101 }
 102
 103 BOOST_AUTO_TEST_CASE(util_ParseParameters)
 104 {
 105     const char *argv_test[] = {"-ignored", "-a", "-b", "-ccc=argument", "-ccc=multiple", "f", "-d=e"};
 106
 107     ParseParameters(0, (char**)argv_test);
 108     BOOST_CHECK(mapArgs.empty() && mapMultiArgs.empty());
 109
 110     ParseParameters(1, (char**)argv_test);
 111     BOOST_CHECK(mapArgs.empty() && mapMultiArgs.empty());
 112
 113     ParseParameters(5, (char**)argv_test);
 114     // expectation: -ignored is ignored (program name argument),
 115     // -a, -b and -ccc end up in map, -d ignored because it is after
 116     // a non-option argument (non-GNU option parsing)
 117     BOOST_CHECK(mapArgs.size() == 3 && mapMultiArgs.size() == 3);
 118     BOOST_CHECK(mapArgs.count("-a") && mapArgs.count("-b") && mapArgs.count("-ccc")
 119                 && !mapArgs.count("f") && !mapArgs.count("-d"));
 120     BOOST_CHECK(mapMultiArgs.count("-a") && mapMultiArgs.count("-b") && mapMultiArgs.count("-ccc")
 121                 && !mapMultiArgs.count("f") && !mapMultiArgs.count("-d"));
 122
 123     BOOST_CHECK(mapArgs["-a"] == "" && mapArgs["-ccc"] == "multiple");
 124     BOOST_CHECK(mapMultiArgs["-ccc"].size() == 2);
 125 }
 126
 127 BOOST_AUTO_TEST_CASE(util_GetArg)
 128 {
 129     mapArgs.clear();
 130     mapArgs["strtest1"] = "string...";
 131     // strtest2 undefined on purpose
 132     mapArgs["inttest1"] = "12345";
 133     mapArgs["inttest2"] = "81985529216486895";
 134     // inttest3 undefined on purpose
 135     mapArgs["booltest1"] = "";
 136     // booltest2 undefined on purpose
 137     mapArgs["booltest3"] = "0";
 138     mapArgs["booltest4"] = "1";
 139
 140     BOOST_CHECK_EQUAL(GetArg("strtest1", "default"), "string...");
 141     BOOST_CHECK_EQUAL(GetArg("strtest2", "default"), "default");
 142     BOOST_CHECK_EQUAL(GetArg("inttest1", -1), 12345);
 143     BOOST_CHECK_EQUAL(GetArg("inttest2", -1), 81985529216486895LL);
 144     BOOST_CHECK_EQUAL(GetArg("inttest3", -1), -1);
 145     BOOST_CHECK_EQUAL(GetBoolArg("booltest1"), true);
 146     BOOST_CHECK_EQUAL(GetBoolArg("booltest2"), false);
 147     BOOST_CHECK_EQUAL(GetBoolArg("booltest3"), false);
 148     BOOST_CHECK_EQUAL(GetBoolArg("booltest4"), true);
 149 }
 150
 151 BOOST_AUTO_TEST_CASE(util_WildcardMatch)
 152 {
 153     BOOST_CHECK(WildcardMatch("127.0.0.1", "*"));
 154     BOOST_CHECK(WildcardMatch("127.0.0.1", "127.*"));
 155     BOOST_CHECK(WildcardMatch("abcdef", "a?cde?"));
 156     BOOST_CHECK(!WildcardMatch("abcdef", "a?cde??"));
 157     BOOST_CHECK(WildcardMatch("abcdef", "a*f"));
 158     BOOST_CHECK(!WildcardMatch("abcdef", "a*x"));
 159     BOOST_CHECK(WildcardMatch("", "*"));
 160 }
 161
 162 BOOST_AUTO_TEST_CASE(util_FormatMoney)
 163 {
 164     BOOST_CHECK_EQUAL(FormatMoney(0, false), "0.00");
 165     BOOST_CHECK_EQUAL(FormatMoney((COIN/10000)*123456789, false), "12345.6789");
 166     BOOST_CHECK_EQUAL(FormatMoney(COIN, true), "+1.00");
 167     BOOST_CHECK_EQUAL(FormatMoney(-COIN, false), "-1.00");
 168     BOOST_CHECK_EQUAL(FormatMoney(-COIN, true), "-1.00");
 169
 170     BOOST_CHECK_EQUAL(FormatMoney(COIN*100000000, false), "100000000.00");
 171     BOOST_CHECK_EQUAL(FormatMoney(COIN*10000000, false), "10000000.00");
 172     BOOST_CHECK_EQUAL(FormatMoney(COIN*1000000, false), "1000000.00");
 173     BOOST_CHECK_EQUAL(FormatMoney(COIN*100000, false), "100000.00");
 174     BOOST_CHECK_EQUAL(FormatMoney(COIN*10000, false), "10000.00");
 175     BOOST_CHECK_EQUAL(FormatMoney(COIN*1000, false), "1000.00");
 176     BOOST_CHECK_EQUAL(FormatMoney(COIN*100, false), "100.00");
 177     BOOST_CHECK_EQUAL(FormatMoney(COIN*10, false), "10.00");
 178     BOOST_CHECK_EQUAL(FormatMoney(COIN, false), "1.00");
 179     BOOST_CHECK_EQUAL(FormatMoney(COIN/10, false), "0.10");
 180     BOOST_CHECK_EQUAL(FormatMoney(COIN/100, false), "0.01");
 181     BOOST_CHECK_EQUAL(FormatMoney(COIN/1000, false), "0.001");
 182     BOOST_CHECK_EQUAL(FormatMoney(COIN/10000, false), "0.0001");
 183     BOOST_CHECK_EQUAL(FormatMoney(COIN/100000, false), "0.00001");
 184     BOOST_CHECK_EQUAL(FormatMoney(COIN/1000000, false), "0.000001");
 185     BOOST_CHECK_EQUAL(FormatMoney(COIN/10000000, false), "0.0000001");
 186     BOOST_CHECK_EQUAL(FormatMoney(COIN/100000000, false), "0.00000001");
 187 }
 188
 189 BOOST_AUTO_TEST_CASE(util_ParseMoney)
 190 {
 191     int64_t ret = 0;
 192     BOOST_CHECK(ParseMoney("0.0", ret));
 193     BOOST_CHECK_EQUAL(ret, 0);
 194
 195     BOOST_CHECK(ParseMoney("12345.6789", ret));
 196     BOOST_CHECK_EQUAL(ret, (COIN/10000)*123456789);
 197
 198     BOOST_CHECK(ParseMoney("100000000.00", ret));
 199     BOOST_CHECK_EQUAL(ret, COIN*100000000);
 200     BOOST_CHECK(ParseMoney("10000000.00", ret));
 201     BOOST_CHECK_EQUAL(ret, COIN*10000000);
 202     BOOST_CHECK(ParseMoney("1000000.00", ret));
 203     BOOST_CHECK_EQUAL(ret, COIN*1000000);
 204     BOOST_CHECK(ParseMoney("100000.00", ret));
 205     BOOST_CHECK_EQUAL(ret, COIN*100000);
 206     BOOST_CHECK(ParseMoney("10000.00", ret));
 207     BOOST_CHECK_EQUAL(ret, COIN*10000);
 208     BOOST_CHECK(ParseMoney("1000.00", ret));
 209     BOOST_CHECK_EQUAL(ret, COIN*1000);
 210     BOOST_CHECK(ParseMoney("100.00", ret));
 211     BOOST_CHECK_EQUAL(ret, COIN*100);
 212     BOOST_CHECK(ParseMoney("10.00", ret));
 213     BOOST_CHECK_EQUAL(ret, COIN*10);
 214     BOOST_CHECK(ParseMoney("1.00", ret));
 215     BOOST_CHECK_EQUAL(ret, COIN);
 216     BOOST_CHECK(ParseMoney("0.1", ret));
 217     BOOST_CHECK_EQUAL(ret, COIN/10);
 218     BOOST_CHECK(ParseMoney("0.01", ret));
 219     BOOST_CHECK_EQUAL(ret, COIN/100);
 220     BOOST_CHECK(ParseMoney("0.001", ret));
 221     BOOST_CHECK_EQUAL(ret, COIN/1000);
 222     BOOST_CHECK(ParseMoney("0.0001", ret));
 223     BOOST_CHECK_EQUAL(ret, COIN/10000);
 224     BOOST_CHECK(ParseMoney("0.00001", ret));
 225     BOOST_CHECK_EQUAL(ret, COIN/100000);
 226     BOOST_CHECK(ParseMoney("0.000001", ret));
 227     BOOST_CHECK_EQUAL(ret, COIN/1000000);
 228     BOOST_CHECK(ParseMoney("0.0000001", ret));
 229     BOOST_CHECK_EQUAL(ret, COIN/10000000);
 230     BOOST_CHECK(ParseMoney("0.00000001", ret));
 231     BOOST_CHECK_EQUAL(ret, COIN/100000000);
 232
 233     // Attempted 63 bit overflow should fail
 234     BOOST_CHECK(!ParseMoney("92233720368.54775808", ret));
 235 }
 236
 237 BOOST_AUTO_TEST_SUITE_END()