Feathercoin  0.5.0
P2P Digital Currency
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros
util_tests.cpp
Go to the documentation of this file.
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"), true);
158  BOOST_CHECK_EQUAL(GetBoolArg("booltest2"), false);
159  BOOST_CHECK_EQUAL(GetBoolArg("booltest3"), false);
160  BOOST_CHECK_EQUAL(GetBoolArg("booltest4"), 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  int i;
267  int count=0;
268 
269  seed_insecure_rand(true);
270 
271  for (int mod=2;mod<11;mod++)
272  {
273  int mask = 1;
274  // Really rough binomal confidence approximation.
275  int err = 30*10000./mod*sqrt((1./mod*(1-1./mod))/10000.);
276  //mask is 2^ceil(log2(mod))-1
277  while(mask<mod-1)mask=(mask<<1)+1;
278 
279  count = 0;
280  //How often does it get a zero from the uniform range [0,mod)?
281  for (i=0;i<10000;i++)
282  {
283  uint32_t rval;
284  do{
285  rval=insecure_rand()&mask;
286  }while(rval>=(uint32_t)mod);
287  count += rval==0;
288  }
289  BOOST_CHECK(count<=10000/mod+err);
290  BOOST_CHECK(count>=10000/mod-err);
291  }
292 }
293 
294 BOOST_AUTO_TEST_CASE(util_TimingResistantEqual)
295 {
296  BOOST_CHECK(TimingResistantEqual(std::string(""), std::string("")));
297  BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("")));
298  BOOST_CHECK(!TimingResistantEqual(std::string(""), std::string("abc")));
299  BOOST_CHECK(!TimingResistantEqual(std::string("a"), std::string("aa")));
300  BOOST_CHECK(!TimingResistantEqual(std::string("aa"), std::string("a")));
301  BOOST_CHECK(TimingResistantEqual(std::string("abc"), std::string("abc")));
302  BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("aba")));
303 }
304 
305 BOOST_AUTO_TEST_SUITE_END()
TRY_LOCK
#define TRY_LOCK(cs, name)
Definition: sync.h:110
seed_insecure_rand
void seed_insecure_rand(bool fDeterministic)
Seed insecure_rand using the random pool.
Definition: util.cpp:1377
CMedianFilter
Median filter over a stream of values.
Definition: util.h:462
IsHex
bool IsHex(const string &str)
Definition: util.cpp:490
GetBoolArg
bool GetBoolArg(const std::string &strArg, bool fDefault)
Return boolean argument or default value.
Definition: util.cpp:600
CMedianFilter::input
void input(T value)
Definition: util.h:477
uint32_t
unsigned int uint32_t
Definition: stdint.h:21
LOCK
#define LOCK(cs)
Definition: sync.h:108
CMedianFilter::median
T median() const
Definition: util.h:490
ParseParameters
void ParseParameters(int argc, const char *const argv[])
Definition: util.cpp:541
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(util_criticalsection)
Definition: util_tests.cpp:13
FormatMoney
string FormatMoney(int64 n, bool fPlus)
Definition: util.cpp:389
WildcardMatch
bool WildcardMatch(const char *psz, const char *mask)
Definition: util.cpp:956
TimingResistantEqual
bool TimingResistantEqual(const T &a, const T &b)
Timing-attack-resistant comparison.
Definition: util.h:450
GetArg
std::string GetArg(const std::string &strArg, const std::string &strDefault)
Return string argument or default value.
Definition: util.cpp:586
ParseMoney
bool ParseMoney(const string &str, int64 &nRet)
Definition: util.cpp:413
HexStr
std::string HexStr(const T itbegin, const T itend, bool fSpaces=false)
Definition: util.h:292
mapMultiArgs
map< string, vector< string > > mapMultiArgs
Definition: util.cpp:72
ParseHex
vector< unsigned char > ParseHex(const char *psz)
Definition: util.cpp:500
mapArgs
map< string, string > mapArgs
Definition: util.cpp:71
int64
long long int64
Definition: serialize.h:25
Generated on Thu Sep 11 2014 10:57:09 for Feathercoin by   doxygen 1.8.8