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