38 #include <sys/types.h>
42 #include <boost/test/unit_test.hpp>
44 using namespace std::literals;
82 const std::unique_ptr<int> p_two =
Assert(std::make_unique<int>(2));
84 const int two = *
Assert(p_two);
88 const bool result{
Assume(two == 2)};
100 BOOST_ERROR(
"break was swallowed!");
110 BOOST_ERROR(
"break was swallowed!");
115 0x04, 0x67, 0x8a, 0xfd, 0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67, 0xf1, 0xa6, 0x71, 0x30, 0xb7,
116 0x10, 0x5c, 0xd6, 0xa8, 0x28, 0xe0, 0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, 0xea, 0x1f, 0x61, 0xde,
117 0xb6, 0x49, 0xf6, 0xbc, 0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04, 0xe5, 0x1e, 0xc1, 0x12,
118 0xde, 0x5c, 0x38, 0x4d, 0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, 0x2b, 0x6b, 0xf1, 0x1d,
123 std::vector<unsigned char> result;
126 result =
ParseHex(
"04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
127 BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
131 BOOST_CHECK(result.size() == 4 && result[0] == 0x12 && result[1] == 0x34 && result[2] == 0x56 && result[3] == 0x78);
135 BOOST_CHECK(result.size() == 4 && result[0] == 0x89 && result[1] == 0x34 && result[2] == 0x56 && result[3] == 0x78);
138 result =
ParseHex(
"1234 invalid 1234");
139 BOOST_CHECK(result.size() == 2 && result[0] == 0x12 && result[1] == 0x34);
146 "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
160 const std::string out_exp{
"04678afdb0"};
170 std::array mut_arr{uint8_t{0xaa}, uint8_t{0xbb}};
172 mut_bytes[1] = std::byte{0x11};
185 const auto op_upper = [](
const std::string& s) {
return ToUpper(s); };
188 BOOST_CHECK_EQUAL(Join<std::string>({
"foo",
"bar"},
", ", op_upper),
"FOO, BAR");
203 BOOST_CHECK_EQUAL(
TrimString(std::string(
"\x05\x04\x03\x02\x01\x00", 6), std::string(
"\x05\x04\x03\x02\x01", 5)), std::string(
"\0", 1));
230 std::istringstream streamConfig(str_config);
233 m_settings.ro_config.clear();
234 m_config_sections.clear();
237 BOOST_REQUIRE(ReadConfigStream(streamConfig,
"",
error));
242 m_network_only_args.insert(arg);
244 void SetupArgs(
const std::vector<std::pair<std::string, unsigned int>>&
args)
246 for (
const auto& arg :
args) {
254 using ArgsManager::m_network;
255 using ArgsManager::m_settings;
264 bool default_string =
false;
265 bool default_int =
false;
266 bool default_bool =
false;
267 const char* string_value =
nullptr;
280 Expect&
List(std::vector<std::string> m) { list_value = std::move(
m);
return *
this; }
288 const char* argv[] = {
"ignored", arg};
294 if (
expect.setting.isNull() ||
expect.setting.isFalse()) {
303 BOOST_CHECK_NE(
error.find(
expect.error), std::string::npos);
309 if (
expect.default_string) {
311 }
else if (
expect.string_value) {
319 }
else if (
expect.int_value) {
325 if (
expect.default_bool) {
328 }
else if (
expect.bool_value) {
336 auto l = test.
GetArgs(
"-value");
337 BOOST_CHECK_EQUAL_COLLECTIONS(l.begin(), l.end(),
expect.list_value->begin(),
expect.list_value->end());
348 CheckValue(M::ALLOW_ANY,
nullptr, Expect{{}}.DefaultString().DefaultInt().DefaultBool().List({}));
349 CheckValue(M::ALLOW_ANY,
"-novalue", Expect{
false}.String(
"0").Int(0).Bool(
false).List({}));
350 CheckValue(M::ALLOW_ANY,
"-novalue=", Expect{
false}.String(
"0").Int(0).Bool(
false).List({}));
351 CheckValue(M::ALLOW_ANY,
"-novalue=0", Expect{
true}.String(
"1").Int(1).Bool(
true).List({
"1"}));
352 CheckValue(M::ALLOW_ANY,
"-novalue=1", Expect{
false}.String(
"0").Int(0).Bool(
false).List({}));
353 CheckValue(M::ALLOW_ANY,
"-novalue=2", Expect{
false}.String(
"0").Int(0).Bool(
false).List({}));
354 CheckValue(M::ALLOW_ANY,
"-novalue=abc", Expect{
true}.String(
"1").Int(1).Bool(
true).List({
"1"}));
355 CheckValue(M::ALLOW_ANY,
"-value", Expect{
""}.String(
"").Int(0).Bool(
true).List({
""}));
356 CheckValue(M::ALLOW_ANY,
"-value=", Expect{
""}.String(
"").Int(0).Bool(
true).List({
""}));
357 CheckValue(M::ALLOW_ANY,
"-value=0", Expect{
"0"}.String(
"0").Int(0).Bool(
false).List({
"0"}));
358 CheckValue(M::ALLOW_ANY,
"-value=1", Expect{
"1"}.String(
"1").Int(1).Bool(
true).List({
"1"}));
359 CheckValue(M::ALLOW_ANY,
"-value=2", Expect{
"2"}.String(
"2").Int(2).Bool(
true).List({
"2"}));
360 CheckValue(M::ALLOW_ANY,
"-value=abc", Expect{
"abc"}.String(
"abc").Int(0).Bool(
false).List({
"abc"}));
368 std::array argv{
"ignored", arg};
378 BOOST_CHECK_EQUAL(
Parse(
"-includeconf"),
"-includeconf cannot be used from commandline; -includeconf=\"\"");
379 BOOST_CHECK_EQUAL(
Parse(
"-includeconf=file"),
"-includeconf cannot be used from commandline; -includeconf=\"file\"");
390 const char *argv_test[] = {
"-ignored",
"-a",
"-b",
"-ccc=argument",
"-ccc=multiple",
"f",
"-d=e"};
396 BOOST_CHECK(testArgs.m_settings.command_line_options.empty() && testArgs.m_settings.ro_config.empty());
399 BOOST_CHECK(testArgs.m_settings.command_line_options.empty() && testArgs.m_settings.ro_config.empty());
405 BOOST_CHECK(testArgs.m_settings.command_line_options.size() == 3 && testArgs.m_settings.ro_config.empty());
408 BOOST_CHECK(testArgs.m_settings.command_line_options.count(
"a") && testArgs.m_settings.command_line_options.count(
"b") && testArgs.m_settings.command_line_options.count(
"ccc")
409 && !testArgs.m_settings.command_line_options.count(
"f") && !testArgs.m_settings.command_line_options.count(
"d"));
411 BOOST_CHECK(testArgs.m_settings.command_line_options[
"a"].size() == 1);
412 BOOST_CHECK(testArgs.m_settings.command_line_options[
"a"].front().get_str() ==
"");
413 BOOST_CHECK(testArgs.m_settings.command_line_options[
"ccc"].size() == 2);
414 BOOST_CHECK(testArgs.m_settings.command_line_options[
"ccc"].front().get_str() ==
"argument");
415 BOOST_CHECK(testArgs.m_settings.command_line_options[
"ccc"].back().get_str() ==
"multiple");
424 const char* argv[] = {
"ignored",
"-registered"};
429 argv[1] =
"-unregistered";
435 argv[1] =
"-test.registered";
440 static void TestParse(
const std::string& str,
bool expected_bool, int64_t expected_int)
444 std::string arg =
"-value=" + str;
445 const char* argv[] = {
"ignored", arg.c_str()};
504 const char *argv_test[] = {
505 "ignored",
"-a",
"-nob",
"-c=0",
"-d=1",
"-e=false",
"-f=true"};
512 for (
const char opt :
"abcdef")
516 BOOST_CHECK(testArgs.m_settings.command_line_options.size() == 6 &&
517 testArgs.m_settings.ro_config.empty());
543 const char *argv_test[] = {
"ignored",
"-nofoo",
"-foo",
"-nobar=0"};
557 const char *conf_test =
"nofoo=1\nfoo=1\nnobar=0\n";
571 const char *combo_test_args[] = {
"ignored",
"-nofoo",
"-bar"};
572 const char *combo_test_conf =
"foo=1\nnobar=1\n";
585 && testArgs.
GetArgs(
"-bar").front() ==
"");
590 const char *str_config =
624 test_args.
SetupArgs({a, b, ccc, d, e, fff, ggg, h, i, iii});
630 BOOST_CHECK(test_args.m_settings.command_line_options.empty());
631 BOOST_CHECK(test_args.m_settings.ro_config.size() == 3);
632 BOOST_CHECK(test_args.m_settings.ro_config[
""].size() == 8);
633 BOOST_CHECK(test_args.m_settings.ro_config[
"sec1"].size() == 3);
634 BOOST_CHECK(test_args.m_settings.ro_config[
"sec2"].size() == 2);
636 BOOST_CHECK(test_args.m_settings.ro_config[
""].count(
"a"));
637 BOOST_CHECK(test_args.m_settings.ro_config[
""].count(
"b"));
638 BOOST_CHECK(test_args.m_settings.ro_config[
""].count(
"ccc"));
639 BOOST_CHECK(test_args.m_settings.ro_config[
""].count(
"d"));
640 BOOST_CHECK(test_args.m_settings.ro_config[
""].count(
"fff"));
641 BOOST_CHECK(test_args.m_settings.ro_config[
""].count(
"ggg"));
642 BOOST_CHECK(test_args.m_settings.ro_config[
""].count(
"h"));
643 BOOST_CHECK(test_args.m_settings.ro_config[
""].count(
"i"));
644 BOOST_CHECK(test_args.m_settings.ro_config[
"sec1"].count(
"ccc"));
645 BOOST_CHECK(test_args.m_settings.ro_config[
"sec1"].count(
"h"));
646 BOOST_CHECK(test_args.m_settings.ro_config[
"sec2"].count(
"ccc"));
647 BOOST_CHECK(test_args.m_settings.ro_config[
"sec2"].count(
"iii"));
671 for (
const bool def : {
false,
true}) {
685 && test_args.
GetArgs(
"-a").front() ==
"");
687 && test_args.
GetArgs(
"-b").front() ==
"1");
689 && test_args.
GetArgs(
"-ccc").front() ==
"argument"
690 && test_args.
GetArgs(
"-ccc").back() ==
"multiple");
694 && test_args.
GetArgs(
"-ggg").front() ==
"1");
699 && test_args.
GetArgs(
"-i").front() ==
"1");
730 const std::vector<std::string> sec1_ccc_expected = {
"extend1",
"extend2",
"argument",
"multiple"};
731 const auto& sec1_ccc_res = test_args.
GetArgs(
"-ccc");
732 BOOST_CHECK_EQUAL_COLLECTIONS(sec1_ccc_res.begin(), sec1_ccc_res.end(), sec1_ccc_expected.begin(), sec1_ccc_expected.end());
749 const std::vector<std::string> sec2_ccc_expected = {
"extend3",
"argument",
"multiple"};
750 const auto& sec2_ccc_res = test_args.
GetArgs(
"-ccc");
751 BOOST_CHECK_EQUAL_COLLECTIONS(sec2_ccc_res.begin(), sec2_ccc_res.end(), sec2_ccc_expected.begin(), sec2_ccc_expected.end());
781 testArgs.m_settings.command_line_options.clear();
782 testArgs.m_settings.command_line_options[
"strtest1"] = {
"string..."};
784 testArgs.m_settings.command_line_options[
"inttest1"] = {
"12345"};
785 testArgs.m_settings.command_line_options[
"inttest2"] = {
"81985529216486895"};
787 testArgs.m_settings.command_line_options[
"booltest1"] = {
""};
789 testArgs.m_settings.command_line_options[
"booltest3"] = {
"0"};
790 testArgs.m_settings.command_line_options[
"booltest4"] = {
"1"};
793 testArgs.m_settings.command_line_options[
"pritest1"] = {
"a",
"b"};
794 testArgs.m_settings.ro_config[
""][
"pritest2"] = {
"a",
"b"};
795 testArgs.m_settings.command_line_options[
"pritest3"] = {
"a"};
796 testArgs.m_settings.ro_config[
""][
"pritest3"] = {
"b"};
797 testArgs.m_settings.command_line_options[
"pritest4"] = {
"a",
"b"};
798 testArgs.m_settings.ro_config[
""][
"pritest4"] = {
"c",
"d"};
823 const char* argv_testnet[] = {
"cmd",
"-testnet"};
824 const char* argv_regtest[] = {
"cmd",
"-regtest"};
825 const char* argv_test_no_reg[] = {
"cmd",
"-testnet",
"-noregtest"};
826 const char* argv_both[] = {
"cmd",
"-testnet",
"-regtest"};
830 const char* testnetconf =
"testnet=1\nregtest=0\n[test]\nregtest=1";
918 static constexpr
int MAX_ACTIONS = 3;
920 enum Action { NONE,
SET, NEGATE, SECTION_SET, SECTION_NEGATE };
924 template <
typename Fn>
932 for (
bool soft_set : {
false,
true}) {
933 for (
bool force_set : {
false,
true}) {
936 for (
bool net_specific : {
false,
true}) {
937 fn(arg_actions, conf_actions, soft_set, force_set, section, network, net_specific);
949 const std::string& section,
950 const std::string&
name,
951 const std::string& value_prefix)
953 std::vector<std::string>
values;
955 for (
Action action : actions) {
956 if (action == NONE)
break;
958 if (action == SECTION_SET || action == SECTION_NEGATE)
prefix = section +
".";
959 if (action == SET || action == SECTION_SET) {
960 for (
int i = 0; i < 2; ++i) {
964 if (action == NEGATE || action == SECTION_NEGATE) {
979 FILE* out_file =
nullptr;
980 if (
const char* out_path = getenv(
"ARGS_MERGE_TEST_OUT")) {
982 if (!out_file)
throw std::system_error(errno, std::generic_category(),
"fopen failed");
985 ForEachMergeSetup([&](
const ActionList& arg_actions,
const ActionList& conf_actions,
bool soft_set,
bool force_set,
986 const std::string& section,
const std::string& network,
bool net_specific) {
990 std::string desc =
"net=";
992 parser.m_network = network;
994 const std::string&
name = net_specific ?
"wallet" :
"server";
995 const std::string key =
"-" +
name;
999 auto args = GetValues(arg_actions, section,
name,
"a");
1000 std::vector<const char*> argv = {
"ignored"};
1001 for (
auto& arg :
args) {
1005 argv.push_back(arg.c_str());
1012 for (
auto& conf_val : GetValues(conf_actions, section,
name,
"c")) {
1018 std::istringstream conf_stream(conf);
1046 desc += parser.
GetArg(key,
"default");
1048 for (
const auto& arg : parser.
GetArgs(key)) {
1055 if (!ignored.empty()) {
1056 desc +=
" | ignored";
1057 for (
const auto& arg : ignored) {
1067 BOOST_REQUIRE(fwrite(desc.data(), 1, desc.size(), out_file) == desc.size());
1072 if (fclose(out_file))
throw std::system_error(errno, std::generic_category(),
"fclose failed");
1078 std::string out_sha_hex =
HexStr(out_sha_bytes);
1089 BOOST_CHECK_EQUAL(out_sha_hex,
"d1e436c1cd510d0ec44d5205d4b4e3bee6387d316e0075c58206cb16603f3d82");
1094 static constexpr
int MAX_ACTIONS = 2;
1096 enum Action {
NONE, ENABLE_TEST, DISABLE_TEST, NEGATE_TEST, ENABLE_REG, DISABLE_REG, NEGATE_REG };
1100 template <
typename Fn>
1104 ForEachNoDup(arg_actions, ENABLE_TEST, NEGATE_REG, [&] {
1106 ForEachNoDup(conf_actions, ENABLE_TEST, NEGATE_REG, [&] { fn(arg_actions, conf_actions); });
1114 FILE* out_file =
nullptr;
1115 if (
const char* out_path = getenv(
"CHAIN_MERGE_TEST_OUT")) {
1117 if (!out_file)
throw std::system_error(errno, std::generic_category(),
"fopen failed");
1120 ForEachMergeSetup([&](
const ActionList& arg_actions,
const ActionList& conf_actions) {
1126 auto arg = [](Action action) {
return action == ENABLE_TEST ?
"-testnet=1" :
1127 action == DISABLE_TEST ?
"-testnet=0" :
1128 action == NEGATE_TEST ?
"-notestnet=1" :
1129 action == ENABLE_REG ?
"-regtest=1" :
1130 action == DISABLE_REG ?
"-regtest=0" :
1131 action == NEGATE_REG ?
"-noregtest=1" :
nullptr; };
1134 std::vector<const char*> argv = {
"ignored"};
1135 for (Action action : arg_actions) {
1136 const char* argstr = arg(action);
1138 argv.push_back(argstr);
1140 desc += argv.back();
1147 for (Action action : conf_actions) {
1148 const char* argstr = arg(action);
1155 std::istringstream conf_stream(conf);
1162 }
catch (
const std::runtime_error& e) {
1170 BOOST_REQUIRE(fwrite(desc.data(), 1, desc.size(), out_file) == desc.size());
1175 if (fclose(out_file))
throw std::system_error(errno, std::generic_category(),
"fclose failed");
1181 std::string out_sha_hex =
HexStr(out_sha_bytes);
1192 BOOST_CHECK_EQUAL(out_sha_hex,
"f263493e300023b6509963887444c41386f44b63bc30047eb8402e8c1144854c");
1261 BOOST_CHECK_EQUAL(ParseMoney("12345.").value(), COIN * 12345);
1263 BOOST_CHECK_EQUAL(ParseMoney("12345.6789").value(), (COIN/10000)*123456789);
1265 BOOST_CHECK_EQUAL(ParseMoney("10000000.00").value(), COIN*10000000);
1266 BOOST_CHECK_EQUAL(ParseMoney("1000000.00").value(), COIN*1000000);
1267 BOOST_CHECK_EQUAL(ParseMoney("100000.00").value(), COIN*100000);
1268 BOOST_CHECK_EQUAL(ParseMoney("10000.00").value(), COIN*10000);
1269 BOOST_CHECK_EQUAL(ParseMoney("1000.00").value(), COIN*1000);
1270 BOOST_CHECK_EQUAL(ParseMoney("100.00").value(), COIN*100);
1271 BOOST_CHECK_EQUAL(ParseMoney("10.00").value(), COIN*10);
1272 BOOST_CHECK_EQUAL(ParseMoney("1.00").value(), COIN);
1273 BOOST_CHECK_EQUAL(ParseMoney("1").value(), COIN);
1274 BOOST_CHECK_EQUAL(ParseMoney(" 1").value(), COIN);
1275 BOOST_CHECK_EQUAL(ParseMoney("1 ").value(), COIN);
1276 BOOST_CHECK_EQUAL(ParseMoney(" 1 ").value(), COIN);
1277 BOOST_CHECK_EQUAL(ParseMoney("0.1").value(), COIN/10);
1278 BOOST_CHECK_EQUAL(ParseMoney("0.01").value(), COIN/100);
1279 BOOST_CHECK_EQUAL(ParseMoney("0.001").value(), COIN/1000);
1280 BOOST_CHECK_EQUAL(ParseMoney("0.0001").value(), COIN/10000);
1281 BOOST_CHECK_EQUAL(ParseMoney("0.00001").value(), COIN/100000);
1282 BOOST_CHECK_EQUAL(ParseMoney("0.000001").value(), COIN/1000000);
1283 BOOST_CHECK_EQUAL(ParseMoney("0.0000001").value(), COIN/10000000);
1284 BOOST_CHECK_EQUAL(ParseMoney("0.00000001").value(), COIN/100000000);
1285 BOOST_CHECK_EQUAL(ParseMoney(" 0.00000001 ").value(), COIN/100000000);
1286 BOOST_CHECK_EQUAL(ParseMoney("0.00000001 ").value(), COIN/100000000);
1287 BOOST_CHECK_EQUAL(ParseMoney(" 0.00000001").value(), COIN/100000000);
1289 // Parsing amount that can not be represented should fail
1290 BOOST_CHECK(!ParseMoney("100000000.00"));
1291 BOOST_CHECK(!ParseMoney("0.000000001"));
1293 // Parsing empty string should fail
1294 BOOST_CHECK(!ParseMoney(""));
1295 BOOST_CHECK(!ParseMoney(" "));
1296 BOOST_CHECK(!ParseMoney(" "));
1298 // Parsing two numbers should fail
1299 BOOST_CHECK(!ParseMoney(".."));
1300 BOOST_CHECK(!ParseMoney("0..0"));
1301 BOOST_CHECK(!ParseMoney("1 2"));
1302 BOOST_CHECK(!ParseMoney(" 1 2 "));
1303 BOOST_CHECK(!ParseMoney(" 1.2 3 "));
1304 BOOST_CHECK(!ParseMoney(" 1 2.3 "));
1306 // Embedded whitespace should fail
1307 BOOST_CHECK(!ParseMoney(" -1 .2 "));
1308 BOOST_CHECK(!ParseMoney(" 1 .2 "));
1309 BOOST_CHECK(!ParseMoney(" +1 .2 "));
1311 // Attempted 63 bit overflow should fail
1312 BOOST_CHECK(!ParseMoney("92233720368.54775808"));
1314 // Parsing negative amounts must fail
1315 BOOST_CHECK(!ParseMoney("-1"));
1317 // Parsing strings with embedded NUL characters should fail
1318 BOOST_CHECK(!ParseMoney("\0-1"s));
1319 BOOST_CHECK(!ParseMoney(STRING_WITH_EMBEDDED_NULL_CHAR));
1320 BOOST_CHECK(!ParseMoney("1\0"s));
1323 BOOST_AUTO_TEST_CASE(util_IsHex)
1325 BOOST_CHECK(IsHex("00"));
1326 BOOST_CHECK(IsHex("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
1327 BOOST_CHECK(IsHex("ff"));
1328 BOOST_CHECK(IsHex("FF"));
1330 BOOST_CHECK(!IsHex(""));
1331 BOOST_CHECK(!IsHex("0"));
1332 BOOST_CHECK(!IsHex("a"));
1333 BOOST_CHECK(!IsHex("eleven"));
1334 BOOST_CHECK(!IsHex("00xx00"));
1335 BOOST_CHECK(!IsHex("0x0000"));
1338 BOOST_AUTO_TEST_CASE(util_IsHexNumber)
1340 BOOST_CHECK(IsHexNumber("0x0"));
1341 BOOST_CHECK(IsHexNumber("0"));
1342 BOOST_CHECK(IsHexNumber("0x10"));
1343 BOOST_CHECK(IsHexNumber("10"));
1344 BOOST_CHECK(IsHexNumber("0xff"));
1345 BOOST_CHECK(IsHexNumber("ff"));
1346 BOOST_CHECK(IsHexNumber("0xFfa"));
1347 BOOST_CHECK(IsHexNumber("Ffa"));
1348 BOOST_CHECK(IsHexNumber("0x00112233445566778899aabbccddeeffAABBCCDDEEFF"));
1349 BOOST_CHECK(IsHexNumber("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
1351 BOOST_CHECK(!IsHexNumber("")); // empty string not allowed
1352 BOOST_CHECK(!IsHexNumber("0x")); // empty string after prefix not allowed
1353 BOOST_CHECK(!IsHexNumber("0x0 ")); // no spaces at end,
1354 BOOST_CHECK(!IsHexNumber(" 0x0")); // or beginning,
1355 BOOST_CHECK(!IsHexNumber("0x 0")); // or middle,
1356 BOOST_CHECK(!IsHexNumber(" ")); // etc.
1357 BOOST_CHECK(!IsHexNumber("0x0ga")); // invalid character
1358 BOOST_CHECK(!IsHexNumber("x0")); // broken prefix
1359 BOOST_CHECK(!IsHexNumber("0x0x00")); // two prefixes not allowed
1363 BOOST_AUTO_TEST_CASE(util_seed_insecure_rand)
1365 SeedInsecureRand(SeedRand::ZEROS);
1366 for (int mod=2;mod<11;mod++)
1369 // Really rough binomial confidence approximation.
1370 int err = 30*10000./mod*sqrt((1./mod*(1-1./mod))/10000.);
1371 //mask is 2^ceil(log2(mod))-1
1372 while(mask<mod-1)mask=(mask<<1)+1;
1375 //How often does it get a zero from the uniform range [0,mod)?
1376 for (int i = 0; i < 10000; i++) {
1379 rval=InsecureRand32()&mask;
1380 }while(rval>=(uint32_t)mod);
1383 BOOST_CHECK(count<=10000/mod+err);
1384 BOOST_CHECK(count>=10000/mod-err);
1388 BOOST_AUTO_TEST_CASE(util_TimingResistantEqual)
1390 BOOST_CHECK(TimingResistantEqual(std::string(""), std::string("")));
1391 BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("")));
1392 BOOST_CHECK(!TimingResistantEqual(std::string(""), std::string("abc")));
1393 BOOST_CHECK(!TimingResistantEqual(std::string("a"), std::string("aa")));
1394 BOOST_CHECK(!TimingResistantEqual(std::string("aa"), std::string("a")));
1395 BOOST_CHECK(TimingResistantEqual(std::string("abc"), std::string("abc")));
1396 BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("aba")));
1399 /* Test strprintf formatting directives.
1400 * Put a string before and after to ensure sanity of element sizes on stack. */
1401 #define B "check_prefix"
1402 #define E "check_postfix"
1403 BOOST_AUTO_TEST_CASE(strprintf_numbers)
1405 int64_t s64t = -9223372036854775807LL; /* signed 64 bit test value */
1406 uint64_t u64t = 18446744073709551615ULL; /* unsigned 64 bit test value */
1407 BOOST_CHECK(strprintf("%s %d %s", B, s64t, E) == B" -9223372036854775807 " E);
1408 BOOST_CHECK(strprintf("%s %u %s", B, u64t, E) == B" 18446744073709551615 " E);
1409 BOOST_CHECK(strprintf("%s %x %s", B, u64t, E) == B" ffffffffffffffff " E);
1411 size_t st = 12345678; /* unsigned size_t test value */
1412 ssize_t sst = -12345678; /* signed size_t test value */
1413 BOOST_CHECK(strprintf("%s %d %s", B, sst, E) == B" -12345678 " E);
1414 BOOST_CHECK(strprintf("%s %u %s", B, st, E) == B" 12345678 " E);
1415 BOOST_CHECK(strprintf("%s %x %s", B, st, E) == B" bc614e " E);
1417 ptrdiff_t pt = 87654321; /* positive ptrdiff_t test value */
1418 ptrdiff_t spt = -87654321; /* negative ptrdiff_t test value */
1419 BOOST_CHECK(strprintf("%s %d %s", B, spt, E) == B" -87654321 " E);
1420 BOOST_CHECK(strprintf("%s %u %s", B, pt, E) == B" 87654321 " E);
1421 BOOST_CHECK(strprintf("%s %x %s", B, pt, E) == B" 5397fb1 " E);
1426 /* Check for mingw/wine issue #3494
1427 * Remove this test before time.ctime(0xffffffff) == 'Sun Feb 7 07:28:15 2106
'
1429 BOOST_AUTO_TEST_CASE(gettime)
1431 BOOST_CHECK((GetTime() & ~0xFFFFFFFFLL) == 0);
1434 BOOST_AUTO_TEST_CASE(util_time_GetTime)
1437 // Check that mock time does not change after a sleep
1438 for (const auto& num_sleep : {0, 1}) {
1439 UninterruptibleSleep(std::chrono::milliseconds{num_sleep});
1440 BOOST_CHECK_EQUAL(111, GetTime()); // Deprecated time getter
1441 BOOST_CHECK_EQUAL(111, GetTime<std::chrono::seconds>().count());
1442 BOOST_CHECK_EQUAL(111000, GetTime<std::chrono::milliseconds>().count());
1443 BOOST_CHECK_EQUAL(111000000, GetTime<std::chrono::microseconds>().count());
1447 // Check that system time changes after a sleep
1448 const auto ms_0 = GetTime<std::chrono::milliseconds>();
1449 const auto us_0 = GetTime<std::chrono::microseconds>();
1450 UninterruptibleSleep(std::chrono::milliseconds{1});
1451 BOOST_CHECK(ms_0 < GetTime<std::chrono::milliseconds>());
1452 BOOST_CHECK(us_0 < GetTime<std::chrono::microseconds>());
1455 BOOST_AUTO_TEST_CASE(test_IsDigit)
1457 BOOST_CHECK_EQUAL(IsDigit('0
'), true);
1458 BOOST_CHECK_EQUAL(IsDigit('1
'), true);
1459 BOOST_CHECK_EQUAL(IsDigit('8
'), true);
1460 BOOST_CHECK_EQUAL(IsDigit('9
'), true);
1462 BOOST_CHECK_EQUAL(IsDigit('0
' - 1), false);
1463 BOOST_CHECK_EQUAL(IsDigit('9
' + 1), false);
1464 BOOST_CHECK_EQUAL(IsDigit(0), false);
1465 BOOST_CHECK_EQUAL(IsDigit(1), false);
1466 BOOST_CHECK_EQUAL(IsDigit(8), false);
1467 BOOST_CHECK_EQUAL(IsDigit(9), false);
1470 /* Check for overflow */
1471 template <typename T>
1472 static void TestAddMatrixOverflow()
1474 constexpr T MAXI{std::numeric_limits<T>::max()};
1475 BOOST_CHECK(!CheckedAdd(T{1}, MAXI));
1476 BOOST_CHECK(!CheckedAdd(MAXI, MAXI));
1477 BOOST_CHECK_EQUAL(0, CheckedAdd(T{0}, T{0}).value());
1478 BOOST_CHECK_EQUAL(MAXI, CheckedAdd(T{0}, MAXI).value());
1479 BOOST_CHECK_EQUAL(MAXI, CheckedAdd(T{1}, MAXI - 1).value());
1482 /* Check for overflow or underflow */
1483 template <typename T>
1484 static void TestAddMatrix()
1486 TestAddMatrixOverflow<T>();
1487 constexpr T MINI{std::numeric_limits<T>::min()};
1488 constexpr T MAXI{std::numeric_limits<T>::max()};
1489 BOOST_CHECK(!CheckedAdd(T{-1}, MINI));
1490 BOOST_CHECK(!CheckedAdd(MINI, MINI));
1491 BOOST_CHECK_EQUAL(MINI, CheckedAdd(T{0}, MINI).value());
1492 BOOST_CHECK_EQUAL(MINI, CheckedAdd(T{-1}, MINI + 1).value());
1493 BOOST_CHECK_EQUAL(-1, CheckedAdd(MINI, MAXI).value());
1496 BOOST_AUTO_TEST_CASE(util_overflow)
1498 TestAddMatrixOverflow<unsigned>();
1499 TestAddMatrix<signed>();
1502 BOOST_AUTO_TEST_CASE(test_ParseInt32)
1506 BOOST_CHECK(ParseInt32("1234", nullptr));
1507 BOOST_CHECK(ParseInt32("0", &n) && n == 0);
1508 BOOST_CHECK(ParseInt32("1234", &n) && n == 1234);
1509 BOOST_CHECK(ParseInt32("01234", &n) && n == 1234); // no octal
1510 BOOST_CHECK(ParseInt32("2147483647", &n) && n == 2147483647);
1511 BOOST_CHECK(ParseInt32("-2147483648", &n) && n == (-2147483647 - 1)); // (-2147483647 - 1) equals INT_MIN
1512 BOOST_CHECK(ParseInt32("-1234", &n) && n == -1234);
1513 BOOST_CHECK(ParseInt32("00000000000000001234", &n) && n == 1234);
1514 BOOST_CHECK(ParseInt32("-00000000000000001234", &n) && n == -1234);
1515 BOOST_CHECK(ParseInt32("00000000000000000000", &n) && n == 0);
1516 BOOST_CHECK(ParseInt32("-00000000000000000000", &n) && n == 0);
1518 BOOST_CHECK(!ParseInt32("", &n));
1519 BOOST_CHECK(!ParseInt32(" 1", &n)); // no padding inside
1520 BOOST_CHECK(!ParseInt32("1 ", &n));
1521 BOOST_CHECK(!ParseInt32("++1", &n));
1522 BOOST_CHECK(!ParseInt32("+-1", &n));
1523 BOOST_CHECK(!ParseInt32("-+1", &n));
1524 BOOST_CHECK(!ParseInt32("--1", &n));
1525 BOOST_CHECK(!ParseInt32("1a", &n));
1526 BOOST_CHECK(!ParseInt32("aap", &n));
1527 BOOST_CHECK(!ParseInt32("0x1", &n)); // no hex
1528 BOOST_CHECK(!ParseInt32(STRING_WITH_EMBEDDED_NULL_CHAR, &n));
1529 // Overflow and underflow
1530 BOOST_CHECK(!ParseInt32("-2147483649", nullptr));
1531 BOOST_CHECK(!ParseInt32("2147483648", nullptr));
1532 BOOST_CHECK(!ParseInt32("-32482348723847471234", nullptr));
1533 BOOST_CHECK(!ParseInt32("32482348723847471234", nullptr));
1536 template <typename T>
1537 static void RunToIntegralTests()
1539 BOOST_CHECK(!ToIntegral<T>(STRING_WITH_EMBEDDED_NULL_CHAR));
1540 BOOST_CHECK(!ToIntegral<T>(" 1"));
1541 BOOST_CHECK(!ToIntegral<T>("1 "));
1542 BOOST_CHECK(!ToIntegral<T>("1a"));
1543 BOOST_CHECK(!ToIntegral<T>("1.1"));
1544 BOOST_CHECK(!ToIntegral<T>("1.9"));
1545 BOOST_CHECK(!ToIntegral<T>("+01.9"));
1546 BOOST_CHECK(!ToIntegral<T>("-"));
1547 BOOST_CHECK(!ToIntegral<T>("+"));
1548 BOOST_CHECK(!ToIntegral<T>(" -1"));
1549 BOOST_CHECK(!ToIntegral<T>("-1 "));
1550 BOOST_CHECK(!ToIntegral<T>(" -1 "));
1551 BOOST_CHECK(!ToIntegral<T>("+1"));
1552 BOOST_CHECK(!ToIntegral<T>(" +1"));
1553 BOOST_CHECK(!ToIntegral<T>(" +1 "));
1554 BOOST_CHECK(!ToIntegral<T>("+-1"));
1555 BOOST_CHECK(!ToIntegral<T>("-+1"));
1556 BOOST_CHECK(!ToIntegral<T>("++1"));
1557 BOOST_CHECK(!ToIntegral<T>("--1"));
1558 BOOST_CHECK(!ToIntegral<T>(""));
1559 BOOST_CHECK(!ToIntegral<T>("aap"));
1560 BOOST_CHECK(!ToIntegral<T>("0x1"));
1561 BOOST_CHECK(!ToIntegral<T>("-32482348723847471234"));
1562 BOOST_CHECK(!ToIntegral<T>("32482348723847471234"));
1565 BOOST_AUTO_TEST_CASE(test_ToIntegral)
1567 BOOST_CHECK_EQUAL(ToIntegral<int32_t>("1234").value(), 1'234);
1570 BOOST_CHECK_EQUAL(ToIntegral<int32_t>("00000000000000001234").value(), 1'234);
1571 BOOST_CHECK_EQUAL(ToIntegral<int32_t>(
"-00000000000000001234").value(), -1
'234);
1572 BOOST_CHECK_EQUAL(ToIntegral<int32_t>("00000000000000000000").value(), 0);
1573 BOOST_CHECK_EQUAL(ToIntegral<int32_t>("-00000000000000000000").value(), 0);
1574 BOOST_CHECK_EQUAL(ToIntegral<int32_t>("-1234").value(), -1'234);
1577 RunToIntegralTests<uint64_t>();
1578 RunToIntegralTests<int64_t>();
1579 RunToIntegralTests<uint32_t>();
1580 RunToIntegralTests<int32_t>();
1581 RunToIntegralTests<uint16_t>();
1582 RunToIntegralTests<int16_t>();
1583 RunToIntegralTests<uint8_t>();
1584 RunToIntegralTests<int8_t>();
1586 BOOST_CHECK(!ToIntegral<int64_t>(
"-9223372036854775809"));
1587 BOOST_CHECK_EQUAL(ToIntegral<int64_t>(
"-9223372036854775808").value(), -9
'223'372
'036'854
'775'807LL - 1LL);
1588 BOOST_CHECK_EQUAL(ToIntegral<int64_t>(
"9223372036854775807").value(), 9
'223'372
'036'854
'775'807);
1589 BOOST_CHECK(!ToIntegral<int64_t>(
"9223372036854775808"));
1593 BOOST_CHECK_EQUAL(ToIntegral<uint64_t>(
"18446744073709551615").value(), 18
'446'744
'073'709
'551'615ULL);
1594 BOOST_CHECK(!ToIntegral<uint64_t>(
"18446744073709551616"));
1597 BOOST_CHECK_EQUAL(ToIntegral<int32_t>(
"-2147483648").value(), -2
'147'483
'648LL);
1598 BOOST_CHECK_EQUAL(ToIntegral<int32_t>("2147483647").value(), 2'147
'483'647);
1604 BOOST_CHECK(!ToIntegral<uint32_t>("4294967296"));
1606 BOOST_CHECK(!ToIntegral<int16_t>("-32769"));
1607 BOOST_CHECK_EQUAL(ToIntegral<int16_t>("-32768").value(), -32'768);
1609 BOOST_CHECK(!ToIntegral<int16_t>("32768"));
1611 BOOST_CHECK(!ToIntegral<uint16_t>("-1"));
1612 BOOST_CHECK_EQUAL(ToIntegral<uint16_t>("0").value(), 0U);
1613 BOOST_CHECK_EQUAL(ToIntegral<uint16_t>("65535").value(), 65'535U);
1629 return strtoll(str.c_str(),
nullptr, 10);
1635 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("0"), 0);
1636 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("01234"), 1'234);
1638 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>(" 1"), 1);
1639 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("1 "), 1);
1640 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("1a"), 1);
1641 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("1.1"), 1);
1642 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("1.9"), 1);
1643 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("+01.9"), 1);
1644 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("-1"), -1);
1645 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>(" -1"), -1);
1646 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("-1 "), -1);
1647 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>(" -1 "), -1);
1648 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("+1"), 1);
1649 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>(" +1"), 1);
1650 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>(" +1 "), 1);
1652 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("+-1"), 0);
1653 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("-+1"), 0);
1654 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("++1"), 0);
1655 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("--1"), 0);
1656 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>(""), 0);
1657 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("aap"), 0);
1658 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("0x1"), 0);
1659 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("-32482348723847471234"), -2'147
'483'647 - 1);
1660 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>(
"32482348723847471234"), 2
'147'483
'647);
1662 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int64_t>("-9223372036854775809"), -9'223
'372'036
'854'775
'807LL - 1LL);
1663 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int64_t>("-9223372036854775808"), -9'223
'372'036
'854'775
'807LL - 1LL);
1664 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int64_t>("9223372036854775807"), 9'223
'372'036
'854'775
'807);
1665 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int64_t>("9223372036854775808"), 9'223
'372'036
'854'775
'807);
1667 std::map<std::string, int64_t> atoi64_test_pairs = {
1668 {"-9223372036854775809", std::numeric_limits<int64_t>::min()},
1669 {"-9223372036854775808", -9'223
'372'036
'854'775
'807LL - 1LL},
1670 {"9223372036854775807", 9'223
'372'036
'854'775
'807},
1671 {"9223372036854775808", std::numeric_limits<int64_t>::max()},
1678 for (const auto& pair : atoi64_test_pairs) {
1679 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int64_t>(pair.first), pair.second);
1682 // Ensure legacy compatibility with previous versions of Bitcoin Core's atoi64
1683 for (
const auto& pair : atoi64_test_pairs) {
1689 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint64_t>(
"18446744073709551615"), 18
'446'744
'073'709
'551'615ULL);
1690 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint64_t>(
"18446744073709551616"), 18
'446'744
'073'709
'551'615ULL);
1692 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>(
"-2147483649"), -2
'147'483
'648LL);
1693 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("-2147483648"), -2'147
'483'648LL);
1695 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int32_t>("2147483648"), 2'147
'483'647);
1699 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint32_t>(
"4294967295"), 4
'294'967
'295U);
1700 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint32_t>("4294967296"), 4'294
'967'295U);
1703 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int16_t>("-32768"), -32'768);
1705 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<int16_t>("32768"), 32'767);
1710 BOOST_CHECK_EQUAL(LocaleIndependentAtoi<uint16_t>("65536"), 65'535U);
1901 BOOST_CHECK_EQUAL(
FormatParagraph(
"This_is_a_very_long_test_string_without_any_spaces_so_it_should_just_get_returned_as_is_despite_the_length until it gets here", 79),
"This_is_a_very_long_test_string_without_any_spaces_so_it_should_just_get_returned_as_is_despite_the_length\nuntil it gets here");
1904 BOOST_CHECK_EQUAL(
FormatParagraph(
"a b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p", 79),
"a b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de\nf g h i j k l m n o p");
1905 BOOST_CHECK_EQUAL(
FormatParagraph(
"x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p", 79),
"x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de\nf g h i j k l m n o p");
1907 BOOST_CHECK_EQUAL(
FormatParagraph(
"x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9 a b c d e fg h i j k", 79, 4),
"x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de\n f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9 a b c d e fg\n h i j k");
1909 BOOST_CHECK_EQUAL(
FormatParagraph(
"This is a very long test string. This is a second sentence in the very long test string.", 79),
"This is a very long test string. This is a second sentence in the very long\ntest string.");
1910 BOOST_CHECK_EQUAL(
FormatParagraph(
"This is a very long test string.\nThis is a second sentence in the very long test string. This is a third sentence in the very long test string.", 79),
"This is a very long test string.\nThis is a second sentence in the very long test string. This is a third\nsentence in the very long test string.");
1911 BOOST_CHECK_EQUAL(
FormatParagraph(
"This is a very long test string.\n\nThis is a second sentence in the very long test string. This is a third sentence in the very long test string.", 79),
"This is a very long test string.\n\nThis is a second sentence in the very long test string. This is a third\nsentence in the very long test string.");
1912 BOOST_CHECK_EQUAL(
FormatParagraph(
"Testing that normal newlines do not get indented.\nLike here.", 79),
"Testing that normal newlines do not get indented.\nLike here.");
1917 std::vector<std::string> comments;
1918 comments.push_back(std::string(
"comment1"));
1919 std::vector<std::string> comments2;
1920 comments2.push_back(std::string(
"comment1"));
2006 #ifndef WIN32 // Cannot do this test on WIN32 due to lack of fork()
2015 int rv = read(fd, &ch, 1);
2020 rv = write(fd, &ch, 1);
2026 rv = write(fd, &ch, 1);
2041 fs::path dirname = m_args.GetDataDirBase() /
"lock_dir";
2042 const std::string lockname =
".lock";
2047 void (*old_handler)(int) = signal(SIGCHLD, SIG_DFL);
2119 signal(SIGCHLD, old_handler);
2124 fs::remove_all(dirname);
2130 fs::path tmpdirname = m_args.GetDataDirBase();
2137 fs::create_directory(tmpdirname);
2140 fs::remove(tmpdirname);
2180 return std::string(span.
begin(), span.
end());
2191 input =
"MilkToastHoney";
2193 success =
Const(
"", sp);
2197 success =
Const(
"Milk", sp);
2201 success =
Const(
"Bread", sp);
2204 success =
Const(
"Toast", sp);
2208 success =
Const(
"Honeybadger", sp);
2211 success =
Const(
"Honey", sp);
2216 input =
"Foo(Bar(xy,z()))";
2219 success =
Func(
"FooBar", sp);
2222 success =
Func(
"Foo(", sp);
2225 success =
Func(
"Foo", sp);
2229 success =
Func(
"Bar", sp);
2233 success =
Func(
"xy", sp);
2239 input =
"(n*(n-1))/2";
2251 input =
"(aaaaa,bbbbb()),c";
2263 input =
"((a),(b),(c)),xxx";
2270 std::vector<Span<const char>> results;
2273 results =
Split(input,
'x');
2280 input =
"one#two#three";
2281 results =
Split(input,
'-');
2285 input =
"one#two#three";
2286 results =
Split(input,
'#');
2292 input =
"*foo*bar*";
2293 results =
Split(input,
'*');
2310 const std::string NUL(
"O\x00O", 3);
2319 const Tracker* origin;
2323 Tracker() noexcept : origin(this), copies(0) {}
2324 Tracker(
const Tracker& t) noexcept : origin(
t.origin), copies(
t.copies + 1) {}
2325 Tracker(Tracker&& t) noexcept : origin(
t.origin), copies(
t.copies) {}
2326 Tracker& operator=(
const Tracker& t) noexcept
2329 copies =
t.copies + 1;
2351 auto v2 =
Vector(std::move(t2));
2356 auto v3 =
Vector(t1, std::move(t2));
2363 auto v4 =
Vector(std::move(v3[0]), v3[1], std::move(t3));
2372 auto v5 =
Cat(v1, v4);
2383 auto v6 =
Cat(std::move(v1), v3);
2392 auto v7 =
Cat(v2, std::move(v4));
2403 auto v8 =
Cat(std::move(v2), std::move(v3));
2415 const std::array<unsigned char, 32> privkey_bytes = {
2418 0xD9, 0x7F, 0x51, 0x08, 0xF1, 0x1C, 0xDA, 0x6E,
2419 0xEE, 0xBA, 0xAA, 0x42, 0x0F, 0xEF, 0x07, 0x26,
2420 0xB1, 0xF8, 0x98, 0x06, 0x0B, 0x98, 0x48, 0x9F,
2421 0xA3, 0x09, 0x84, 0x63, 0xC0, 0x03, 0x28, 0x66
2424 const std::string message =
"Trust no one";
2426 const std::string expected_signature =
2427 "IPojfrX2dfPnH26UegfbGQQLrdK844DlHq5157/P6h57WyuS/Qsl+h/WSVGDF4MUi4rWSswW38oimDYfNNUBUOk=";
2430 std::string generated_signature;
2432 BOOST_REQUIRE_MESSAGE(!privkey.
IsValid(),
2433 "Confirm the private key is invalid");
2435 BOOST_CHECK_MESSAGE(!
MessageSign(privkey, message, generated_signature),
2436 "Sign with an invalid private key");
2438 privkey.
Set(privkey_bytes.begin(), privkey_bytes.end(),
true);
2440 BOOST_REQUIRE_MESSAGE(privkey.
IsValid(),
2441 "Confirm the private key is valid");
2443 BOOST_CHECK_MESSAGE(
MessageSign(privkey, message, generated_signature),
2444 "Sign with a valid private key");
2454 "signature should be irrelevant",
2460 "3B5fQsEXEaV8v6U3ejYc8XaKXAkyQj2MjV",
2461 "signature should be irrelevant",
2467 "1KqbBpLy5FARmTPD4VZnDDpYjkUvkr82Pm",
2468 "invalid signature, not in base64 encoding",
2469 "message should be irrelevant"),
2474 "1KqbBpLy5FARmTPD4VZnDDpYjkUvkr82Pm",
2475 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
2476 "message should be irrelevant"),
2481 "15CRxFdyRpGZLW9w8HnHvVduizdL5jKNbs",
2482 "IPojfrX2dfPnH26UegfbGQQLrdK844DlHq5157/P6h57WyuS/Qsl+h/WSVGDF4MUi4rWSswW38oimDYfNNUBUOk=",
2483 "I never signed this"),
2488 "15CRxFdyRpGZLW9w8HnHvVduizdL5jKNbs",
2489 "IPojfrX2dfPnH26UegfbGQQLrdK844DlHq5157/P6h57WyuS/Qsl+h/WSVGDF4MUi4rWSswW38oimDYfNNUBUOk=",
2495 "11canuhp9X2NocwCq7xNrQYTmUgZAnLK3",
2496 "IIcaIENoYW5jZWxsb3Igb24gYnJpbmsgb2Ygc2Vjb25kIGJhaWxvdXQgZm9yIGJhbmtzIAaHRtbCeDZINyavx14=",
2503 const std::string unsigned_tx =
"...";
2504 const std::string prefixed_message =
2507 std::string(1, (
char)unsigned_tx.length()) +
2511 const uint256 message_hash1 =
Hash(prefixed_message);
2515 BOOST_CHECK_NE(message_hash1, signature_hash);
2546 BOOST_CHECK_EQUAL(ParseByteUnits("3G", noop).value(), 3ULL << 30);
2548 BOOST_CHECK_EQUAL(ParseByteUnits("4t", noop).value(), 4'000
'000'000
'000ULL);
2549 BOOST_CHECK_EQUAL(ParseByteUnits("4T", noop).value(), 4ULL << 40);
2551 // check default multiplier
2552 BOOST_CHECK_EQUAL(ParseByteUnits("5", ByteUnit::K).value(), 5ULL << 10);
2555 BOOST_CHECK(!ParseByteUnits("", noop));
2556 BOOST_CHECK(!ParseByteUnits("foo", noop));
2559 BOOST_CHECK(!ParseByteUnits("123m ", noop));
2560 BOOST_CHECK(!ParseByteUnits(" 123m", noop));
2563 BOOST_CHECK(!ParseByteUnits("-123m", noop));
2564 BOOST_CHECK(!ParseByteUnits("+123m", noop));
2567 BOOST_CHECK_EQUAL(ParseByteUnits("020M", noop).value(), 20ULL << 20);
2569 // fractions not allowed
2570 BOOST_CHECK(!ParseByteUnits("0.5T", noop));
2573 BOOST_CHECK(!ParseByteUnits("18446744073709551615g", noop));
2576 BOOST_CHECK(!ParseByteUnits("1x", noop));
2579 BOOST_AUTO_TEST_SUITE_END()