Line data Source code
1 : // Copyright (c) 2011-2014 The Bitcoin Core developers
2 : // Distributed under the MIT 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 : #include "test/test_bitcoin.h"
14 :
15 : #include <stdint.h>
16 : #include <vector>
17 :
18 : #include <boost/test/unit_test.hpp>
19 :
20 : using namespace std;
21 :
22 1 : BOOST_FIXTURE_TEST_SUITE(util_tests, BasicTestingSetup)
23 :
24 6 : BOOST_AUTO_TEST_CASE(util_criticalsection)
25 : {
26 : CCriticalSection cs;
27 :
28 : do {
29 1 : LOCK(cs);
30 : break;
31 :
32 : BOOST_ERROR("break was swallowed!");
33 : } while(0);
34 :
35 : do {
36 1 : TRY_LOCK(cs, lockTest);
37 1 : if (lockTest)
38 : break;
39 :
40 0 : BOOST_ERROR("break was swallowed!");
41 : } while(0);
42 1 : }
43 :
44 : static const unsigned char ParseHex_expected[65] = {
45 : 0x04, 0x67, 0x8a, 0xfd, 0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67, 0xf1, 0xa6, 0x71, 0x30, 0xb7,
46 : 0x10, 0x5c, 0xd6, 0xa8, 0x28, 0xe0, 0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, 0xea, 0x1f, 0x61, 0xde,
47 : 0xb6, 0x49, 0xf6, 0xbc, 0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04, 0xe5, 0x1e, 0xc1, 0x12,
48 : 0xde, 0x5c, 0x38, 0x4d, 0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, 0x2b, 0x6b, 0xf1, 0x1d,
49 : 0x5f
50 : };
51 6 : BOOST_AUTO_TEST_CASE(util_ParseHex)
52 : {
53 : std::vector<unsigned char> result;
54 2 : std::vector<unsigned char> expected(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected));
55 : // Basic test vector
56 2 : result = ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
57 5 : BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
58 :
59 : // Spaces between bytes must be supported
60 2 : result = ParseHex("12 34 56 78");
61 9 : BOOST_CHECK(result.size() == 4 && result[0] == 0x12 && result[1] == 0x34 && result[2] == 0x56 && result[3] == 0x78);
62 :
63 : // Stop parsing at invalid value
64 2 : result = ParseHex("1234 invalid 1234");
65 9 : BOOST_CHECK(result.size() == 2 && result[0] == 0x12 && result[1] == 0x34);
66 1 : }
67 :
68 6 : BOOST_AUTO_TEST_CASE(util_HexStr)
69 : {
70 6 : BOOST_CHECK_EQUAL(
71 : HexStr(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected)),
72 : "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
73 :
74 6 : BOOST_CHECK_EQUAL(
75 : HexStr(ParseHex_expected, ParseHex_expected + 5, true),
76 : "04 67 8a fd b0");
77 :
78 6 : BOOST_CHECK_EQUAL(
79 : HexStr(ParseHex_expected, ParseHex_expected, true),
80 : "");
81 :
82 2 : std::vector<unsigned char> ParseHex_vec(ParseHex_expected, ParseHex_expected + 5);
83 :
84 7 : BOOST_CHECK_EQUAL(
85 : HexStr(ParseHex_vec, true),
86 : "04 67 8a fd b0");
87 1 : }
88 :
89 :
90 6 : BOOST_AUTO_TEST_CASE(util_DateTimeStrFormat)
91 : {
92 6 : BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 0), "1970-01-01 00:00:00");
93 6 : BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 0x7FFFFFFF), "2038-01-19 03:14:07");
94 6 : BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 1317425777), "2011-09-30 23:36:17");
95 6 : BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M", 1317425777), "2011-09-30 23:36");
96 6 : BOOST_CHECK_EQUAL(DateTimeStrFormat("%a, %d %b %Y %H:%M:%S +0000", 1317425777), "Fri, 30 Sep 2011 23:36:17 +0000");
97 1 : }
98 :
99 6 : BOOST_AUTO_TEST_CASE(util_ParseParameters)
100 : {
101 1 : const char *argv_test[] = {"-ignored", "-a", "-b", "-ccc=argument", "-ccc=multiple", "f", "-d=e"};
102 :
103 1 : ParseParameters(0, (char**)argv_test);
104 9 : BOOST_CHECK(mapArgs.empty() && mapMultiArgs.empty());
105 :
106 1 : ParseParameters(1, (char**)argv_test);
107 9 : BOOST_CHECK(mapArgs.empty() && mapMultiArgs.empty());
108 :
109 1 : 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 9 : BOOST_CHECK(mapArgs.size() == 3 && mapMultiArgs.size() == 3);
114 22 : BOOST_CHECK(mapArgs.count("-a") && mapArgs.count("-b") && mapArgs.count("-ccc")
115 : && !mapArgs.count("f") && !mapArgs.count("-d"));
116 23 : BOOST_CHECK(mapMultiArgs.count("-a") && mapMultiArgs.count("-b") && mapMultiArgs.count("-ccc")
117 : && !mapMultiArgs.count("f") && !mapMultiArgs.count("-d"));
118 :
119 14 : BOOST_CHECK(mapArgs["-a"] == "" && mapArgs["-ccc"] == "multiple");
120 11 : BOOST_CHECK(mapMultiArgs["-ccc"].size() == 2);
121 1 : }
122 :
123 6 : BOOST_AUTO_TEST_CASE(util_GetArg)
124 : {
125 : mapArgs.clear();
126 3 : mapArgs["strtest1"] = "string...";
127 : // strtest2 undefined on purpose
128 3 : mapArgs["inttest1"] = "12345";
129 3 : mapArgs["inttest2"] = "81985529216486895";
130 : // inttest3 undefined on purpose
131 3 : mapArgs["booltest1"] = "";
132 : // booltest2 undefined on purpose
133 3 : mapArgs["booltest3"] = "0";
134 3 : mapArgs["booltest4"] = "1";
135 :
136 10 : BOOST_CHECK_EQUAL(GetArg("strtest1", "default"), "string...");
137 10 : BOOST_CHECK_EQUAL(GetArg("strtest2", "default"), "default");
138 7 : BOOST_CHECK_EQUAL(GetArg("inttest1", -1), 12345);
139 7 : BOOST_CHECK_EQUAL(GetArg("inttest2", -1), 81985529216486895LL);
140 7 : BOOST_CHECK_EQUAL(GetArg("inttest3", -1), -1);
141 7 : BOOST_CHECK_EQUAL(GetBoolArg("booltest1", false), true);
142 7 : BOOST_CHECK_EQUAL(GetBoolArg("booltest2", false), false);
143 7 : BOOST_CHECK_EQUAL(GetBoolArg("booltest3", false), false);
144 7 : BOOST_CHECK_EQUAL(GetBoolArg("booltest4", false), true);
145 1 : }
146 :
147 6 : BOOST_AUTO_TEST_CASE(util_FormatMoney)
148 : {
149 6 : BOOST_CHECK_EQUAL(FormatMoney(0), "0.00");
150 6 : BOOST_CHECK_EQUAL(FormatMoney((COIN/10000)*123456789), "12345.6789");
151 6 : BOOST_CHECK_EQUAL(FormatMoney(-COIN), "-1.00");
152 :
153 6 : BOOST_CHECK_EQUAL(FormatMoney(COIN*100000000), "100000000.00");
154 6 : BOOST_CHECK_EQUAL(FormatMoney(COIN*10000000), "10000000.00");
155 6 : BOOST_CHECK_EQUAL(FormatMoney(COIN*1000000), "1000000.00");
156 6 : BOOST_CHECK_EQUAL(FormatMoney(COIN*100000), "100000.00");
157 6 : BOOST_CHECK_EQUAL(FormatMoney(COIN*10000), "10000.00");
158 6 : BOOST_CHECK_EQUAL(FormatMoney(COIN*1000), "1000.00");
159 6 : BOOST_CHECK_EQUAL(FormatMoney(COIN*100), "100.00");
160 6 : BOOST_CHECK_EQUAL(FormatMoney(COIN*10), "10.00");
161 6 : BOOST_CHECK_EQUAL(FormatMoney(COIN), "1.00");
162 5 : BOOST_CHECK_EQUAL(FormatMoney(COIN/10), "0.10");
163 6 : BOOST_CHECK_EQUAL(FormatMoney(COIN/100), "0.01");
164 6 : BOOST_CHECK_EQUAL(FormatMoney(COIN/1000), "0.001");
165 6 : BOOST_CHECK_EQUAL(FormatMoney(COIN/10000), "0.0001");
166 6 : BOOST_CHECK_EQUAL(FormatMoney(COIN/100000), "0.00001");
167 6 : BOOST_CHECK_EQUAL(FormatMoney(COIN/1000000), "0.000001");
168 6 : BOOST_CHECK_EQUAL(FormatMoney(COIN/10000000), "0.0000001");
169 6 : BOOST_CHECK_EQUAL(FormatMoney(COIN/100000000), "0.00000001");
170 1 : }
171 :
172 6 : BOOST_AUTO_TEST_CASE(util_ParseMoney)
173 : {
174 1 : CAmount ret = 0;
175 8 : BOOST_CHECK(ParseMoney("0.0", ret));
176 5 : BOOST_CHECK_EQUAL(ret, 0);
177 :
178 8 : BOOST_CHECK(ParseMoney("12345.6789", ret));
179 5 : BOOST_CHECK_EQUAL(ret, (COIN/10000)*123456789);
180 :
181 8 : BOOST_CHECK(ParseMoney("100000000.00", ret));
182 5 : BOOST_CHECK_EQUAL(ret, COIN*100000000);
183 8 : BOOST_CHECK(ParseMoney("10000000.00", ret));
184 5 : BOOST_CHECK_EQUAL(ret, COIN*10000000);
185 8 : BOOST_CHECK(ParseMoney("1000000.00", ret));
186 5 : BOOST_CHECK_EQUAL(ret, COIN*1000000);
187 8 : BOOST_CHECK(ParseMoney("100000.00", ret));
188 5 : BOOST_CHECK_EQUAL(ret, COIN*100000);
189 8 : BOOST_CHECK(ParseMoney("10000.00", ret));
190 5 : BOOST_CHECK_EQUAL(ret, COIN*10000);
191 5 : BOOST_CHECK(ParseMoney("1000.00", ret));
192 5 : BOOST_CHECK_EQUAL(ret, COIN*1000);
193 8 : BOOST_CHECK(ParseMoney("100.00", ret));
194 5 : BOOST_CHECK_EQUAL(ret, COIN*100);
195 8 : BOOST_CHECK(ParseMoney("10.00", ret));
196 5 : BOOST_CHECK_EQUAL(ret, COIN*10);
197 8 : BOOST_CHECK(ParseMoney("1.00", ret));
198 5 : BOOST_CHECK_EQUAL(ret, COIN);
199 8 : BOOST_CHECK(ParseMoney("0.1", ret));
200 5 : BOOST_CHECK_EQUAL(ret, COIN/10);
201 8 : BOOST_CHECK(ParseMoney("0.01", ret));
202 5 : BOOST_CHECK_EQUAL(ret, COIN/100);
203 8 : BOOST_CHECK(ParseMoney("0.001", ret));
204 5 : BOOST_CHECK_EQUAL(ret, COIN/1000);
205 8 : BOOST_CHECK(ParseMoney("0.0001", ret));
206 5 : BOOST_CHECK_EQUAL(ret, COIN/10000);
207 8 : BOOST_CHECK(ParseMoney("0.00001", ret));
208 5 : BOOST_CHECK_EQUAL(ret, COIN/100000);
209 8 : BOOST_CHECK(ParseMoney("0.000001", ret));
210 5 : BOOST_CHECK_EQUAL(ret, COIN/1000000);
211 8 : BOOST_CHECK(ParseMoney("0.0000001", ret));
212 5 : BOOST_CHECK_EQUAL(ret, COIN/10000000);
213 8 : BOOST_CHECK(ParseMoney("0.00000001", ret));
214 5 : BOOST_CHECK_EQUAL(ret, COIN/100000000);
215 :
216 : // Attempted 63 bit overflow should fail
217 8 : BOOST_CHECK(!ParseMoney("92233720368.54775808", ret));
218 1 : }
219 :
220 6 : BOOST_AUTO_TEST_CASE(util_IsHex)
221 : {
222 10 : BOOST_CHECK(IsHex("00"));
223 10 : BOOST_CHECK(IsHex("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
224 10 : BOOST_CHECK(IsHex("ff"));
225 10 : BOOST_CHECK(IsHex("FF"));
226 :
227 10 : BOOST_CHECK(!IsHex(""));
228 10 : BOOST_CHECK(!IsHex("0"));
229 10 : BOOST_CHECK(!IsHex("a"));
230 10 : BOOST_CHECK(!IsHex("eleven"));
231 10 : BOOST_CHECK(!IsHex("00xx00"));
232 10 : BOOST_CHECK(!IsHex("0x0000"));
233 1 : }
234 :
235 6 : BOOST_AUTO_TEST_CASE(util_seed_insecure_rand)
236 : {
237 : int i;
238 1 : int count=0;
239 :
240 1 : seed_insecure_rand(true);
241 :
242 10 : for (int mod=2;mod<11;mod++)
243 : {
244 9 : int mask = 1;
245 : // Really rough binomal confidence approximation.
246 9 : int err = 30*10000./mod*sqrt((1./mod*(1-1./mod))/10000.);
247 : //mask is 2^ceil(log2(mod))-1
248 9 : while(mask<mod-1)mask=(mask<<1)+1;
249 :
250 : count = 0;
251 : //How often does it get a zero from the uniform range [0,mod)?
252 90000 : for (i=0;i<10000;i++)
253 : {
254 : uint32_t rval;
255 117703 : do{
256 117703 : rval=insecure_rand()&mask;
257 117703 : }while(rval>=(uint32_t)mod);
258 90000 : count += rval==0;
259 : }
260 72 : BOOST_CHECK(count<=10000/mod+err);
261 72 : BOOST_CHECK(count>=10000/mod-err);
262 : }
263 1 : }
264 :
265 6 : BOOST_AUTO_TEST_CASE(util_TimingResistantEqual)
266 : {
267 12 : BOOST_CHECK(TimingResistantEqual(std::string(""), std::string("")));
268 12 : BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("")));
269 12 : BOOST_CHECK(!TimingResistantEqual(std::string(""), std::string("abc")));
270 12 : BOOST_CHECK(!TimingResistantEqual(std::string("a"), std::string("aa")));
271 12 : BOOST_CHECK(!TimingResistantEqual(std::string("aa"), std::string("a")));
272 12 : BOOST_CHECK(TimingResistantEqual(std::string("abc"), std::string("abc")));
273 12 : BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("aba")));
274 1 : }
275 :
276 : /* Test strprintf formatting directives.
277 : * Put a string before and after to ensure sanity of element sizes on stack. */
278 : #define B "check_prefix"
279 : #define E "check_postfix"
280 6 : BOOST_AUTO_TEST_CASE(strprintf_numbers)
281 : {
282 1 : int64_t s64t = -9223372036854775807LL; /* signed 64 bit test value */
283 1 : uint64_t u64t = 18446744073709551615ULL; /* unsigned 64 bit test value */
284 10 : BOOST_CHECK(strprintf("%s %d %s", B, s64t, E) == B" -9223372036854775807 " E);
285 10 : BOOST_CHECK(strprintf("%s %u %s", B, u64t, E) == B" 18446744073709551615 " E);
286 10 : BOOST_CHECK(strprintf("%s %x %s", B, u64t, E) == B" ffffffffffffffff " E);
287 :
288 1 : size_t st = 12345678; /* unsigned size_t test value */
289 1 : ssize_t sst = -12345678; /* signed size_t test value */
290 10 : BOOST_CHECK(strprintf("%s %d %s", B, sst, E) == B" -12345678 " E);
291 10 : BOOST_CHECK(strprintf("%s %u %s", B, st, E) == B" 12345678 " E);
292 10 : BOOST_CHECK(strprintf("%s %x %s", B, st, E) == B" bc614e " E);
293 :
294 1 : ptrdiff_t pt = 87654321; /* positive ptrdiff_t test value */
295 1 : ptrdiff_t spt = -87654321; /* negative ptrdiff_t test value */
296 10 : BOOST_CHECK(strprintf("%s %d %s", B, spt, E) == B" -87654321 " E);
297 10 : BOOST_CHECK(strprintf("%s %u %s", B, pt, E) == B" 87654321 " E);
298 10 : BOOST_CHECK(strprintf("%s %x %s", B, pt, E) == B" 5397fb1 " E);
299 1 : }
300 : #undef B
301 : #undef E
302 :
303 : /* Check for mingw/wine issue #3494
304 : * Remove this test before time.ctime(0xffffffff) == 'Sun Feb 7 07:28:15 2106'
305 : */
306 6 : BOOST_AUTO_TEST_CASE(gettime)
307 : {
308 8 : BOOST_CHECK((GetTime() & ~0xFFFFFFFFLL) == 0);
309 1 : }
310 :
311 6 : BOOST_AUTO_TEST_CASE(test_ParseInt32)
312 : {
313 : int32_t n;
314 : // Valid values
315 10 : BOOST_CHECK(ParseInt32("1234", NULL));
316 10 : BOOST_CHECK(ParseInt32("0", &n) && n == 0);
317 10 : BOOST_CHECK(ParseInt32("1234", &n) && n == 1234);
318 10 : BOOST_CHECK(ParseInt32("01234", &n) && n == 1234); // no octal
319 10 : BOOST_CHECK(ParseInt32("2147483647", &n) && n == 2147483647);
320 10 : BOOST_CHECK(ParseInt32("-2147483648", &n) && n == -2147483648);
321 10 : BOOST_CHECK(ParseInt32("-1234", &n) && n == -1234);
322 : // Invalid values
323 10 : BOOST_CHECK(!ParseInt32("", &n));
324 10 : BOOST_CHECK(!ParseInt32(" 1", &n)); // no padding inside
325 10 : BOOST_CHECK(!ParseInt32("1 ", &n));
326 10 : BOOST_CHECK(!ParseInt32("1a", &n));
327 10 : BOOST_CHECK(!ParseInt32("aap", &n));
328 10 : BOOST_CHECK(!ParseInt32("0x1", &n)); // no hex
329 10 : BOOST_CHECK(!ParseInt32("0x1", &n)); // no hex
330 1 : const char test_bytes[] = {'1', 0, '1'};
331 2 : std::string teststr(test_bytes, sizeof(test_bytes));
332 8 : BOOST_CHECK(!ParseInt32(teststr, &n)); // no embedded NULs
333 : // Overflow and underflow
334 10 : BOOST_CHECK(!ParseInt32("-2147483649", NULL));
335 10 : BOOST_CHECK(!ParseInt32("2147483648", NULL));
336 10 : BOOST_CHECK(!ParseInt32("-32482348723847471234", NULL));
337 10 : BOOST_CHECK(!ParseInt32("32482348723847471234", NULL));
338 1 : }
339 :
340 6 : BOOST_AUTO_TEST_CASE(test_ParseInt64)
341 : {
342 : int64_t n;
343 : // Valid values
344 10 : BOOST_CHECK(ParseInt64("1234", NULL));
345 10 : BOOST_CHECK(ParseInt64("0", &n) && n == 0LL);
346 10 : BOOST_CHECK(ParseInt64("1234", &n) && n == 1234LL);
347 10 : BOOST_CHECK(ParseInt64("01234", &n) && n == 1234LL); // no octal
348 10 : BOOST_CHECK(ParseInt64("2147483647", &n) && n == 2147483647LL);
349 10 : BOOST_CHECK(ParseInt64("-2147483648", &n) && n == -2147483648LL);
350 10 : BOOST_CHECK(ParseInt64("9223372036854775807", &n) && n == (int64_t)9223372036854775807);
351 10 : BOOST_CHECK(ParseInt64("-9223372036854775808", &n) && n == (int64_t)-9223372036854775807-1);
352 10 : BOOST_CHECK(ParseInt64("-1234", &n) && n == -1234LL);
353 : // Invalid values
354 10 : BOOST_CHECK(!ParseInt64("", &n));
355 10 : BOOST_CHECK(!ParseInt64(" 1", &n)); // no padding inside
356 10 : BOOST_CHECK(!ParseInt64("1 ", &n));
357 10 : BOOST_CHECK(!ParseInt64("1a", &n));
358 10 : BOOST_CHECK(!ParseInt64("aap", &n));
359 10 : BOOST_CHECK(!ParseInt64("0x1", &n)); // no hex
360 1 : const char test_bytes[] = {'1', 0, '1'};
361 2 : std::string teststr(test_bytes, sizeof(test_bytes));
362 8 : BOOST_CHECK(!ParseInt64(teststr, &n)); // no embedded NULs
363 : // Overflow and underflow
364 10 : BOOST_CHECK(!ParseInt64("-9223372036854775809", NULL));
365 10 : BOOST_CHECK(!ParseInt64("9223372036854775808", NULL));
366 10 : BOOST_CHECK(!ParseInt64("-32482348723847471234", NULL));
367 10 : BOOST_CHECK(!ParseInt64("32482348723847471234", NULL));
368 1 : }
369 :
370 6 : BOOST_AUTO_TEST_CASE(test_ParseDouble)
371 : {
372 : double n;
373 : // Valid values
374 10 : BOOST_CHECK(ParseDouble("1234", NULL));
375 10 : BOOST_CHECK(ParseDouble("0", &n) && n == 0.0);
376 10 : BOOST_CHECK(ParseDouble("1234", &n) && n == 1234.0);
377 10 : BOOST_CHECK(ParseDouble("01234", &n) && n == 1234.0); // no octal
378 10 : BOOST_CHECK(ParseDouble("2147483647", &n) && n == 2147483647.0);
379 10 : BOOST_CHECK(ParseDouble("-2147483648", &n) && n == -2147483648.0);
380 10 : BOOST_CHECK(ParseDouble("-1234", &n) && n == -1234.0);
381 10 : BOOST_CHECK(ParseDouble("1e6", &n) && n == 1e6);
382 10 : BOOST_CHECK(ParseDouble("-1e6", &n) && n == -1e6);
383 : // Invalid values
384 10 : BOOST_CHECK(!ParseDouble("", &n));
385 10 : BOOST_CHECK(!ParseDouble(" 1", &n)); // no padding inside
386 10 : BOOST_CHECK(!ParseDouble("1 ", &n));
387 10 : BOOST_CHECK(!ParseDouble("1a", &n));
388 10 : BOOST_CHECK(!ParseDouble("aap", &n));
389 10 : BOOST_CHECK(!ParseDouble("0x1", &n)); // no hex
390 1 : const char test_bytes[] = {'1', 0, '1'};
391 2 : std::string teststr(test_bytes, sizeof(test_bytes));
392 8 : BOOST_CHECK(!ParseDouble(teststr, &n)); // no embedded NULs
393 : // Overflow and underflow
394 10 : BOOST_CHECK(!ParseDouble("-1e10000", NULL));
395 10 : BOOST_CHECK(!ParseDouble("1e10000", NULL));
396 1 : }
397 :
398 6 : BOOST_AUTO_TEST_CASE(test_FormatParagraph)
399 : {
400 8 : BOOST_CHECK_EQUAL(FormatParagraph("", 79, 0), "");
401 8 : BOOST_CHECK_EQUAL(FormatParagraph("test", 79, 0), "test");
402 8 : BOOST_CHECK_EQUAL(FormatParagraph(" test", 79, 0), "test");
403 8 : BOOST_CHECK_EQUAL(FormatParagraph("test test", 79, 0), "test test");
404 8 : BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 0), "test\ntest");
405 8 : BOOST_CHECK_EQUAL(FormatParagraph("testerde test ", 4, 0), "testerde\ntest");
406 8 : BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 4), "test\n test");
407 8 : 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.");
408 1 : }
409 :
410 6 : BOOST_AUTO_TEST_CASE(test_FormatSubVersion)
411 : {
412 : std::vector<std::string> comments;
413 3 : comments.push_back(std::string("comment1"));
414 1 : std::vector<std::string> comments2;
415 3 : comments2.push_back(std::string("comment1"));
416 4 : comments2.push_back(SanitizeString(std::string("Comment2; .,_?@-; !\"#$%&'()*+/<=>[]\\^`{|}~"), SAFE_CHARS_UA_COMMENT)); // Semicolon is discouraged but not forbidden by BIP-0014
417 11 : BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, std::vector<std::string>()),std::string("/Test:0.9.99/"));
418 10 : BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, comments),std::string("/Test:0.9.99(comment1)/"));
419 11 : BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, comments2),std::string("/Test:0.9.99(comment1; Comment2; .,_?@-; )/"));
420 1 : }
421 :
422 6 : BOOST_AUTO_TEST_CASE(test_ParseFixedPoint)
423 : {
424 1 : int64_t amount = 0;
425 10 : BOOST_CHECK(ParseFixedPoint("0", 8, &amount));
426 5 : BOOST_CHECK_EQUAL(amount, 0LL);
427 10 : BOOST_CHECK(ParseFixedPoint("1", 8, &amount));
428 5 : BOOST_CHECK_EQUAL(amount, 100000000LL);
429 10 : BOOST_CHECK(ParseFixedPoint("0.0", 8, &amount));
430 5 : BOOST_CHECK_EQUAL(amount, 0LL);
431 10 : BOOST_CHECK(ParseFixedPoint("-0.1", 8, &amount));
432 5 : BOOST_CHECK_EQUAL(amount, -10000000LL);
433 10 : BOOST_CHECK(ParseFixedPoint("1.1", 8, &amount));
434 5 : BOOST_CHECK_EQUAL(amount, 110000000LL);
435 10 : BOOST_CHECK(ParseFixedPoint("1.10000000000000000", 8, &amount));
436 5 : BOOST_CHECK_EQUAL(amount, 110000000LL);
437 10 : BOOST_CHECK(ParseFixedPoint("1.1e1", 8, &amount));
438 5 : BOOST_CHECK_EQUAL(amount, 1100000000LL);
439 10 : BOOST_CHECK(ParseFixedPoint("1.1e-1", 8, &amount));
440 5 : BOOST_CHECK_EQUAL(amount, 11000000LL);
441 10 : BOOST_CHECK(ParseFixedPoint("1000", 8, &amount));
442 5 : BOOST_CHECK_EQUAL(amount, 100000000000LL);
443 10 : BOOST_CHECK(ParseFixedPoint("-1000", 8, &amount));
444 5 : BOOST_CHECK_EQUAL(amount, -100000000000LL);
445 10 : BOOST_CHECK(ParseFixedPoint("0.00000001", 8, &amount));
446 5 : BOOST_CHECK_EQUAL(amount, 1LL);
447 10 : BOOST_CHECK(ParseFixedPoint("0.0000000100000000", 8, &amount));
448 5 : BOOST_CHECK_EQUAL(amount, 1LL);
449 10 : BOOST_CHECK(ParseFixedPoint("-0.00000001", 8, &amount));
450 5 : BOOST_CHECK_EQUAL(amount, -1LL);
451 10 : BOOST_CHECK(ParseFixedPoint("1000000000.00000001", 8, &amount));
452 5 : BOOST_CHECK_EQUAL(amount, 100000000000000001LL);
453 10 : BOOST_CHECK(ParseFixedPoint("9999999999.99999999", 8, &amount));
454 5 : BOOST_CHECK_EQUAL(amount, 999999999999999999LL);
455 10 : BOOST_CHECK(ParseFixedPoint("-9999999999.99999999", 8, &amount));
456 5 : BOOST_CHECK_EQUAL(amount, -999999999999999999LL);
457 :
458 10 : BOOST_CHECK(!ParseFixedPoint("", 8, &amount));
459 10 : BOOST_CHECK(!ParseFixedPoint("-", 8, &amount));
460 10 : BOOST_CHECK(!ParseFixedPoint("a-1000", 8, &amount));
461 10 : BOOST_CHECK(!ParseFixedPoint("-a1000", 8, &amount));
462 10 : BOOST_CHECK(!ParseFixedPoint("-1000a", 8, &amount));
463 10 : BOOST_CHECK(!ParseFixedPoint("-01000", 8, &amount));
464 10 : BOOST_CHECK(!ParseFixedPoint("00.1", 8, &amount));
465 10 : BOOST_CHECK(!ParseFixedPoint(".1", 8, &amount));
466 10 : BOOST_CHECK(!ParseFixedPoint("--0.1", 8, &amount));
467 10 : BOOST_CHECK(!ParseFixedPoint("0.000000001", 8, &amount));
468 10 : BOOST_CHECK(!ParseFixedPoint("-0.000000001", 8, &amount));
469 10 : BOOST_CHECK(!ParseFixedPoint("0.00000001000000001", 8, &amount));
470 10 : BOOST_CHECK(!ParseFixedPoint("-10000000000.00000000", 8, &amount));
471 10 : BOOST_CHECK(!ParseFixedPoint("10000000000.00000000", 8, &amount));
472 10 : BOOST_CHECK(!ParseFixedPoint("-10000000000.00000001", 8, &amount));
473 10 : BOOST_CHECK(!ParseFixedPoint("10000000000.00000001", 8, &amount));
474 10 : BOOST_CHECK(!ParseFixedPoint("-10000000000.00000009", 8, &amount));
475 10 : BOOST_CHECK(!ParseFixedPoint("10000000000.00000009", 8, &amount));
476 10 : BOOST_CHECK(!ParseFixedPoint("-99999999999.99999999", 8, &amount));
477 10 : BOOST_CHECK(!ParseFixedPoint("99999909999.09999999", 8, &amount));
478 10 : BOOST_CHECK(!ParseFixedPoint("92233720368.54775807", 8, &amount));
479 10 : BOOST_CHECK(!ParseFixedPoint("92233720368.54775808", 8, &amount));
480 10 : BOOST_CHECK(!ParseFixedPoint("-92233720368.54775808", 8, &amount));
481 10 : BOOST_CHECK(!ParseFixedPoint("-92233720368.54775809", 8, &amount));
482 10 : BOOST_CHECK(!ParseFixedPoint("1.1e", 8, &amount));
483 10 : BOOST_CHECK(!ParseFixedPoint("1.1e-", 8, &amount));
484 10 : BOOST_CHECK(!ParseFixedPoint("1.", 8, &amount));
485 1 : }
486 :
487 3 : BOOST_AUTO_TEST_SUITE_END()
|
