PIVX Core  5.6.99
P2P Digital Currency
util_tests.cpp
Go to the documentation of this file.
1 // Copyright (c) 2011-2014 The Bitcoin Core developers
2 // Copyright (c) 2017-2022 The PIVX Core developers
3 // Distributed under the MIT/X11 software license, see the accompanying
4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 
6 #include "util/system.h"
7 
8 #include "clientversion.h"
9 #include "sync.h"
10 #include "utilstrencodings.h"
11 #include "util/string.h"
12 #include "utilmoneystr.h"
13 #include "test/test_pivx.h"
14 #include "util/vector.h"
15 
16 #include <stdint.h>
17 #include <vector>
18 #ifndef WIN32
19 #include <sys/types.h>
20 #include <sys/wait.h>
21 #endif
22 
23 #include <boost/test/unit_test.hpp>
24 
25 BOOST_FIXTURE_TEST_SUITE(util_tests, BasicTestingSetup)
26 
27 BOOST_AUTO_TEST_CASE(util_criticalsection)
28 {
29  RecursiveMutex cs;
30 
31  do {
32  LOCK(cs);
33  break;
34 
35  BOOST_ERROR("break was swallowed!");
36  } while(0);
37 
38  do {
39  TRY_LOCK(cs, lockTest);
40  if (lockTest)
41  break;
42 
43  BOOST_ERROR("break was swallowed!");
44  } while(0);
45 }
46 
47 static const unsigned char ParseHex_expected[65] = {
48  0x04, 0x67, 0x8a, 0xfd, 0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67, 0xf1, 0xa6, 0x71, 0x30, 0xb7,
49  0x10, 0x5c, 0xd6, 0xa8, 0x28, 0xe0, 0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, 0xea, 0x1f, 0x61, 0xde,
50  0xb6, 0x49, 0xf6, 0xbc, 0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04, 0xe5, 0x1e, 0xc1, 0x12,
51  0xde, 0x5c, 0x38, 0x4d, 0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, 0x2b, 0x6b, 0xf1, 0x1d,
52  0x5f
53 };
54 BOOST_AUTO_TEST_CASE(util_ParseHex)
55 {
56  std::vector<unsigned char> result;
57  std::vector<unsigned char> expected(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected));
58  // Basic test vector
59  result = ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
60  BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
61 
62  // Spaces between bytes must be supported
63  result = ParseHex("12 34 56 78");
64  BOOST_CHECK(result.size() == 4 && result[0] == 0x12 && result[1] == 0x34 && result[2] == 0x56 && result[3] == 0x78);
65 
66  // Stop parsing at invalid value
67  result = ParseHex("1234 invalid 1234");
68  BOOST_CHECK(result.size() == 2 && result[0] == 0x12 && result[1] == 0x34);
69 }
70 
71 BOOST_AUTO_TEST_CASE(util_HexStr)
72 {
73  BOOST_CHECK_EQUAL(
74  HexStr(ParseHex_expected),
75  "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
76 
77  BOOST_CHECK_EQUAL(
78  HexStr(Span<const unsigned char>(
79  ParseHex_expected + sizeof(ParseHex_expected),
80  ParseHex_expected + sizeof(ParseHex_expected))),
81  "");
82 
83  BOOST_CHECK_EQUAL(
84  HexStr(Span<const unsigned char>(ParseHex_expected, ParseHex_expected)),
85  "");
86 
87  std::vector<unsigned char> ParseHex_vec(ParseHex_expected, ParseHex_expected + 5);
88 
89  BOOST_CHECK_EQUAL(
90  HexStr(ParseHex_vec),
91  "04678afdb0"
92  );
93 }
94 
95 BOOST_AUTO_TEST_CASE(util_Join)
96 {
97  // Normal version
98  BOOST_CHECK_EQUAL(Join({}, ", "), "");
99  BOOST_CHECK_EQUAL(Join({"foo"}, ", "), "foo");
100  BOOST_CHECK_EQUAL(Join({"foo", "bar"}, ", "), "foo, bar");
101 
102  // Version with unary operator
103  const auto op_upper = [](const std::string& s) { return ToUpper(s); };
104  BOOST_CHECK_EQUAL(Join<std::string>({}, ", ", op_upper), "");
105  BOOST_CHECK_EQUAL(Join<std::string>({"foo"}, ", ", op_upper), "FOO");
106  BOOST_CHECK_EQUAL(Join<std::string>({"foo", "bar"}, ", ", op_upper), "FOO, BAR");
107 }
108 
109 BOOST_AUTO_TEST_CASE(util_FormatISO8601DateTime)
110 {
111  BOOST_CHECK_EQUAL(FormatISO8601DateTime(1317425777), "2011-09-30T23:36:17Z");
112 }
113 
114 BOOST_AUTO_TEST_CASE(util_FormatISO8601DateTimeForBackup)
115 {
116  BOOST_CHECK_EQUAL(FormatISO8601DateTimeForBackup(1586310600), ".20200408T0150Z");
117 }
118 
119 BOOST_AUTO_TEST_CASE(util_FormatISO8601Date)
120 {
121  BOOST_CHECK_EQUAL(FormatISO8601Date(1317425777), "2011-09-30");
122 }
123 
124 BOOST_AUTO_TEST_CASE(util_FormatISO8601Time)
125 {
126  BOOST_CHECK_EQUAL(FormatISO8601Time(1317425777), "23:36:17Z");
127 }
128 
129 struct TestArgsManager : public ArgsManager
130 {
131  TestArgsManager() { m_network_only_args.clear(); }
132  std::map<std::string, std::vector<std::string> >& GetOverrideArgs() { return m_override_args; }
133  std::map<std::string, std::vector<std::string> >& GetConfigArgs() { return m_config_args; }
134  void ReadConfigString(const std::string str_config)
135  {
136  std::istringstream streamConfig(str_config);
137  {
138  LOCK(cs_args);
139  m_config_args.clear();
140  }
141  ReadConfigStream(streamConfig);
142  }
143  void SetNetworkOnlyArg(const std::string arg)
144  {
145  LOCK(cs_args);
146  m_network_only_args.insert(arg);
147  }
148 };
149 
150 BOOST_AUTO_TEST_CASE(util_ParseParameters)
151 {
152  TestArgsManager testArgs;
153  const char *argv_test[] = {"-ignored", "-a", "-b", "-ccc=argument", "-ccc=multiple", "f", "-d=e"};
154 
155  testArgs.ParseParameters(0, (char**)argv_test);
156  BOOST_CHECK(testArgs.GetOverrideArgs().empty() && testArgs.GetConfigArgs().empty());
157 
158  testArgs.ParseParameters(1, (char**)argv_test);
159  BOOST_CHECK(testArgs.GetOverrideArgs().empty() && testArgs.GetConfigArgs().empty());
160 
161  testArgs.ParseParameters(5, (char**)argv_test);
162  // expectation: -ignored is ignored (program name argument),
163  // -a, -b and -ccc end up in map, -d ignored because it is after
164  // a non-option argument (non-GNU option parsing)
165  BOOST_CHECK(testArgs.GetOverrideArgs().size() == 3 && testArgs.GetConfigArgs().empty());
166  BOOST_CHECK(testArgs.IsArgSet("-a") && testArgs.IsArgSet("-b") && testArgs.IsArgSet("-ccc")
167  && !testArgs.IsArgSet("f") && !testArgs.IsArgSet("-d"));
168  BOOST_CHECK(testArgs.GetOverrideArgs().count("-a") && testArgs.GetOverrideArgs().count("-b") && testArgs.GetOverrideArgs().count("-ccc")
169  && !testArgs.GetOverrideArgs().count("f") && !testArgs.GetOverrideArgs().count("-d"));
170 
171  BOOST_CHECK(testArgs.GetOverrideArgs()["-a"].size() == 1);
172  BOOST_CHECK(testArgs.GetOverrideArgs()["-a"].front() == "");
173  BOOST_CHECK(testArgs.GetOverrideArgs()["-ccc"].size() == 2);
174  BOOST_CHECK(testArgs.GetOverrideArgs()["-ccc"].front() == "argument");
175  BOOST_CHECK(testArgs.GetOverrideArgs()["-ccc"].back() == "multiple");
176 }
177 
178 BOOST_AUTO_TEST_CASE(util_GetBoolArg)
179 {
180  TestArgsManager testArgs;
181  const char *argv_test[] = {
182  "ignored", "-a", "-nob", "-c=0", "-d=1", "-e=false", "-f=true"};
183  testArgs.ParseParameters(7, (char**)argv_test);
184 
185  // Each letter should be set.
186  for (char opt : "abcdef")
187  BOOST_CHECK(testArgs.IsArgSet({'-', opt}) || !opt);
188 
189  // Nothing else should be in the map
190  BOOST_CHECK(testArgs.GetOverrideArgs().size() == 6 &&
191  testArgs.GetConfigArgs().empty());
192 
193  // The -no prefix should get stripped on the way in.
194  BOOST_CHECK(!testArgs.IsArgSet("-nob"));
195 
196  // The -b option is flagged as negated, and nothing else is
197  BOOST_CHECK(testArgs.IsArgNegated("-b"));
198  BOOST_CHECK(!testArgs.IsArgNegated("-a"));
199 
200  // Check expected values.
201  BOOST_CHECK(testArgs.GetBoolArg("-a", false) == true);
202  BOOST_CHECK(testArgs.GetBoolArg("-b", true) == false);
203  BOOST_CHECK(testArgs.GetBoolArg("-c", true) == false);
204  BOOST_CHECK(testArgs.GetBoolArg("-d", false) == true);
205  BOOST_CHECK(testArgs.GetBoolArg("-e", true) == false);
206  BOOST_CHECK(testArgs.GetBoolArg("-f", true) == false);
207 }
208 
209 BOOST_AUTO_TEST_CASE(util_GetBoolArgEdgeCases)
210 {
211  // Test some awful edge cases that hopefully no user will ever exercise.
212  TestArgsManager testArgs;
213 
214  // Params test
215  const char *argv_test[] = {"ignored", "-nofoo", "-foo", "-nobar=0"};
216  testArgs.ParseParameters(4, (char**)argv_test);
217 
218  // This was passed twice, second one overrides the negative setting.
219  BOOST_CHECK(!testArgs.IsArgNegated("-foo"));
220  BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "");
221 
222  // A double negative is a positive, and not marked as negated.
223  BOOST_CHECK(!testArgs.IsArgNegated("-bar"));
224  BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "1");
225 
226  // Config test
227  const char *conf_test = "nofoo=1\nfoo=1\nnobar=0\n";
228  testArgs.ParseParameters(1, (char**)argv_test);
229  testArgs.ReadConfigString(conf_test);
230 
231  // This was passed twice, second one overrides the negative setting,
232  // and the value.
233  BOOST_CHECK(!testArgs.IsArgNegated("-foo"));
234  BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "1");
235 
236  // A double negative is a positive, and does not count as negated.
237  BOOST_CHECK(!testArgs.IsArgNegated("-bar"));
238  BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "1");
239 
240  // Combined test
241  const char *combo_test_args[] = {"ignored", "-nofoo", "-bar"};
242  const char *combo_test_conf = "foo=1\nnobar=1\n";
243  testArgs.ParseParameters(3, (char**)combo_test_args);
244  testArgs.ReadConfigString(combo_test_conf);
245 
246  // Command line overrides, but doesn't erase old setting
247  BOOST_CHECK(testArgs.IsArgNegated("-foo"));
248  BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "0");
249  BOOST_CHECK(testArgs.GetArgs("-foo").size() == 0);
250 
251  // Command line overrides, but doesn't erase old setting
252  BOOST_CHECK(!testArgs.IsArgNegated("-bar"));
253  BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "");
254  BOOST_CHECK(testArgs.GetArgs("-bar").size() == 1
255  && testArgs.GetArgs("-bar").front() == "");
256 }
257 
258 BOOST_AUTO_TEST_CASE(util_ReadConfigStream)
259 {
260  const char *str_config =
261  "a=\n"
262  "b=1\n"
263  "ccc=argument\n"
264  "ccc=multiple\n"
265  "d=e\n"
266  "nofff=1\n"
267  "noggg=0\n"
268  "h=1\n"
269  "noh=1\n"
270  "noi=1\n"
271  "i=1\n"
272  "sec1.ccc=extend1\n"
273  "\n"
274  "[sec1]\n"
275  "ccc=extend2\n"
276  "d=eee\n"
277  "h=1\n"
278  "[sec2]\n"
279  "ccc=extend3\n"
280  "iii=2\n";
281 
282  TestArgsManager test_args;
283 
284  test_args.ReadConfigString(str_config);
285  // expectation: a, b, ccc, d, fff, ggg, h, i end up in map
286  // so do sec1.ccc, sec1.d, sec1.h, sec2.ccc, sec2.iii
287 
288  BOOST_CHECK(test_args.GetOverrideArgs().empty());
289  BOOST_CHECK(test_args.GetConfigArgs().size() == 13);
290 
291  BOOST_CHECK(test_args.GetConfigArgs().count("-a")
292  && test_args.GetConfigArgs().count("-b")
293  && test_args.GetConfigArgs().count("-ccc")
294  && test_args.GetConfigArgs().count("-d")
295  && test_args.GetConfigArgs().count("-fff")
296  && test_args.GetConfigArgs().count("-ggg")
297  && test_args.GetConfigArgs().count("-h")
298  && test_args.GetConfigArgs().count("-i")
299  );
300  BOOST_CHECK(test_args.GetConfigArgs().count("-sec1.ccc")
301  && test_args.GetConfigArgs().count("-sec1.h")
302  && test_args.GetConfigArgs().count("-sec2.ccc")
303  && test_args.GetConfigArgs().count("-sec2.iii")
304  );
305 
306  BOOST_CHECK(test_args.IsArgSet("-a")
307  && test_args.IsArgSet("-b")
308  && test_args.IsArgSet("-ccc")
309  && test_args.IsArgSet("-d")
310  && test_args.IsArgSet("-fff")
311  && test_args.IsArgSet("-ggg")
312  && test_args.IsArgSet("-h")
313  && test_args.IsArgSet("-i")
314  && !test_args.IsArgSet("-zzz")
315  && !test_args.IsArgSet("-iii")
316  );
317 
318  BOOST_CHECK(test_args.GetArg("-a", "xxx") == ""
319  && test_args.GetArg("-b", "xxx") == "1"
320  && test_args.GetArg("-ccc", "xxx") == "argument"
321  && test_args.GetArg("-d", "xxx") == "e"
322  && test_args.GetArg("-fff", "xxx") == "0"
323  && test_args.GetArg("-ggg", "xxx") == "1"
324  && test_args.GetArg("-h", "xxx") == "0"
325  && test_args.GetArg("-i", "xxx") == "1"
326  && test_args.GetArg("-zzz", "xxx") == "xxx"
327  && test_args.GetArg("-iii", "xxx") == "xxx"
328  );
329 
330  for (bool def : {false, true}) {
331  BOOST_CHECK(test_args.GetBoolArg("-a", def)
332  && test_args.GetBoolArg("-b", def)
333  && !test_args.GetBoolArg("-ccc", def)
334  && !test_args.GetBoolArg("-d", def)
335  && !test_args.GetBoolArg("-fff", def)
336  && test_args.GetBoolArg("-ggg", def)
337  && !test_args.GetBoolArg("-h", def)
338  && test_args.GetBoolArg("-i", def)
339  && test_args.GetBoolArg("-zzz", def) == def
340  && test_args.GetBoolArg("-iii", def) == def
341  );
342  }
343 
344  BOOST_CHECK(test_args.GetArgs("-a").size() == 1
345  && test_args.GetArgs("-a").front() == "");
346  BOOST_CHECK(test_args.GetArgs("-b").size() == 1
347  && test_args.GetArgs("-b").front() == "1");
348  BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2
349  && test_args.GetArgs("-ccc").front() == "argument"
350  && test_args.GetArgs("-ccc").back() == "multiple");
351  BOOST_CHECK(test_args.GetArgs("-fff").size() == 0);
352  BOOST_CHECK(test_args.GetArgs("-nofff").size() == 0);
353  BOOST_CHECK(test_args.GetArgs("-ggg").size() == 1
354  && test_args.GetArgs("-ggg").front() == "1");
355  BOOST_CHECK(test_args.GetArgs("-noggg").size() == 0);
356  BOOST_CHECK(test_args.GetArgs("-h").size() == 0);
357  BOOST_CHECK(test_args.GetArgs("-noh").size() == 0);
358  BOOST_CHECK(test_args.GetArgs("-i").size() == 1
359  && test_args.GetArgs("-i").front() == "1");
360  BOOST_CHECK(test_args.GetArgs("-noi").size() == 0);
361  BOOST_CHECK(test_args.GetArgs("-zzz").size() == 0);
362 
363  BOOST_CHECK(!test_args.IsArgNegated("-a"));
364  BOOST_CHECK(!test_args.IsArgNegated("-b"));
365  BOOST_CHECK(!test_args.IsArgNegated("-ccc"));
366  BOOST_CHECK(!test_args.IsArgNegated("-d"));
367  BOOST_CHECK(test_args.IsArgNegated("-fff"));
368  BOOST_CHECK(!test_args.IsArgNegated("-ggg"));
369  BOOST_CHECK(test_args.IsArgNegated("-h")); // last setting takes precedence
370  BOOST_CHECK(!test_args.IsArgNegated("-i")); // last setting takes precedence
371  BOOST_CHECK(!test_args.IsArgNegated("-zzz"));
372 
373  // Test sections work
374  test_args.SelectConfigNetwork("sec1");
375 
376  // same as original
377  BOOST_CHECK(test_args.GetArg("-a", "xxx") == ""
378  && test_args.GetArg("-b", "xxx") == "1"
379  && test_args.GetArg("-fff", "xxx") == "0"
380  && test_args.GetArg("-ggg", "xxx") == "1"
381  && test_args.GetArg("-zzz", "xxx") == "xxx"
382  && test_args.GetArg("-iii", "xxx") == "xxx"
383  );
384  // d is overridden
385  BOOST_CHECK(test_args.GetArg("-d", "xxx") == "eee");
386  // section-specific setting
387  BOOST_CHECK(test_args.GetArg("-h", "xxx") == "1");
388  // section takes priority for multiple values
389  BOOST_CHECK(test_args.GetArg("-ccc", "xxx") == "extend1");
390  // check multiple values works
391  const std::vector<std::string> sec1_ccc_expected = {"extend1","extend2","argument","multiple"};
392  const auto& sec1_ccc_res = test_args.GetArgs("-ccc");
393  BOOST_CHECK_EQUAL_COLLECTIONS(sec1_ccc_res.begin(), sec1_ccc_res.end(), sec1_ccc_expected.begin(), sec1_ccc_expected.end());
394 
395  test_args.SelectConfigNetwork("sec2");
396 
397  // same as original
398  BOOST_CHECK(test_args.GetArg("-a", "xxx") == ""
399  && test_args.GetArg("-b", "xxx") == "1"
400  && test_args.GetArg("-d", "xxx") == "e"
401  && test_args.GetArg("-fff", "xxx") == "0"
402  && test_args.GetArg("-ggg", "xxx") == "1"
403  && test_args.GetArg("-zzz", "xxx") == "xxx"
404  && test_args.GetArg("-h", "xxx") == "0"
405  );
406  // section-specific setting
407  BOOST_CHECK(test_args.GetArg("-iii", "xxx") == "2");
408  // section takes priority for multiple values
409  BOOST_CHECK(test_args.GetArg("-ccc", "xxx") == "extend3");
410  // check multiple values works
411  const std::vector<std::string> sec2_ccc_expected = {"extend3","argument","multiple"};
412  const auto& sec2_ccc_res = test_args.GetArgs("-ccc");
413  BOOST_CHECK_EQUAL_COLLECTIONS(sec2_ccc_res.begin(), sec2_ccc_res.end(), sec2_ccc_expected.begin(), sec2_ccc_expected.end());
414 
415  // Test section only options
416 
417  test_args.SetNetworkOnlyArg("-d");
418  test_args.SetNetworkOnlyArg("-ccc");
419  test_args.SetNetworkOnlyArg("-h");
420 
421  test_args.SelectConfigNetwork(CBaseChainParams::MAIN);
422  BOOST_CHECK(test_args.GetArg("-d", "xxx") == "e");
423  BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2);
424  BOOST_CHECK(test_args.GetArg("-h", "xxx") == "0");
425 
426  test_args.SelectConfigNetwork("sec1");
427  BOOST_CHECK(test_args.GetArg("-d", "xxx") == "eee");
428  BOOST_CHECK(test_args.GetArgs("-d").size() == 1);
429  BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2);
430  BOOST_CHECK(test_args.GetArg("-h", "xxx") == "1");
431 
432  test_args.SelectConfigNetwork("sec2");
433  BOOST_CHECK(test_args.GetArg("-d", "xxx") == "xxx");
434  BOOST_CHECK(test_args.GetArgs("-d").size() == 0);
435  BOOST_CHECK(test_args.GetArgs("-ccc").size() == 1);
436  BOOST_CHECK(test_args.GetArg("-h", "xxx") == "0");
437 }
438 
439 BOOST_AUTO_TEST_CASE(util_GetArg)
440 {
441  TestArgsManager testArgs;
442  testArgs.GetOverrideArgs().clear();
443  testArgs.GetOverrideArgs()["strtest1"] = {"string..."};
444  // strtest2 undefined on purpose
445  testArgs.GetOverrideArgs()["inttest1"] = {"12345"};
446  testArgs.GetOverrideArgs()["inttest2"] = {"81985529216486895"};
447  // inttest3 undefined on purpose
448  testArgs.GetOverrideArgs()["booltest1"] = {""};
449  // booltest2 undefined on purpose
450  testArgs.GetOverrideArgs()["booltest3"] = {"0"};
451  testArgs.GetOverrideArgs()["booltest4"] = {"1"};
452 
453  // priorities
454  testArgs.GetOverrideArgs()["pritest1"] = {"a", "b"};
455  testArgs.GetConfigArgs()["pritest2"] = {"a", "b"};
456  testArgs.GetOverrideArgs()["pritest3"] = {"a"};
457  testArgs.GetConfigArgs()["pritest3"] = {"b"};
458  testArgs.GetOverrideArgs()["pritest4"] = {"a","b"};
459  testArgs.GetConfigArgs()["pritest4"] = {"c","d"};
460 
461  BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "string...");
462  BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "default");
463  BOOST_CHECK_EQUAL(testArgs.GetArg("inttest1", -1), 12345);
464  BOOST_CHECK_EQUAL(testArgs.GetArg("inttest2", -1), 81985529216486895LL);
465  BOOST_CHECK_EQUAL(testArgs.GetArg("inttest3", -1), -1);
466  BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", false), true);
467  BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest2", false), false);
468  BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest3", false), false);
469  BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest4", false), true);
470 
471  BOOST_CHECK_EQUAL(testArgs.GetArg("pritest1", "default"), "b");
472  BOOST_CHECK_EQUAL(testArgs.GetArg("pritest2", "default"), "a");
473  BOOST_CHECK_EQUAL(testArgs.GetArg("pritest3", "default"), "a");
474  BOOST_CHECK_EQUAL(testArgs.GetArg("pritest4", "default"), "b");
475 }
476 
477 BOOST_AUTO_TEST_CASE(util_GetChainName)
478 {
479  TestArgsManager test_args;
480 
481  const char* argv_testnet[] = {"cmd", "-testnet"};
482  const char* argv_regtest[] = {"cmd", "-regtest"};
483  const char* argv_test_no_reg[] = {"cmd", "-testnet", "-noregtest"};
484  const char* argv_both[] = {"cmd", "-testnet", "-regtest"};
485 
486  // equivalent to "-testnet"
487  // regtest in testnet section is ignored
488  const char* testnetconf = "testnet=1\nregtest=0\n[test]\nregtest=1";
489 
490  test_args.ParseParameters(0, (char**)argv_testnet);
491  BOOST_CHECK_EQUAL(test_args.GetChainName(), "main");
492 
493  test_args.ParseParameters(2, (char**)argv_testnet);
494  BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
495 
496  test_args.ParseParameters(2, (char**)argv_regtest);
497  BOOST_CHECK_EQUAL(test_args.GetChainName(), "regtest");
498 
499  test_args.ParseParameters(3, (char**)argv_test_no_reg);
500  BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
501 
502  test_args.ParseParameters(3, (char**)argv_both);
503  BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
504 
505  test_args.ParseParameters(0, (char**)argv_testnet);
506  test_args.ReadConfigString(testnetconf);
507  BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
508 
509  test_args.ParseParameters(2, (char**)argv_testnet);
510  test_args.ReadConfigString(testnetconf);
511  BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
512 
513  test_args.ParseParameters(2, (char**)argv_regtest);
514  test_args.ReadConfigString(testnetconf);
515  BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
516 
517  test_args.ParseParameters(3, (char**)argv_test_no_reg);
518  test_args.ReadConfigString(testnetconf);
519  BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
520 
521  test_args.ParseParameters(3, (char**)argv_both);
522  test_args.ReadConfigString(testnetconf);
523  BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
524 
525  // check setting the network to test (and thus making
526  // [test] regtest=1 potentially relevant) doesn't break things
527  test_args.SelectConfigNetwork("test");
528 
529  test_args.ParseParameters(0, (char**)argv_testnet);
530  test_args.ReadConfigString(testnetconf);
531  BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
532 
533  test_args.ParseParameters(2, (char**)argv_testnet);
534  test_args.ReadConfigString(testnetconf);
535  BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
536 
537  test_args.ParseParameters(2, (char**)argv_regtest);
538  test_args.ReadConfigString(testnetconf);
539  BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
540 
541  test_args.ParseParameters(2, (char**)argv_test_no_reg);
542  test_args.ReadConfigString(testnetconf);
543  BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
544 
545  test_args.ParseParameters(3, (char**)argv_both);
546  test_args.ReadConfigString(testnetconf);
547  BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
548 }
549 
550 BOOST_AUTO_TEST_CASE(util_FormatMoney)
551 {
552  BOOST_CHECK_EQUAL(FormatMoney(0, false), "0.00");
553  BOOST_CHECK_EQUAL(FormatMoney((COIN/10000)*123456789, false), "12345.6789");
554  BOOST_CHECK_EQUAL(FormatMoney(COIN, true), "+1.00");
555  BOOST_CHECK_EQUAL(FormatMoney(-COIN, false), "-1.00");
556  BOOST_CHECK_EQUAL(FormatMoney(-COIN, true), "-1.00");
557 
558  BOOST_CHECK_EQUAL(FormatMoney(COIN*100000000, false), "100000000.00");
559  BOOST_CHECK_EQUAL(FormatMoney(COIN*10000000, false), "10000000.00");
560  BOOST_CHECK_EQUAL(FormatMoney(COIN*1000000, false), "1000000.00");
561  BOOST_CHECK_EQUAL(FormatMoney(COIN*100000, false), "100000.00");
562  BOOST_CHECK_EQUAL(FormatMoney(COIN*10000, false), "10000.00");
563  BOOST_CHECK_EQUAL(FormatMoney(COIN*1000, false), "1000.00");
564  BOOST_CHECK_EQUAL(FormatMoney(COIN*100, false), "100.00");
565  BOOST_CHECK_EQUAL(FormatMoney(COIN*10, false), "10.00");
566  BOOST_CHECK_EQUAL(FormatMoney(COIN, false), "1.00");
567  BOOST_CHECK_EQUAL(FormatMoney(COIN/10, false), "0.10");
568  BOOST_CHECK_EQUAL(FormatMoney(COIN/100, false), "0.01");
569  BOOST_CHECK_EQUAL(FormatMoney(COIN/1000, false), "0.001");
570  BOOST_CHECK_EQUAL(FormatMoney(COIN/10000, false), "0.0001");
571  BOOST_CHECK_EQUAL(FormatMoney(COIN/100000, false), "0.00001");
572  BOOST_CHECK_EQUAL(FormatMoney(COIN/1000000, false), "0.000001");
573  BOOST_CHECK_EQUAL(FormatMoney(COIN/10000000, false), "0.0000001");
574  BOOST_CHECK_EQUAL(FormatMoney(COIN/100000000, false), "0.00000001");
575 }
576 
577 BOOST_AUTO_TEST_CASE(util_ParseMoney)
578 {
579  CAmount ret = 0;
580  BOOST_CHECK(ParseMoney("0.0", ret));
581  BOOST_CHECK_EQUAL(ret, 0);
582 
583  BOOST_CHECK(ParseMoney("12345.6789", ret));
584  BOOST_CHECK_EQUAL(ret, (COIN/10000)*123456789);
585 
586  BOOST_CHECK(ParseMoney("100000000.00", ret));
587  BOOST_CHECK_EQUAL(ret, COIN*100000000);
588  BOOST_CHECK(ParseMoney("10000000.00", ret));
589  BOOST_CHECK_EQUAL(ret, COIN*10000000);
590  BOOST_CHECK(ParseMoney("1000000.00", ret));
591  BOOST_CHECK_EQUAL(ret, COIN*1000000);
592  BOOST_CHECK(ParseMoney("100000.00", ret));
593  BOOST_CHECK_EQUAL(ret, COIN*100000);
594  BOOST_CHECK(ParseMoney("10000.00", ret));
595  BOOST_CHECK_EQUAL(ret, COIN*10000);
596  BOOST_CHECK(ParseMoney("1000.00", ret));
597  BOOST_CHECK_EQUAL(ret, COIN*1000);
598  BOOST_CHECK(ParseMoney("100.00", ret));
599  BOOST_CHECK_EQUAL(ret, COIN*100);
600  BOOST_CHECK(ParseMoney("10.00", ret));
601  BOOST_CHECK_EQUAL(ret, COIN*10);
602  BOOST_CHECK(ParseMoney("1.00", ret));
603  BOOST_CHECK_EQUAL(ret, COIN);
604  BOOST_CHECK(ParseMoney("1", ret));
605  BOOST_CHECK_EQUAL(ret, COIN);
606  BOOST_CHECK(ParseMoney("0.1", ret));
607  BOOST_CHECK_EQUAL(ret, COIN/10);
608  BOOST_CHECK(ParseMoney("0.01", ret));
609  BOOST_CHECK_EQUAL(ret, COIN/100);
610  BOOST_CHECK(ParseMoney("0.001", ret));
611  BOOST_CHECK_EQUAL(ret, COIN/1000);
612  BOOST_CHECK(ParseMoney("0.0001", ret));
613  BOOST_CHECK_EQUAL(ret, COIN/10000);
614  BOOST_CHECK(ParseMoney("0.00001", ret));
615  BOOST_CHECK_EQUAL(ret, COIN/100000);
616  BOOST_CHECK(ParseMoney("0.000001", ret));
617  BOOST_CHECK_EQUAL(ret, COIN/1000000);
618  BOOST_CHECK(ParseMoney("0.0000001", ret));
619  BOOST_CHECK_EQUAL(ret, COIN/10000000);
620  BOOST_CHECK(ParseMoney("0.00000001", ret));
621  BOOST_CHECK_EQUAL(ret, COIN/100000000);
622 
623  // Attempted 63 bit overflow should fail
624  BOOST_CHECK(!ParseMoney("92233720368.54775808", ret));
625 
626  // Parsing negative amounts must fail
627  BOOST_CHECK(!ParseMoney("-1", ret));
628 }
629 
630 BOOST_AUTO_TEST_CASE(util_IsHex)
631 {
632  BOOST_CHECK(IsHex("00"));
633  BOOST_CHECK(IsHex("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
634  BOOST_CHECK(IsHex("ff"));
635  BOOST_CHECK(IsHex("FF"));
636 
637  BOOST_CHECK(!IsHex(""));
638  BOOST_CHECK(!IsHex("0"));
639  BOOST_CHECK(!IsHex("a"));
640  BOOST_CHECK(!IsHex("eleven"));
641  BOOST_CHECK(!IsHex("00xx00"));
642  BOOST_CHECK(!IsHex("0x0000"));
643 }
644 
645 BOOST_AUTO_TEST_CASE(util_seed_insecure_rand)
646 {
647  int i;
648  int count=0;
649 
650  SeedInsecureRand(SeedRand::ZEROS);
651 
652  for (int mod=2;mod<11;mod++)
653  {
654  int mask = 1;
655  // Really rough binomal confidence approximation.
656  int err = 30*10000./mod*sqrt((1./mod*(1-1./mod))/10000.);
657  //mask is 2^ceil(log2(mod))-1
658  while(mask<mod-1)mask=(mask<<1)+1;
659 
660  count = 0;
661  //How often does it get a zero from the uniform range [0,mod)?
662  for (i=0;i<10000;i++)
663  {
664  uint32_t rval;
665  do{
666  rval=InsecureRand32()&mask;
667  }while(rval>=(uint32_t)mod);
668  count += rval==0;
669  }
670  BOOST_CHECK(count<=10000/mod+err);
671  BOOST_CHECK(count>=10000/mod-err);
672  }
673 }
674 
675 BOOST_AUTO_TEST_CASE(util_TimingResistantEqual)
676 {
677  BOOST_CHECK(TimingResistantEqual(std::string(""), std::string("")));
678  BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("")));
679  BOOST_CHECK(!TimingResistantEqual(std::string(""), std::string("abc")));
680  BOOST_CHECK(!TimingResistantEqual(std::string("a"), std::string("aa")));
681  BOOST_CHECK(!TimingResistantEqual(std::string("aa"), std::string("a")));
682  BOOST_CHECK(TimingResistantEqual(std::string("abc"), std::string("abc")));
683  BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("aba")));
684 }
685 
686 /* Test strprintf formatting directives.
687  * Put a string before and after to ensure sanity of element sizes on stack. */
688 #define B "check_prefix"
689 #define E "check_postfix"
690 BOOST_AUTO_TEST_CASE(strprintf_numbers)
691 {
692  int64_t s64t = -9223372036854775807LL; /* signed 64 bit test value */
693  uint64_t u64t = 18446744073709551615ULL; /* unsigned 64 bit test value */
694  BOOST_CHECK(strprintf("%s %d %s", B, s64t, E) == B" -9223372036854775807 " E);
695  BOOST_CHECK(strprintf("%s %u %s", B, u64t, E) == B" 18446744073709551615 " E);
696  BOOST_CHECK(strprintf("%s %x %s", B, u64t, E) == B" ffffffffffffffff " E);
697 
698  size_t st = 12345678; /* unsigned size_t test value */
699  ssize_t sst = -12345678; /* signed size_t test value */
700  BOOST_CHECK(strprintf("%s %d %s", B, sst, E) == B" -12345678 " E);
701  BOOST_CHECK(strprintf("%s %u %s", B, st, E) == B" 12345678 " E);
702  BOOST_CHECK(strprintf("%s %x %s", B, st, E) == B" bc614e " E);
703 
704  ptrdiff_t pt = 87654321; /* positive ptrdiff_t test value */
705  ptrdiff_t spt = -87654321; /* negative ptrdiff_t test value */
706  BOOST_CHECK(strprintf("%s %d %s", B, spt, E) == B" -87654321 " E);
707  BOOST_CHECK(strprintf("%s %u %s", B, pt, E) == B" 87654321 " E);
708  BOOST_CHECK(strprintf("%s %x %s", B, pt, E) == B" 5397fb1 " E);
709 }
710 #undef B
711 #undef E
712 
713 /* Check for mingw/wine issue #3494
714  * Remove this test before time.ctime(0xffffffff) == 'Sun Feb 7 07:28:15 2106'
715  */
716 BOOST_AUTO_TEST_CASE(gettime)
717 {
718  BOOST_CHECK((GetTime() & ~0xFFFFFFFFLL) == 0);
719 }
720 
721 BOOST_AUTO_TEST_CASE(util_time_GetTime)
722 {
723  SetMockTime(111);
724  // Check that mock time does not change after a sleep
725  for (const auto& num_sleep : {0, 1}) {
726  MilliSleep(num_sleep);
727  BOOST_CHECK_EQUAL(111, GetTime()); // Deprecated time getter
728  BOOST_CHECK_EQUAL(111, GetTime<std::chrono::seconds>().count());
729  BOOST_CHECK_EQUAL(111000, GetTime<std::chrono::milliseconds>().count());
730  BOOST_CHECK_EQUAL(111000000, GetTime<std::chrono::microseconds>().count());
731  }
732 
733  SetMockTime(0);
734  // Check that system time changes after a sleep
735  const auto ms_0 = GetTime<std::chrono::milliseconds>();
736  const auto us_0 = GetTime<std::chrono::microseconds>();
737  MilliSleep(1);
738  BOOST_CHECK(ms_0 < GetTime<std::chrono::milliseconds>());
739  BOOST_CHECK(us_0 < GetTime<std::chrono::microseconds>());
740 }
741 
742 BOOST_AUTO_TEST_CASE(test_IsDigit)
743 {
744  BOOST_CHECK_EQUAL(IsDigit('0'), true);
745  BOOST_CHECK_EQUAL(IsDigit('1'), true);
746  BOOST_CHECK_EQUAL(IsDigit('8'), true);
747  BOOST_CHECK_EQUAL(IsDigit('9'), true);
748 
749  BOOST_CHECK_EQUAL(IsDigit('0' - 1), false);
750  BOOST_CHECK_EQUAL(IsDigit('9' + 1), false);
751  BOOST_CHECK_EQUAL(IsDigit(0), false);
752  BOOST_CHECK_EQUAL(IsDigit(1), false);
753  BOOST_CHECK_EQUAL(IsDigit(8), false);
754  BOOST_CHECK_EQUAL(IsDigit(9), false);
755 }
756 
757 BOOST_AUTO_TEST_CASE(test_ParseInt32)
758 {
759  int32_t n;
760  // Valid values
761  BOOST_CHECK(ParseInt32("1234", nullptr));
762  BOOST_CHECK(ParseInt32("0", &n) && n == 0);
763  BOOST_CHECK(ParseInt32("1234", &n) && n == 1234);
764  BOOST_CHECK(ParseInt32("01234", &n) && n == 1234); // no octal
765  BOOST_CHECK(ParseInt32("2147483647", &n) && n == 2147483647);
766  BOOST_CHECK(ParseInt32("-2147483648", &n) && n == -2147483648);
767  BOOST_CHECK(ParseInt32("-1234", &n) && n == -1234);
768  // Invalid values
769  BOOST_CHECK(!ParseInt32("", &n));
770  BOOST_CHECK(!ParseInt32(" 1", &n)); // no padding inside
771  BOOST_CHECK(!ParseInt32("1 ", &n));
772  BOOST_CHECK(!ParseInt32("1a", &n));
773  BOOST_CHECK(!ParseInt32("aap", &n));
774  BOOST_CHECK(!ParseInt32("0x1", &n)); // no hex
775  BOOST_CHECK(!ParseInt32("0x1", &n)); // no hex
776  const char test_bytes[] = {'1', 0, '1'};
777  std::string teststr(test_bytes, sizeof(test_bytes));
778  BOOST_CHECK(!ParseInt32(teststr, &n)); // no embedded NULs
779  // Overflow and underflow
780  BOOST_CHECK(!ParseInt32("-2147483649", nullptr));
781  BOOST_CHECK(!ParseInt32("2147483648", nullptr));
782  BOOST_CHECK(!ParseInt32("-32482348723847471234", nullptr));
783  BOOST_CHECK(!ParseInt32("32482348723847471234", nullptr));
784 }
785 
786 BOOST_AUTO_TEST_CASE(test_ParseInt64)
787 {
788  int64_t n;
789  // Valid values
790  BOOST_CHECK(ParseInt64("1234", nullptr));
791  BOOST_CHECK(ParseInt64("0", &n) && n == 0LL);
792  BOOST_CHECK(ParseInt64("1234", &n) && n == 1234LL);
793  BOOST_CHECK(ParseInt64("01234", &n) && n == 1234LL); // no octal
794  BOOST_CHECK(ParseInt64("2147483647", &n) && n == 2147483647LL);
795  BOOST_CHECK(ParseInt64("-2147483648", &n) && n == -2147483648LL);
796  BOOST_CHECK(ParseInt64("9223372036854775807", &n) && n == (int64_t)9223372036854775807);
797  BOOST_CHECK(ParseInt64("-9223372036854775808", &n) && n == (int64_t)-9223372036854775807-1);
798  BOOST_CHECK(ParseInt64("-1234", &n) && n == -1234LL);
799  // Invalid values
800  BOOST_CHECK(!ParseInt64("", &n));
801  BOOST_CHECK(!ParseInt64(" 1", &n)); // no padding inside
802  BOOST_CHECK(!ParseInt64("1 ", &n));
803  BOOST_CHECK(!ParseInt64("1a", &n));
804  BOOST_CHECK(!ParseInt64("aap", &n));
805  BOOST_CHECK(!ParseInt64("0x1", &n)); // no hex
806  const char test_bytes[] = {'1', 0, '1'};
807  std::string teststr(test_bytes, sizeof(test_bytes));
808  BOOST_CHECK(!ParseInt64(teststr, &n)); // no embedded NULs
809  // Overflow and underflow
810  BOOST_CHECK(!ParseInt64("-9223372036854775809", nullptr));
811  BOOST_CHECK(!ParseInt64("9223372036854775808", nullptr));
812  BOOST_CHECK(!ParseInt64("-32482348723847471234", nullptr));
813  BOOST_CHECK(!ParseInt64("32482348723847471234", nullptr));
814 }
815 
816 BOOST_AUTO_TEST_CASE(test_ParseDouble)
817 {
818  double n;
819  // Valid values
820  BOOST_CHECK(ParseDouble("1234", nullptr));
821  BOOST_CHECK(ParseDouble("0", &n) && n == 0.0);
822  BOOST_CHECK(ParseDouble("1234", &n) && n == 1234.0);
823  BOOST_CHECK(ParseDouble("01234", &n) && n == 1234.0); // no octal
824  BOOST_CHECK(ParseDouble("2147483647", &n) && n == 2147483647.0);
825  BOOST_CHECK(ParseDouble("-2147483648", &n) && n == -2147483648.0);
826  BOOST_CHECK(ParseDouble("-1234", &n) && n == -1234.0);
827  BOOST_CHECK(ParseDouble("1e6", &n) && n == 1e6);
828  BOOST_CHECK(ParseDouble("-1e6", &n) && n == -1e6);
829  // Invalid values
830  BOOST_CHECK(!ParseDouble("", &n));
831  BOOST_CHECK(!ParseDouble(" 1", &n)); // no padding inside
832  BOOST_CHECK(!ParseDouble("1 ", &n));
833  BOOST_CHECK(!ParseDouble("1a", &n));
834  BOOST_CHECK(!ParseDouble("aap", &n));
835  BOOST_CHECK(!ParseDouble("0x1", &n)); // no hex
836  const char test_bytes[] = {'1', 0, '1'};
837  std::string teststr(test_bytes, sizeof(test_bytes));
838  BOOST_CHECK(!ParseDouble(teststr, &n)); // no embedded NULs
839  // Overflow and underflow
840  BOOST_CHECK(!ParseDouble("-1e10000", nullptr));
841  BOOST_CHECK(!ParseDouble("1e10000", nullptr));
842 }
843 
844 BOOST_AUTO_TEST_CASE(test_FormatParagraph)
845 {
846  BOOST_CHECK_EQUAL(FormatParagraph("", 79, 0), "");
847  BOOST_CHECK_EQUAL(FormatParagraph("test", 79, 0), "test");
848  BOOST_CHECK_EQUAL(FormatParagraph(" test", 79, 0), "test");
849  BOOST_CHECK_EQUAL(FormatParagraph("test test", 79, 0), "test test");
850  BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 0), "test\ntest");
851  BOOST_CHECK_EQUAL(FormatParagraph("testerde test ", 4, 0), "testerde\ntest");
852  BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 4), "test\n test");
853  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.");
854 }
855 
856 BOOST_AUTO_TEST_CASE(test_FormatSubVersion)
857 {
858  std::vector<std::string> comments;
859  comments.push_back(std::string("comment1"));
860  std::vector<std::string> comments2;
861  comments2.push_back(std::string("comment1"));
862  comments2.push_back(std::string("comment2"));
863  BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, std::vector<std::string>()),std::string("/Test:0.9.99/"));
864  BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, comments),std::string("/Test:0.9.99(comment1)/"));
865  BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, comments2),std::string("/Test:0.9.99(comment1; comment2)/"));
866 }
867 
868 BOOST_AUTO_TEST_CASE(test_ParseFixedPoint)
869 {
870  int64_t amount = 0;
871  BOOST_CHECK(ParseFixedPoint("0", 8, &amount));
872  BOOST_CHECK_EQUAL(amount, 0LL);
873  BOOST_CHECK(ParseFixedPoint("1", 8, &amount));
874  BOOST_CHECK_EQUAL(amount, 100000000LL);
875  BOOST_CHECK(ParseFixedPoint("0.0", 8, &amount));
876  BOOST_CHECK_EQUAL(amount, 0LL);
877  BOOST_CHECK(ParseFixedPoint("-0.1", 8, &amount));
878  BOOST_CHECK_EQUAL(amount, -10000000LL);
879  BOOST_CHECK(ParseFixedPoint("1.1", 8, &amount));
880  BOOST_CHECK_EQUAL(amount, 110000000LL);
881  BOOST_CHECK(ParseFixedPoint("1.10000000000000000", 8, &amount));
882  BOOST_CHECK_EQUAL(amount, 110000000LL);
883  BOOST_CHECK(ParseFixedPoint("1.1e1", 8, &amount));
884  BOOST_CHECK_EQUAL(amount, 1100000000LL);
885  BOOST_CHECK(ParseFixedPoint("1.1e-1", 8, &amount));
886  BOOST_CHECK_EQUAL(amount, 11000000LL);
887  BOOST_CHECK(ParseFixedPoint("1000", 8, &amount));
888  BOOST_CHECK_EQUAL(amount, 100000000000LL);
889  BOOST_CHECK(ParseFixedPoint("-1000", 8, &amount));
890  BOOST_CHECK_EQUAL(amount, -100000000000LL);
891  BOOST_CHECK(ParseFixedPoint("0.00000001", 8, &amount));
892  BOOST_CHECK_EQUAL(amount, 1LL);
893  BOOST_CHECK(ParseFixedPoint("0.0000000100000000", 8, &amount));
894  BOOST_CHECK_EQUAL(amount, 1LL);
895  BOOST_CHECK(ParseFixedPoint("-0.00000001", 8, &amount));
896  BOOST_CHECK_EQUAL(amount, -1LL);
897  BOOST_CHECK(ParseFixedPoint("1000000000.00000001", 8, &amount));
898  BOOST_CHECK_EQUAL(amount, 100000000000000001LL);
899  BOOST_CHECK(ParseFixedPoint("9999999999.99999999", 8, &amount));
900  BOOST_CHECK_EQUAL(amount, 999999999999999999LL);
901  BOOST_CHECK(ParseFixedPoint("-9999999999.99999999", 8, &amount));
902  BOOST_CHECK_EQUAL(amount, -999999999999999999LL);
903 
904  BOOST_CHECK(!ParseFixedPoint("", 8, &amount));
905  BOOST_CHECK(!ParseFixedPoint("-", 8, &amount));
906  BOOST_CHECK(!ParseFixedPoint("a-1000", 8, &amount));
907  BOOST_CHECK(!ParseFixedPoint("-a1000", 8, &amount));
908  BOOST_CHECK(!ParseFixedPoint("-1000a", 8, &amount));
909  BOOST_CHECK(!ParseFixedPoint("-01000", 8, &amount));
910  BOOST_CHECK(!ParseFixedPoint("00.1", 8, &amount));
911  BOOST_CHECK(!ParseFixedPoint(".1", 8, &amount));
912  BOOST_CHECK(!ParseFixedPoint("--0.1", 8, &amount));
913  BOOST_CHECK(!ParseFixedPoint("0.000000001", 8, &amount));
914  BOOST_CHECK(!ParseFixedPoint("-0.000000001", 8, &amount));
915  BOOST_CHECK(!ParseFixedPoint("0.00000001000000001", 8, &amount));
916  BOOST_CHECK(!ParseFixedPoint("-10000000000.00000000", 8, &amount));
917  BOOST_CHECK(!ParseFixedPoint("10000000000.00000000", 8, &amount));
918  BOOST_CHECK(!ParseFixedPoint("-10000000000.00000001", 8, &amount));
919  BOOST_CHECK(!ParseFixedPoint("10000000000.00000001", 8, &amount));
920  BOOST_CHECK(!ParseFixedPoint("-10000000000.00000009", 8, &amount));
921  BOOST_CHECK(!ParseFixedPoint("10000000000.00000009", 8, &amount));
922  BOOST_CHECK(!ParseFixedPoint("-99999999999.99999999", 8, &amount));
923  BOOST_CHECK(!ParseFixedPoint("99999909999.09999999", 8, &amount));
924  BOOST_CHECK(!ParseFixedPoint("92233720368.54775807", 8, &amount));
925  BOOST_CHECK(!ParseFixedPoint("92233720368.54775808", 8, &amount));
926  BOOST_CHECK(!ParseFixedPoint("-92233720368.54775808", 8, &amount));
927  BOOST_CHECK(!ParseFixedPoint("-92233720368.54775809", 8, &amount));
928  BOOST_CHECK(!ParseFixedPoint("1.1e", 8, &amount));
929  BOOST_CHECK(!ParseFixedPoint("1.1e-", 8, &amount));
930  BOOST_CHECK(!ParseFixedPoint("1.", 8, &amount));
931 }
932 
933 BOOST_AUTO_TEST_CASE(test_ToLower)
934 {
935  BOOST_CHECK_EQUAL(ToLower('@'), '@');
936  BOOST_CHECK_EQUAL(ToLower('A'), 'a');
937  BOOST_CHECK_EQUAL(ToLower('Z'), 'z');
938  BOOST_CHECK_EQUAL(ToLower('['), '[');
939  BOOST_CHECK_EQUAL(ToLower(0), 0);
940  BOOST_CHECK_EQUAL(ToLower(255), 255);
941 
942  std::string testVector;
943  Downcase(testVector);
944  BOOST_CHECK_EQUAL(testVector, "");
945 
946  testVector = "#HODL";
947  Downcase(testVector);
948  BOOST_CHECK_EQUAL(testVector, "#hodl");
949 
950  testVector = "\x00\xfe\xff";
951  Downcase(testVector);
952  BOOST_CHECK_EQUAL(testVector, "\x00\xfe\xff");
953 }
954 
955 BOOST_AUTO_TEST_CASE(test_ToUpper)
956 {
957  BOOST_CHECK_EQUAL(ToUpper('`'), '`');
958  BOOST_CHECK_EQUAL(ToUpper('a'), 'A');
959  BOOST_CHECK_EQUAL(ToUpper('z'), 'Z');
960  BOOST_CHECK_EQUAL(ToUpper('{'), '{');
961  BOOST_CHECK_EQUAL(ToUpper(0), 0);
962  BOOST_CHECK_EQUAL(ToUpper(255), 255);
963 }
964 
965 BOOST_AUTO_TEST_CASE(test_Capitalize)
966 {
967  BOOST_CHECK_EQUAL(Capitalize(""), "");
968  BOOST_CHECK_EQUAL(Capitalize("pivx"), "Pivx");
969  BOOST_CHECK_EQUAL(Capitalize("\x00\xfe\xff"), "\x00\xfe\xff");
970 }
971 
972 BOOST_AUTO_TEST_CASE(test_validateURL)
973 {
974  // Must pass
975  BOOST_CHECK(validateURL("http://foo.bar"));
976  BOOST_CHECK(validateURL("https://foo.bar"));
977  BOOST_CHECK(validateURL("https://foo.bar/"));
978  BOOST_CHECK(validateURL("http://pivx.foo.bar"));
979  BOOST_CHECK(validateURL("https://foo.bar/pivx"));
980  BOOST_CHECK(validateURL("https://foo.bar/pivx/more/"));
981  BOOST_CHECK(validateURL("https://142.2.3.1"));
982  BOOST_CHECK(validateURL("https://foo_bar.pivx.com"));
983  BOOST_CHECK(validateURL("http://foo.bar/?baz=some"));
984  BOOST_CHECK(validateURL("http://foo.bar/?baz=some&p=364"));
985 
986  // Must fail
987  BOOST_CHECK(!validateURL("BlahBlah"));
988  BOOST_CHECK(!validateURL("foo.bar"));
989  BOOST_CHECK(!validateURL("://foo.bar"));
990  BOOST_CHECK(!validateURL("www.foo.bar"));
991  BOOST_CHECK(!validateURL("http://foo..bar"));
992  BOOST_CHECK(!validateURL("http:///foo.bar"));
993  BOOST_CHECK(!validateURL("http:// foo.bar"));
994  BOOST_CHECK(!validateURL("http://foo .bar"));
995  BOOST_CHECK(!validateURL("http://foo"));
996  BOOST_CHECK(!validateURL("http://foo.bar."));
997  BOOST_CHECK(!validateURL("http://foo.bar.."));
998  BOOST_CHECK(!validateURL("http://"));
999  BOOST_CHECK(!validateURL("http://.something.com"));
1000  BOOST_CHECK(!validateURL("http://?something.com"));
1001  BOOST_CHECK(!validateURL("https://foo.bar/?q=Spaces are not encoded"));
1002 }
1003 
1004 static void TestOtherThread(fs::path dirname, std::string lockname, bool *result)
1005 {
1006  *result = LockDirectory(dirname, lockname);
1007 }
1008 
1009 #ifndef WIN32 // Cannot do this test on WIN32 due to lack of fork()
1010 static constexpr char LockCommand = 'L';
1011 static constexpr char UnlockCommand = 'U';
1012 static constexpr char ExitCommand = 'X';
1013 
1014 static void TestOtherProcess(fs::path dirname, std::string lockname, int fd)
1015 {
1016  char ch;
1017  int rv;
1018  while (true) {
1019  rv = read(fd, &ch, 1); // Wait for command
1020  assert(rv == 1);
1021  switch(ch) {
1022  case LockCommand:
1023  ch = LockDirectory(dirname, lockname);
1024  rv = write(fd, &ch, 1);
1025  assert(rv == 1);
1026  break;
1027  case UnlockCommand:
1028  ReleaseDirectoryLocks();
1029  ch = true; // Always succeeds
1030  rv = write(fd, &ch, 1);
1031  break;
1032  case ExitCommand:
1033  close(fd);
1034  exit(0);
1035  default:
1036  assert(0);
1037  }
1038  }
1039 }
1040 #endif
1041 
1042 BOOST_AUTO_TEST_CASE(test_LockDirectory)
1043 {
1044  fs::path dirname = fs::temp_directory_path() / fs::unique_path();
1045  const std::string lockname = ".lock";
1046 #ifndef WIN32
1047  // Revert SIGCHLD to default, otherwise boost.test will catch and fail on
1048  // it: there is BOOST_TEST_IGNORE_SIGCHLD but that only works when defined
1049  // at build-time of the boost library
1050  void (*old_handler)(int) = signal(SIGCHLD, SIG_DFL);
1051 
1052  // Fork another process for testing before creating the lock, so that we
1053  // won't fork while holding the lock (which might be undefined, and is not
1054  // relevant as test case as that is avoided with -daemonize).
1055  int fd[2];
1056  BOOST_CHECK_EQUAL(socketpair(AF_UNIX, SOCK_STREAM, 0, fd), 0);
1057  pid_t pid = fork();
1058  if (!pid) {
1059  BOOST_CHECK_EQUAL(close(fd[1]), 0); // Child: close parent end
1060  TestOtherProcess(dirname, lockname, fd[0]);
1061  }
1062  BOOST_CHECK_EQUAL(close(fd[0]), 0); // Parent: close child end
1063 #endif
1064  // Lock on non-existent directory should fail
1065  BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname), false);
1066 
1067  fs::create_directories(dirname);
1068 
1069  // Probing lock on new directory should succeed
1070  BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
1071 
1072  // Persistent lock on new directory should succeed
1073  BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname), true);
1074 
1075  // Another lock on the directory from the same thread should succeed
1076  BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname), true);
1077 
1078  // Another lock on the directory from a different thread within the same process should succeed
1079  bool threadresult;
1080  std::thread thr(TestOtherThread, dirname, lockname, &threadresult);
1081  thr.join();
1082  BOOST_CHECK_EQUAL(threadresult, true);
1083 #ifndef WIN32
1084  // Try to acquire lock in child process while we're holding it, this should fail.
1085  char ch;
1086  BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
1087  BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
1088  BOOST_CHECK_EQUAL((bool)ch, false);
1089 
1090  // Give up our lock
1091  ReleaseDirectoryLocks();
1092  // Probing lock from our side now should succeed, but not hold on to the lock.
1093  BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
1094 
1095  // Try to acquire the lock in the child process, this should be successful.
1096  BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
1097  BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
1098  BOOST_CHECK_EQUAL((bool)ch, true);
1099 
1100  // When we try to probe the lock now, it should fail.
1101  BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), false);
1102 
1103  // Unlock the lock in the child process
1104  BOOST_CHECK_EQUAL(write(fd[1], &UnlockCommand, 1), 1);
1105  BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
1106  BOOST_CHECK_EQUAL((bool)ch, true);
1107 
1108  // When we try to probe the lock now, it should succeed.
1109  BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
1110 
1111  // Re-lock the lock in the child process, then wait for it to exit, check
1112  // successful return. After that, we check that exiting the process
1113  // has released the lock as we would expect by probing it.
1114  int processstatus;
1115  BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
1116  BOOST_CHECK_EQUAL(write(fd[1], &ExitCommand, 1), 1);
1117  BOOST_CHECK_EQUAL(waitpid(pid, &processstatus, 0), pid);
1118  BOOST_CHECK_EQUAL(processstatus, 0);
1119  BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
1120 
1121  // Restore SIGCHLD
1122  signal(SIGCHLD, old_handler);
1123  BOOST_CHECK_EQUAL(close(fd[1]), 0); // Close our side of the socketpair
1124 #endif
1125  // Clean up
1126  ReleaseDirectoryLocks();
1127  fs::remove_all(dirname);
1128 }
1129 
1130 BOOST_AUTO_TEST_CASE(test_DirIsWritable)
1131 {
1132  // Should be able to write to the system tmp dir.
1133  fs::path tmpdirname = fs::temp_directory_path();
1134  BOOST_CHECK_EQUAL(DirIsWritable(tmpdirname), true);
1135 
1136  // Should not be able to write to a non-existent dir.
1137  tmpdirname = fs::temp_directory_path() / fs::unique_path();
1138  BOOST_CHECK_EQUAL(DirIsWritable(tmpdirname), false);
1139 
1140  fs::create_directory(tmpdirname);
1141  // Should be able to write to it now.
1142  BOOST_CHECK_EQUAL(DirIsWritable(tmpdirname), true);
1143  fs::remove(tmpdirname);
1144 }
1145 
1146 namespace {
1147 
1148  struct Tracker
1149  {
1151  const Tracker* origin;
1153  int copies;
1154 
1155  Tracker() noexcept : origin(this), copies(0) {}
1156  Tracker(const Tracker& t) noexcept : origin(t.origin), copies(t.copies + 1) {}
1157  Tracker(Tracker&& t) noexcept : origin(t.origin), copies(t.copies) {}
1158  Tracker& operator=(const Tracker& t) noexcept
1159  {
1160  origin = t.origin;
1161  copies = t.copies + 1;
1162  return *this;
1163  }
1164  Tracker& operator=(Tracker&& t) noexcept
1165  {
1166  origin = t.origin;
1167  copies = t.copies;
1168  return *this;
1169  }
1170  };
1171 
1172 }
1173 
1174 BOOST_AUTO_TEST_CASE(test_tracked_vector)
1175 {
1176  Tracker t1;
1177  Tracker t2;
1178  Tracker t3;
1179 
1180  BOOST_CHECK(t1.origin == &t1);
1181  BOOST_CHECK(t2.origin == &t2);
1182  BOOST_CHECK(t3.origin == &t3);
1183 
1184  auto v1 = Vector(t1);
1185  BOOST_CHECK_EQUAL(v1.size(), 1);
1186  BOOST_CHECK(v1[0].origin == &t1);
1187  BOOST_CHECK_EQUAL(v1[0].copies, 1);
1188 
1189  auto v2 = Vector(std::move(t2));
1190  BOOST_CHECK_EQUAL(v2.size(), 1);
1191  BOOST_CHECK(v2[0].origin == &t2);
1192  BOOST_CHECK_EQUAL(v2[0].copies, 0);
1193 
1194  auto v3 = Vector(t1, std::move(t2));
1195  BOOST_CHECK_EQUAL(v3.size(), 2);
1196  BOOST_CHECK(v3[0].origin == &t1);
1197  BOOST_CHECK(v3[1].origin == &t2);
1198  BOOST_CHECK_EQUAL(v3[0].copies, 1);
1199  BOOST_CHECK_EQUAL(v3[1].copies, 0);
1200 
1201  auto v4 = Vector(std::move(v3[0]), v3[1], std::move(t3));
1202  BOOST_CHECK_EQUAL(v4.size(), 3);
1203  BOOST_CHECK(v4[0].origin == &t1);
1204  BOOST_CHECK(v4[1].origin == &t2);
1205  BOOST_CHECK(v4[2].origin == &t3);
1206  BOOST_CHECK_EQUAL(v4[0].copies, 1);
1207  BOOST_CHECK_EQUAL(v4[1].copies, 1);
1208  BOOST_CHECK_EQUAL(v4[2].copies, 0);
1209 
1210  auto v5 = Cat(v1, v4);
1211  BOOST_CHECK_EQUAL(v5.size(), 4);
1212  BOOST_CHECK(v5[0].origin == &t1);
1213  BOOST_CHECK(v5[1].origin == &t1);
1214  BOOST_CHECK(v5[2].origin == &t2);
1215  BOOST_CHECK(v5[3].origin == &t3);
1216  BOOST_CHECK_EQUAL(v5[0].copies, 2);
1217  BOOST_CHECK_EQUAL(v5[1].copies, 2);
1218  BOOST_CHECK_EQUAL(v5[2].copies, 2);
1219  BOOST_CHECK_EQUAL(v5[3].copies, 1);
1220 
1221  auto v6 = Cat(std::move(v1), v3);
1222  BOOST_CHECK_EQUAL(v6.size(), 3);
1223  BOOST_CHECK(v6[0].origin == &t1);
1224  BOOST_CHECK(v6[1].origin == &t1);
1225  BOOST_CHECK(v6[2].origin == &t2);
1226  BOOST_CHECK_EQUAL(v6[0].copies, 1);
1227  BOOST_CHECK_EQUAL(v6[1].copies, 2);
1228  BOOST_CHECK_EQUAL(v6[2].copies, 1);
1229 
1230  auto v7 = Cat(v2, std::move(v4));
1231  BOOST_CHECK_EQUAL(v7.size(), 4);
1232  BOOST_CHECK(v7[0].origin == &t2);
1233  BOOST_CHECK(v7[1].origin == &t1);
1234  BOOST_CHECK(v7[2].origin == &t2);
1235  BOOST_CHECK(v7[3].origin == &t3);
1236  BOOST_CHECK_EQUAL(v7[0].copies, 1);
1237  BOOST_CHECK_EQUAL(v7[1].copies, 1);
1238  BOOST_CHECK_EQUAL(v7[2].copies, 1);
1239  BOOST_CHECK_EQUAL(v7[3].copies, 0);
1240 
1241  auto v8 = Cat(std::move(v2), std::move(v3));
1242  BOOST_CHECK_EQUAL(v8.size(), 3);
1243  BOOST_CHECK(v8[0].origin == &t2);
1244  BOOST_CHECK(v8[1].origin == &t1);
1245  BOOST_CHECK(v8[2].origin == &t2);
1246  BOOST_CHECK_EQUAL(v8[0].copies, 0);
1247  BOOST_CHECK_EQUAL(v8[1].copies, 1);
1248  BOOST_CHECK_EQUAL(v8[2].copies, 0);
1249 }
1250 
1251 BOOST_AUTO_TEST_SUITE_END()
CAmount
int64_t CAmount
Amount in PIV (Can be negative)
Definition: amount.h:13
ArgsManager::IsArgNegated
bool IsArgNegated(const std::string &strArg) const
Return true if the argument was originally passed as a negated option, i.e.
Definition: system.cpp:431
ArgsManager::ParseParameters
void ParseParameters(int argc, const char *const argv[])
Definition: system.cpp:371
ArgsManager::GetArgs
std::vector< std::string > GetArgs(const std::string &strArg) const
Return a vector of strings of the given argument.
Definition: system.cpp:406
ArgsManager::m_override_args
std::map< std::string, std::vector< std::string > > m_override_args
Definition: system.h:133
ArgsManager::m_network_only_args
std::set< std::string > m_network_only_args
Definition: system.h:136
ArgsManager::SelectConfigNetwork
void SelectConfigNetwork(const std::string &network)
Select the network in use.
Definition: system.cpp:366
ArgsManager::m_config_args
std::map< std::string, std::vector< std::string > > m_config_args
Definition: system.h:134
ArgsManager::IsArgSet
bool IsArgSet(const std::string &strArg) const
Return true if the given argument has been manually set.
Definition: system.cpp:425
ArgsManager::ReadConfigStream
void ReadConfigStream(std::istream &stream)
Definition: system.cpp:816
ArgsManager::cs_args
RecursiveMutex cs_args
Definition: system.h:132
ArgsManager::GetArg
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
Definition: system.cpp:449
ArgsManager::GetBoolArg
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
Definition: system.cpp:465
ArgsManager::GetChainName
std::string GetChainName() const
Looks for -regtest, -testnet and returns the appropriate BIP70 chain name.
Definition: system.cpp:861
CBaseChainParams::MAIN
static const std::string MAIN
Chain name strings.
Definition: chainparamsbase.h:22
Span
A Span is an object that can refer to a contiguous sequence of objects.
Definition: span.h:93
FormatSubVersion
std::string FormatSubVersion(const std::string &name, int nClientVersion, const std::vector< std::string > &comments)
Format the subversion field according to BIP 14 spec (https://github.com/bitcoin/bips/blob/master/bip...
Definition: clientversion.cpp:93
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
LOCK
@ LOCK
Definition: lockunlock.h:16
BOOST_CHECK_THROW
#define BOOST_CHECK_THROW(stmt, excMatch)
Definition: object.cpp:19
BOOST_FIXTURE_TEST_SUITE
#define BOOST_FIXTURE_TEST_SUITE(a, b)
Definition: object.cpp:14
BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:18
BOOST_CHECK
#define BOOST_CHECK(expr)
Definition: object.cpp:17
Join
std::string Join(const std::vector< T > &list, const std::string &separator, UnaryOp unary_op)
Join a list of items.
Definition: string.h:26
BasicTestingSetup
Basic testing setup.
Definition: test_pivx.h:51
TestArgsManager::GetOverrideArgs
std::map< std::string, std::vector< std::string > > & GetOverrideArgs()
Definition: util_tests.cpp:132
TestArgsManager::SetNetworkOnlyArg
void SetNetworkOnlyArg(const std::string arg)
Definition: util_tests.cpp:143
TestArgsManager::ReadConfigString
void ReadConfigString(const std::string str_config)
Definition: util_tests.cpp:134
TestArgsManager::GetConfigArgs
std::map< std::string, std::vector< std::string > > & GetConfigArgs()
Definition: util_tests.cpp:133
TRY_LOCK
#define TRY_LOCK(cs, name)
Definition: sync.h:224
DirIsWritable
bool DirIsWritable(const fs::path &directory)
Definition: system.cpp:140
ReleaseDirectoryLocks
void ReleaseDirectoryLocks()
Release all directory locks.
Definition: system.cpp:134
LockDirectory
bool LockDirectory(const fs::path &directory, const std::string &lockfile_name, bool probe_only)
Definition: system.cpp:110
test_pivx.h
SeedRand::ZEROS
@ ZEROS
Seed with a compile time constant of zeros.
strprintf
#define strprintf
Definition: tinyformat.h:1056
E
#define E
Definition: util_tests.cpp:689
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(util_criticalsection)
Definition: util_tests.cpp:27
B
#define B
Definition: util_tests.cpp:688
ParseMoney
bool ParseMoney(const std::string &str, CAmount &nRet)
Definition: utilmoneystr.cpp:38
FormatMoney
std::string FormatMoney(const CAmount &n, bool fPlus)
Money parsing/formatting utilities.
Definition: utilmoneystr.cpp:14
Downcase
void Downcase(std::string &str)
Converts the given string to its lowercase equivalent.
Definition: utilstrencodings.cpp:537
Capitalize
std::string Capitalize(std::string str)
Capitalizes the first character of the given string.
Definition: utilstrencodings.cpp:556
HexStr
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
Definition: utilstrencodings.cpp:563
FormatParagraph
std::string FormatParagraph(const std::string in, size_t width, size_t indent)
Format a paragraph of text to a fixed width, adding spaces for indentation to any added line.
Definition: utilstrencodings.cpp:352
ToLower
std::string ToLower(const std::string &str)
Returns the lowercase equivalent of the given string.
Definition: utilstrencodings.cpp:542
ParseHex
std::vector< unsigned char > ParseHex(const char *psz)
Definition: utilstrencodings.cpp:99
validateURL
bool validateURL(const std::string &strURL)
Definition: utilstrencodings.cpp:41
ParseInt32
bool ParseInt32(const std::string &str, int32_t *out)
Convert string to signed 32-bit integer with strict parse error feedback.
Definition: utilstrencodings.cpp:278
ParseFixedPoint
bool ParseFixedPoint(const std::string &val, int decimals, int64_t *amount_out)
Parse number as fixed point according to JSON number syntax.
Definition: utilstrencodings.cpp:445
IsHex
bool IsHex(const std::string &str)
Definition: utilstrencodings.cpp:90
ParseInt64
bool ParseInt64(const std::string &str, int64_t *out)
Convert string to signed 64-bit integer with strict parse error feedback.
Definition: utilstrencodings.cpp:294
ParseDouble
bool ParseDouble(const std::string &str, double *out)
Convert string to double with strict parse error feedback.
Definition: utilstrencodings.cpp:338
ToUpper
std::string ToUpper(const std::string &str)
Returns the uppercase equivalent of the given string.
Definition: utilstrencodings.cpp:549
IsDigit
constexpr bool IsDigit(char c)
Tests if the given character is a decimal digit.
Definition: utilstrencodings.h:91
TimingResistantEqual
bool TimingResistantEqual(const T &a, const T &b)
Timing-attack-resistant comparison.
Definition: utilstrencodings.h:168
FormatISO8601Date
std::string FormatISO8601Date(int64_t nTime)
Definition: utiltime.cpp:128
SetMockTime
void SetMockTime(int64_t nMockTimeIn)
For testing.
Definition: utiltime.cpp:51
FormatISO8601Time
std::string FormatISO8601Time(int64_t nTime)
Definition: utiltime.cpp:141
FormatISO8601DateTimeForBackup
std::string FormatISO8601DateTimeForBackup(int64_t nTime)
Definition: utiltime.cpp:115
MilliSleep
void MilliSleep(int64_t n)
Definition: utiltime.cpp:82
GetTime
int64_t GetTime()
DEPRECATED Use either GetSystemTimeInSeconds (not mockable) or GetTime<T> (mockable)
Definition: utiltime.cpp:27
FormatISO8601DateTime
std::string FormatISO8601DateTime(int64_t nTime)
ISO 8601 formatting is preferred.
Definition: utiltime.cpp:102
Vector
std::vector< typename std::common_type< Args... >::type > Vector(Args &&... args)
Construct a vector with the specified elements.
Definition: vector.h:20
Cat
V Cat(V v1, V &&v2)
Concatenate two vectors, moving elements.
Definition: vector.h:31
Generated on Wed Apr 2 2025 00:40:38 for PIVX Core by doxygen 1.9.1