{

ClearDatadirCache();

const fs::path dd_norm = GetDataDir();

gArgs.ForceSetArg("-datadir", dd_norm.string() + "/");

ClearDatadirCache();

BOOST_CHECK_EQUAL(dd_norm, GetDataDir());

gArgs.ForceSetArg("-datadir", dd_norm.string() + "/.");

ClearDatadirCache();

BOOST_CHECK_EQUAL(dd_norm, GetDataDir());

gArgs.ForceSetArg("-datadir", dd_norm.string() + "/./");

ClearDatadirCache();

BOOST_CHECK_EQUAL(dd_norm, GetDataDir());

gArgs.ForceSetArg("-datadir", dd_norm.string() + "/.//");

ClearDatadirCache();

BOOST_CHECK_EQUAL(dd_norm, GetDataDir());

{

RecursiveMutex cs;

do {

LOCK(cs);

break;

BOOST_ERROR("break was swallowed!");

} while(0);

do {

TRY_LOCK(cs, lockTest);

if (lockTest) {

BOOST_CHECK(true); // Needed to suppress "Test case [...] did not check any assertions"

break;

}

BOOST_ERROR("break was swallowed!");

} while(0);

{

std::vector<unsigned char> result;

std::vector<unsigned char> expected(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected));

// Basic test vector

result = ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");

BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());

// Spaces between bytes must be supported

result = ParseHex("12 34 56 78");

BOOST_CHECK(result.size() == 4 && result[0] == 0x12 && result[1] == 0x34 && result[2] == 0x56 && result[3] == 0x78);

// Leading space must be supported (used in BerkeleyEnvironment::Salvage)

result = ParseHex(" 89 34 56 78");

BOOST_CHECK(result.size() == 4 && result[0] == 0x89 && result[1] == 0x34 && result[2] == 0x56 && result[3] == 0x78);

// Stop parsing at invalid value

result = ParseHex("1234 invalid 1234");

BOOST_CHECK(result.size() == 2 && result[0] == 0x12 && result[1] == 0x34);

{

BOOST_CHECK_EQUAL(

HexStr(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected)),

"04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");

BOOST_CHECK_EQUAL(

HexStr(ParseHex_expected + sizeof(ParseHex_expected),

ParseHex_expected + sizeof(ParseHex_expected)),

"");

BOOST_CHECK_EQUAL(

HexStr(ParseHex_expected, ParseHex_expected),

"");

std::vector<unsigned char> ParseHex_vec(ParseHex_expected, ParseHex_expected + 5);

BOOST_CHECK_EQUAL(

HexStr(ParseHex_vec.rbegin(), ParseHex_vec.rend()),

"b0fd8a6704"

);

BOOST_CHECK_EQUAL(

HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected),

std::reverse_iterator<const uint8_t *>(ParseHex_expected)),

""

);

BOOST_CHECK_EQUAL(

HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected + 1),

std::reverse_iterator<const uint8_t *>(ParseHex_expected)),

"04"

);

BOOST_CHECK_EQUAL(

HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected + 5),

std::reverse_iterator<const uint8_t *>(ParseHex_expected)),

"b0fd8a6704"

);

BOOST_CHECK_EQUAL(

HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected + 65),

std::reverse_iterator<const uint8_t *>(ParseHex_expected)),

"5f1df16b2b704c8a578d0bbaf74d385cde12c11ee50455f3c438ef4c3fbcf649b6de611feae06279a60939e028a8d65c10b73071a6f16719274855feb0fd8a6704"

);

{

// Normal version

BOOST_CHECK_EQUAL(Join({}, ", "), "");

BOOST_CHECK_EQUAL(Join({"foo"}, ", "), "foo");

BOOST_CHECK_EQUAL(Join({"foo", "bar"}, ", "), "foo, bar");

// Version with unary operator

const auto op_upper = [](const std::string& s) { return ToUpper(s); };

BOOST_CHECK_EQUAL(Join<std::string>({}, ", ", op_upper), "");

BOOST_CHECK_EQUAL(Join<std::string>({"foo"}, ", ", op_upper), "FOO");

BOOST_CHECK_EQUAL(Join<std::string>({"foo", "bar"}, ", ", op_upper), "FOO, BAR");

{

BOOST_CHECK_EQUAL(FormatISO8601DateTime(1317425777), "2011-09-30T23:36:17Z");

BOOST_CHECK_EQUAL(FormatISO8601DateTime(0), "1970-01-01T00:00:00Z");

BOOST_CHECK_EQUAL(ParseISO8601DateTime("1970-01-01T00:00:00Z"), 0);

BOOST_CHECK_EQUAL(ParseISO8601DateTime("1960-01-01T00:00:00Z"), 0);

BOOST_CHECK_EQUAL(ParseISO8601DateTime("2011-09-30T23:36:17Z"), 1317425777);

auto time = GetSystemTimeInSeconds();

BOOST_CHECK_EQUAL(ParseISO8601DateTime(FormatISO8601DateTime(time)), time);

{

TestArgsManager() { m_network_only_args.clear(); }

void ReadConfigString(const std::string str_config)

{

std::istringstream streamConfig(str_config);

{

LOCK(cs_args);

m_settings.ro_config.clear();

m_config_sections.clear();

}

std::string error;

BOOST_REQUIRE(ReadConfigStream(streamConfig, "", error));

}

void SetNetworkOnlyArg(const std::string arg)

{

LOCK(cs_args);

m_network_only_args.insert(arg);

}

void SetupArgs(const std::vector<std::pair<std::string, unsigned int>>& args)

{

for (const auto& arg : args) {

AddArg(arg.first, "", arg.second, OptionsCategory::OPTIONS);

}

}

using ArgsManager::GetSetting;

using ArgsManager::GetSettingsList;

using ArgsManager::ReadConfigStream;

using ArgsManager::cs_args;

using ArgsManager::m_network;

using ArgsManager::m_settings;

{

struct Expect {

util::SettingsValue setting;

bool default_string = false;

bool default_int = false;

bool default_bool = false;

const char* string_value = nullptr;

Optional<int64_t> int_value;

Optional<bool> bool_value;

Optional<std::vector<std::string>> list_value;

const char* error = nullptr;

Expect(util::SettingsValue s) : setting(std::move(s)) {}

Expect& DefaultString() { default_string = true; return *this; }

Expect& DefaultInt() { default_int = true; return *this; }

Expect& DefaultBool() { default_bool = true; return *this; }

Expect& String(const char* s) { string_value = s; return *this; }

Expect& Int(int64_t i) { int_value = i; return *this; }

Expect& Bool(bool b) { bool_value = b; return *this; }

Expect& List(std::vector<std::string> m) { list_value = std::move(m); return *this; }

Expect& Error(const char* e) { error = e; return *this; }

};

void CheckValue(unsigned int flags, const char* arg, const Expect& expect)

{

TestArgsManager test;

test.SetupArgs({{"-value", flags}});

const char* argv[] = {"ignored", arg};

std::string error;

bool success = test.ParseParameters(arg ? 2 : 1, (char**)argv, error);

BOOST_CHECK_EQUAL(test.GetSetting("-value").write(), expect.setting.write());

auto settings_list = test.GetSettingsList("-value");

if (expect.setting.isNull() || expect.setting.isFalse()) {

BOOST_CHECK_EQUAL(settings_list.size(), 0);

} else {

BOOST_CHECK_EQUAL(settings_list.size(), 1);

BOOST_CHECK_EQUAL(settings_list[0].write(), expect.setting.write());

}

if (expect.error) {

BOOST_CHECK(!success);

BOOST_CHECK_NE(error.find(expect.error), std::string::npos);

} else {

BOOST_CHECK(success);

BOOST_CHECK_EQUAL(error, "");

}

if (expect.default_string) {

BOOST_CHECK_EQUAL(test.GetArg("-value", "zzzzz"), "zzzzz");

} else if (expect.string_value) {

BOOST_CHECK_EQUAL(test.GetArg("-value", "zzzzz"), expect.string_value);

} else {

BOOST_CHECK(!success);

}

if (expect.default_int) {

BOOST_CHECK_EQUAL(test.GetArg("-value", 99999), 99999);

} else if (expect.int_value) {

BOOST_CHECK_EQUAL(test.GetArg("-value", 99999), *expect.int_value);

} else {

BOOST_CHECK(!success);

}

if (expect.default_bool) {

BOOST_CHECK_EQUAL(test.GetBoolArg("-value", false), false);

BOOST_CHECK_EQUAL(test.GetBoolArg("-value", true), true);

} else if (expect.bool_value) {

BOOST_CHECK_EQUAL(test.GetBoolArg("-value", false), *expect.bool_value);

BOOST_CHECK_EQUAL(test.GetBoolArg("-value", true), *expect.bool_value);

} else {

BOOST_CHECK(!success);

}

if (expect.list_value) {

auto l = test.GetArgs("-value");

BOOST_CHECK_EQUAL_COLLECTIONS(l.begin(), l.end(), expect.list_value->begin(), expect.list_value->end());

} else {

BOOST_CHECK(!success);

}

}

{

using M = ArgsManager;

CheckValue(M::ALLOW_ANY, nullptr, Expect{{}}.DefaultString().DefaultInt().DefaultBool().List({}));

CheckValue(M::ALLOW_ANY, "-novalue", Expect{false}.String("0").Int(0).Bool(false).List({}));

CheckValue(M::ALLOW_ANY, "-novalue=", Expect{false}.String("0").Int(0).Bool(false).List({}));

CheckValue(M::ALLOW_ANY, "-novalue=0", Expect{true}.String("1").Int(1).Bool(true).List({"1"}));

CheckValue(M::ALLOW_ANY, "-novalue=1", Expect{false}.String("0").Int(0).Bool(false).List({}));

CheckValue(M::ALLOW_ANY, "-novalue=2", Expect{false}.String("0").Int(0).Bool(false).List({}));

CheckValue(M::ALLOW_ANY, "-novalue=abc", Expect{true}.String("1").Int(1).Bool(true).List({"1"}));

CheckValue(M::ALLOW_ANY, "-value", Expect{""}.String("").Int(0).Bool(true).List({""}));

CheckValue(M::ALLOW_ANY, "-value=", Expect{""}.String("").Int(0).Bool(true).List({""}));

CheckValue(M::ALLOW_ANY, "-value=0", Expect{"0"}.String("0").Int(0).Bool(false).List({"0"}));

CheckValue(M::ALLOW_ANY, "-value=1", Expect{"1"}.String("1").Int(1).Bool(true).List({"1"}));

CheckValue(M::ALLOW_ANY, "-value=2", Expect{"2"}.String("2").Int(2).Bool(true).List({"2"}));

CheckValue(M::ALLOW_ANY, "-value=abc", Expect{"abc"}.String("abc").Int(0).Bool(false).List({"abc"}));

{

TestArgsManager testArgs;

const auto a = std::make_pair("-a", ArgsManager::ALLOW_ANY);

const auto b = std::make_pair("-b", ArgsManager::ALLOW_ANY);

const auto ccc = std::make_pair("-ccc", ArgsManager::ALLOW_ANY);

const auto d = std::make_pair("-d", ArgsManager::ALLOW_ANY);

const char *argv_test[] = {"-ignored", "-a", "-b", "-ccc=argument", "-ccc=multiple", "f", "-d=e"};

std::string error;

LOCK(testArgs.cs_args);

testArgs.SetupArgs({a, b, ccc, d});

BOOST_CHECK(testArgs.ParseParameters(0, (char**)argv_test, error));

BOOST_CHECK(testArgs.m_settings.command_line_options.empty() && testArgs.m_settings.ro_config.empty());

BOOST_CHECK(testArgs.ParseParameters(1, (char**)argv_test, error));

BOOST_CHECK(testArgs.m_settings.command_line_options.empty() && testArgs.m_settings.ro_config.empty());

BOOST_CHECK(testArgs.ParseParameters(7, (char**)argv_test, error));

// expectation: -ignored is ignored (program name argument),

// -a, -b and -ccc end up in map, -d ignored because it is after

// a non-option argument (non-GNU option parsing)

BOOST_CHECK(testArgs.m_settings.command_line_options.size() == 3 && testArgs.m_settings.ro_config.empty());

BOOST_CHECK(testArgs.IsArgSet("-a") && testArgs.IsArgSet("-b") && testArgs.IsArgSet("-ccc")

&& !testArgs.IsArgSet("f") && !testArgs.IsArgSet("-d"));

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")

&& !testArgs.m_settings.command_line_options.count("f") && !testArgs.m_settings.command_line_options.count("d"));

BOOST_CHECK(testArgs.m_settings.command_line_options["a"].size() == 1);

BOOST_CHECK(testArgs.m_settings.command_line_options["a"].front().get_str() == "");

BOOST_CHECK(testArgs.m_settings.command_line_options["ccc"].size() == 2);

BOOST_CHECK(testArgs.m_settings.command_line_options["ccc"].front().get_str() == "argument");

BOOST_CHECK(testArgs.m_settings.command_line_options["ccc"].back().get_str() == "multiple");

BOOST_CHECK(testArgs.GetArgs("-ccc").size() == 2);

{

TestArgsManager test;

test.SetupArgs({{"-registered", ArgsManager::ALLOW_ANY}});

const char* argv[] = {"ignored", "-registered"};

std::string error;

BOOST_CHECK(test.ParseParameters(2, (char**)argv, error));

BOOST_CHECK_EQUAL(error, "");

argv[1] = "-unregistered";

BOOST_CHECK(!test.ParseParameters(2, (char**)argv, error));

BOOST_CHECK_EQUAL(error, "Invalid parameter -unregistered");

// Make sure registered parameters prefixed with a chain name trigger errors.

// (Previously, they were accepted and ignored.)

argv[1] = "-test.registered";

BOOST_CHECK(!test.ParseParameters(2, (char**)argv, error));

BOOST_CHECK_EQUAL(error, "Invalid parameter -test.registered");

{

TestArgsManager test;

test.SetupArgs({{"-value", ArgsManager::ALLOW_ANY}});

std::string arg = "-value=" + str;

const char* argv[] = {"ignored", arg.c_str()};

std::string error;

BOOST_CHECK(test.ParseParameters(2, (char**)argv, error));

BOOST_CHECK_EQUAL(test.GetBoolArg("-value", false), expected_bool);

BOOST_CHECK_EQUAL(test.GetBoolArg("-value", true), expected_bool);

BOOST_CHECK_EQUAL(test.GetArg("-value", 99998), expected_int);

BOOST_CHECK_EQUAL(test.GetArg("-value", 99999), expected_int);

{

// Some of these cases could be ambiguous or surprising to users, and might

// be worth triggering errors or warnings in the future. But for now basic

// test coverage is useful to avoid breaking backwards compatibility

// unintentionally.

TestParse("", true, 0);

TestParse(" ", false, 0);

TestParse("0", false, 0);

TestParse("0 ", false, 0);

TestParse(" 0", false, 0);

TestParse("+0", false, 0);

TestParse("-0", false, 0);

TestParse("5", true, 5);

TestParse("5 ", true, 5);

TestParse(" 5", true, 5);

TestParse("+5", true, 5);

TestParse("-5", true, -5);

TestParse("0 5", false, 0);

TestParse("5 0", true, 5);

TestParse("050", true, 50);

TestParse("0.", false, 0);

TestParse("5.", true, 5);

TestParse("0.0", false, 0);

TestParse("0.5", false, 0);

TestParse("5.0", true, 5);

TestParse("5.5", true, 5);

TestParse("x", false, 0);

TestParse("x0", false, 0);

TestParse("x5", false, 0);

TestParse("0x", false, 0);

TestParse("5x", true, 5);

TestParse("0x5", false, 0);

TestParse("false", false, 0);

TestParse("true", false, 0);

TestParse("yes", false, 0);

TestParse("no", false, 0);

{

TestArgsManager testArgs;

const auto a = std::make_pair("-a", ArgsManager::ALLOW_ANY);

const auto b = std::make_pair("-b", ArgsManager::ALLOW_ANY);

const auto c = std::make_pair("-c", ArgsManager::ALLOW_ANY);

const auto d = std::make_pair("-d", ArgsManager::ALLOW_ANY);

const auto e = std::make_pair("-e", ArgsManager::ALLOW_ANY);

const auto f = std::make_pair("-f", ArgsManager::ALLOW_ANY);

const char *argv_test[] = {

"ignored", "-a", "-nob", "-c=0", "-d=1", "-e=false", "-f=true"};

std::string error;

LOCK(testArgs.cs_args);

testArgs.SetupArgs({a, b, c, d, e, f});

BOOST_CHECK(testArgs.ParseParameters(7, (char**)argv_test, error));

// Each letter should be set.

for (const char opt : "abcdef")

BOOST_CHECK(testArgs.IsArgSet({'-', opt}) || !opt);

// Nothing else should be in the map

BOOST_CHECK(testArgs.m_settings.command_line_options.size() == 6 &&

testArgs.m_settings.ro_config.empty());

// The -no prefix should get stripped on the way in.

BOOST_CHECK(!testArgs.IsArgSet("-nob"));

// The -b option is flagged as negated, and nothing else is

BOOST_CHECK(testArgs.IsArgNegated("-b"));

BOOST_CHECK(!testArgs.IsArgNegated("-a"));

// Check expected values.

BOOST_CHECK(testArgs.GetBoolArg("-a", false) == true);

BOOST_CHECK(testArgs.GetBoolArg("-b", true) == false);

BOOST_CHECK(testArgs.GetBoolArg("-c", true) == false);

BOOST_CHECK(testArgs.GetBoolArg("-d", false) == true);

BOOST_CHECK(testArgs.GetBoolArg("-e", true) == false);

BOOST_CHECK(testArgs.GetBoolArg("-f", true) == false);

{

// Test some awful edge cases that hopefully no user will ever exercise.

TestArgsManager testArgs;

// Params test

const auto foo = std::make_pair("-foo", ArgsManager::ALLOW_ANY);

const auto bar = std::make_pair("-bar", ArgsManager::ALLOW_ANY);

const char *argv_test[] = {"ignored", "-nofoo", "-foo", "-nobar=0"};

testArgs.SetupArgs({foo, bar});

std::string error;

BOOST_CHECK(testArgs.ParseParameters(4, (char**)argv_test, error));

// This was passed twice, second one overrides the negative setting.

BOOST_CHECK(!testArgs.IsArgNegated("-foo"));

BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "");

// A double negative is a positive, and not marked as negated.

BOOST_CHECK(!testArgs.IsArgNegated("-bar"));

BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "1");

// Config test

const char *conf_test = "nofoo=1\nfoo=1\nnobar=0\n";

BOOST_CHECK(testArgs.ParseParameters(1, (char**)argv_test, error));

testArgs.ReadConfigString(conf_test);

// This was passed twice, second one overrides the negative setting,

// and the value.

BOOST_CHECK(!testArgs.IsArgNegated("-foo"));

BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "1");

// A double negative is a positive, and does not count as negated.

BOOST_CHECK(!testArgs.IsArgNegated("-bar"));

BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "1");

// Combined test

const char *combo_test_args[] = {"ignored", "-nofoo", "-bar"};

const char *combo_test_conf = "foo=1\nnobar=1\n";

BOOST_CHECK(testArgs.ParseParameters(3, (char**)combo_test_args, error));

testArgs.ReadConfigString(combo_test_conf);

// Command line overrides, but doesn't erase old setting

BOOST_CHECK(testArgs.IsArgNegated("-foo"));

BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "0");

BOOST_CHECK(testArgs.GetArgs("-foo").size() == 0);

// Command line overrides, but doesn't erase old setting

BOOST_CHECK(!testArgs.IsArgNegated("-bar"));

BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "");

BOOST_CHECK(testArgs.GetArgs("-bar").size() == 1

&& testArgs.GetArgs("-bar").front() == "");

{

const char *str_config =

"a=\n"

"b=1\n"

"ccc=argument\n"

"ccc=multiple\n"

"d=e\n"

"nofff=1\n"

"noggg=0\n"

"h=1\n"

"noh=1\n"

"noi=1\n"

"i=1\n"

"sec1.ccc=extend1\n"

"\n"

"[sec1]\n"

"ccc=extend2\n"

"d=eee\n"

"h=1\n"

"[sec2]\n"

"ccc=extend3\n"

"iii=2\n";

TestArgsManager test_args;

LOCK(test_args.cs_args);

const auto a = std::make_pair("-a", ArgsManager::ALLOW_ANY);

const auto b = std::make_pair("-b", ArgsManager::ALLOW_ANY);

const auto ccc = std::make_pair("-ccc", ArgsManager::ALLOW_ANY);

const auto d = std::make_pair("-d", ArgsManager::ALLOW_ANY);

const auto e = std::make_pair("-e", ArgsManager::ALLOW_ANY);

const auto fff = std::make_pair("-fff", ArgsManager::ALLOW_ANY);

const auto ggg = std::make_pair("-ggg", ArgsManager::ALLOW_ANY);

const auto h = std::make_pair("-h", ArgsManager::ALLOW_ANY);

const auto i = std::make_pair("-i", ArgsManager::ALLOW_ANY);

const auto iii = std::make_pair("-iii", ArgsManager::ALLOW_ANY);

test_args.SetupArgs({a, b, ccc, d, e, fff, ggg, h, i, iii});

test_args.ReadConfigString(str_config);

// expectation: a, b, ccc, d, fff, ggg, h, i end up in map

// so do sec1.ccc, sec1.d, sec1.h, sec2.ccc, sec2.iii

BOOST_CHECK(test_args.m_settings.command_line_options.empty());

BOOST_CHECK(test_args.m_settings.ro_config.size() == 3);

BOOST_CHECK(test_args.m_settings.ro_config[""].size() == 8);

BOOST_CHECK(test_args.m_settings.ro_config["sec1"].size() == 3);

BOOST_CHECK(test_args.m_settings.ro_config["sec2"].size() == 2);

BOOST_CHECK(test_args.m_settings.ro_config[""].count("a")

&& test_args.m_settings.ro_config[""].count("b")

&& test_args.m_settings.ro_config[""].count("ccc")

&& test_args.m_settings.ro_config[""].count("d")

&& test_args.m_settings.ro_config[""].count("fff")

&& test_args.m_settings.ro_config[""].count("ggg")

&& test_args.m_settings.ro_config[""].count("h")

&& test_args.m_settings.ro_config[""].count("i")

);

BOOST_CHECK(test_args.m_settings.ro_config["sec1"].count("ccc")

&& test_args.m_settings.ro_config["sec1"].count("h")

&& test_args.m_settings.ro_config["sec2"].count("ccc")

&& test_args.m_settings.ro_config["sec2"].count("iii")

);

BOOST_CHECK(test_args.IsArgSet("-a")

&& test_args.IsArgSet("-b")

&& test_args.IsArgSet("-ccc")

&& test_args.IsArgSet("-d")

&& test_args.IsArgSet("-fff")

&& test_args.IsArgSet("-ggg")

&& test_args.IsArgSet("-h")

&& test_args.IsArgSet("-i")

&& !test_args.IsArgSet("-zzz")

&& !test_args.IsArgSet("-iii")

);

BOOST_CHECK(test_args.GetArg("-a", "xxx") == ""

&& test_args.GetArg("-b", "xxx") == "1"

&& test_args.GetArg("-ccc", "xxx") == "argument"

&& test_args.GetArg("-d", "xxx") == "e"

&& test_args.GetArg("-fff", "xxx") == "0"

&& test_args.GetArg("-ggg", "xxx") == "1"

&& test_args.GetArg("-h", "xxx") == "0"

&& test_args.GetArg("-i", "xxx") == "1"

&& test_args.GetArg("-zzz", "xxx") == "xxx"

&& test_args.GetArg("-iii", "xxx") == "xxx"

);

for (const bool def : {false, true}) {

BOOST_CHECK(test_args.GetBoolArg("-a", def)

&& test_args.GetBoolArg("-b", def)

&& !test_args.GetBoolArg("-ccc", def)

&& !test_args.GetBoolArg("-d", def)

&& !test_args.GetBoolArg("-fff", def)

&& test_args.GetBoolArg("-ggg", def)

&& !test_args.GetBoolArg("-h", def)

&& test_args.GetBoolArg("-i", def)

&& test_args.GetBoolArg("-zzz", def) == def

&& test_args.GetBoolArg("-iii", def) == def

);

}

BOOST_CHECK(test_args.GetArgs("-a").size() == 1

&& test_args.GetArgs("-a").front() == "");

BOOST_CHECK(test_args.GetArgs("-b").size() == 1

&& test_args.GetArgs("-b").front() == "1");

BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2

&& test_args.GetArgs("-ccc").front() == "argument"

&& test_args.GetArgs("-ccc").back() == "multiple");

BOOST_CHECK(test_args.GetArgs("-fff").size() == 0);

BOOST_CHECK(test_args.GetArgs("-nofff").size() == 0);

BOOST_CHECK(test_args.GetArgs("-ggg").size() == 1

&& test_args.GetArgs("-ggg").front() == "1");

BOOST_CHECK(test_args.GetArgs("-noggg").size() == 0);

BOOST_CHECK(test_args.GetArgs("-h").size() == 0);

BOOST_CHECK(test_args.GetArgs("-noh").size() == 0);

BOOST_CHECK(test_args.GetArgs("-i").size() == 1

&& test_args.GetArgs("-i").front() == "1");

BOOST_CHECK(test_args.GetArgs("-noi").size() == 0);

BOOST_CHECK(test_args.GetArgs("-zzz").size() == 0);

BOOST_CHECK(!test_args.IsArgNegated("-a"));

BOOST_CHECK(!test_args.IsArgNegated("-b"));

BOOST_CHECK(!test_args.IsArgNegated("-ccc"));

BOOST_CHECK(!test_args.IsArgNegated("-d"));

BOOST_CHECK(test_args.IsArgNegated("-fff"));

BOOST_CHECK(!test_args.IsArgNegated("-ggg"));

BOOST_CHECK(test_args.IsArgNegated("-h")); // last setting takes precedence

BOOST_CHECK(!test_args.IsArgNegated("-i")); // last setting takes precedence

BOOST_CHECK(!test_args.IsArgNegated("-zzz"));

// Test sections work

test_args.SelectConfigNetwork("sec1");

// same as original

BOOST_CHECK(test_args.GetArg("-a", "xxx") == ""

&& test_args.GetArg("-b", "xxx") == "1"

&& test_args.GetArg("-fff", "xxx") == "0"

&& test_args.GetArg("-ggg", "xxx") == "1"

&& test_args.GetArg("-zzz", "xxx") == "xxx"

&& test_args.GetArg("-iii", "xxx") == "xxx"

);

// d is overridden

BOOST_CHECK(test_args.GetArg("-d", "xxx") == "eee");

// section-specific setting

BOOST_CHECK(test_args.GetArg("-h", "xxx") == "1");

// section takes priority for multiple values

BOOST_CHECK(test_args.GetArg("-ccc", "xxx") == "extend1");

// check multiple values works

const std::vector<std::string> sec1_ccc_expected = {"extend1","extend2","argument","multiple"};

const auto& sec1_ccc_res = test_args.GetArgs("-ccc");

BOOST_CHECK_EQUAL_COLLECTIONS(sec1_ccc_res.begin(), sec1_ccc_res.end(), sec1_ccc_expected.begin(), sec1_ccc_expected.end());

test_args.SelectConfigNetwork("sec2");

// same as original

BOOST_CHECK(test_args.GetArg("-a", "xxx") == ""

&& test_args.GetArg("-b", "xxx") == "1"

&& test_args.GetArg("-d", "xxx") == "e"

&& test_args.GetArg("-fff", "xxx") == "0"

&& test_args.GetArg("-ggg", "xxx") == "1"

&& test_args.GetArg("-zzz", "xxx") == "xxx"

&& test_args.GetArg("-h", "xxx") == "0"

);

// section-specific setting

BOOST_CHECK(test_args.GetArg("-iii", "xxx") == "2");

// section takes priority for multiple values

BOOST_CHECK(test_args.GetArg("-ccc", "xxx") == "extend3");

// check multiple values works

const std::vector<std::string> sec2_ccc_expected = {"extend3","argument","multiple"};

const auto& sec2_ccc_res = test_args.GetArgs("-ccc");

BOOST_CHECK_EQUAL_COLLECTIONS(sec2_ccc_res.begin(), sec2_ccc_res.end(), sec2_ccc_expected.begin(), sec2_ccc_expected.end());

// Test section only options

test_args.SetNetworkOnlyArg("-d");

test_args.SetNetworkOnlyArg("-ccc");

test_args.SetNetworkOnlyArg("-h");

test_args.SelectConfigNetwork(CBaseChainParams::MAIN);

BOOST_CHECK(test_args.GetArg("-d", "xxx") == "e");

BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2);

BOOST_CHECK(test_args.GetArg("-h", "xxx") == "0");

test_args.SelectConfigNetwork("sec1");

BOOST_CHECK(test_args.GetArg("-d", "xxx") == "eee");

BOOST_CHECK(test_args.GetArgs("-d").size() == 1);

BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2);

BOOST_CHECK(test_args.GetArg("-h", "xxx") == "1");

test_args.SelectConfigNetwork("sec2");

BOOST_CHECK(test_args.GetArg("-d", "xxx") == "xxx");

BOOST_CHECK(test_args.GetArgs("-d").size() == 0);

BOOST_CHECK(test_args.GetArgs("-ccc").size() == 1);

BOOST_CHECK(test_args.GetArg("-h", "xxx") == "0");

{

TestArgsManager testArgs;

LOCK(testArgs.cs_args);

testArgs.m_settings.command_line_options.clear();

testArgs.m_settings.command_line_options["strtest1"] = {"string..."};

// strtest2 undefined on purpose

testArgs.m_settings.command_line_options["inttest1"] = {"12345"};

testArgs.m_settings.command_line_options["inttest2"] = {"81985529216486895"};

// inttest3 undefined on purpose

testArgs.m_settings.command_line_options["booltest1"] = {""};

// booltest2 undefined on purpose

testArgs.m_settings.command_line_options["booltest3"] = {"0"};

testArgs.m_settings.command_line_options["booltest4"] = {"1"};

// priorities

testArgs.m_settings.command_line_options["pritest1"] = {"a", "b"};

testArgs.m_settings.ro_config[""]["pritest2"] = {"a", "b"};

testArgs.m_settings.command_line_options["pritest3"] = {"a"};

testArgs.m_settings.ro_config[""]["pritest3"] = {"b"};

testArgs.m_settings.command_line_options["pritest4"] = {"a","b"};

testArgs.m_settings.ro_config[""]["pritest4"] = {"c","d"};

BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "string...");

BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "default");

BOOST_CHECK_EQUAL(testArgs.GetArg("inttest1", -1), 12345);

BOOST_CHECK_EQUAL(testArgs.GetArg("inttest2", -1), 81985529216486895LL);

BOOST_CHECK_EQUAL(testArgs.GetArg("inttest3", -1), -1);

BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", false), true);

BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest2", false), false);

BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest3", false), false);

BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest4", false), true);

BOOST_CHECK_EQUAL(testArgs.GetArg("pritest1", "default"), "b");

BOOST_CHECK_EQUAL(testArgs.GetArg("pritest2", "default"), "a");

BOOST_CHECK_EQUAL(testArgs.GetArg("pritest3", "default"), "a");

BOOST_CHECK_EQUAL(testArgs.GetArg("pritest4", "default"), "b");

{

TestArgsManager test_args;

const auto testnet = std::make_pair("-testnet", ArgsManager::ALLOW_ANY);

const auto regtest = std::make_pair("-regtest", ArgsManager::ALLOW_ANY);

test_args.SetupArgs({testnet, regtest});

const char* argv_testnet[] = {"cmd", "-testnet"};

const char* argv_regtest[] = {"cmd", "-regtest"};

const char* argv_test_no_reg[] = {"cmd", "-testnet", "-noregtest"};

const char* argv_both[] = {"cmd", "-testnet", "-regtest"};

// equivalent to "-testnet"

// regtest in testnet section is ignored

const char* testnetconf = "testnet=1\nregtest=0\n[test]\nregtest=1";

std::string error;

BOOST_CHECK(test_args.ParseParameters(0, (char**)argv_testnet, error));

BOOST_CHECK_EQUAL(test_args.GetChainName(), "main");

BOOST_CHECK(test_args.ParseParameters(2, (char**)argv_testnet, error));

BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");

BOOST_CHECK(test_args.ParseParameters(2, (char**)argv_regtest, error));

BOOST_CHECK_EQUAL(test_args.GetChainName(), "regtest");

BOOST_CHECK(test_args.ParseParameters(3, (char**)argv_test_no_reg, error));

BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");

BOOST_CHECK(test_args.ParseParameters(3, (char**)argv_both, error));

BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);

BOOST_CHECK(test_args.ParseParameters(0, (char**)argv_testnet, error));

test_args.ReadConfigString(testnetconf);

BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");

BOOST_CHECK(test_args.ParseParameters(2, (char**)argv_testnet, error));

test_args.ReadConfigString(testnetconf);

BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");

BOOST_CHECK(test_args.ParseParameters(2, (char**)argv_regtest, error));

test_args.ReadConfigString(testnetconf);

BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);

BOOST_CHECK(test_args.ParseParameters(3, (char**)argv_test_no_reg, error));

test_args.ReadConfigString(testnetconf);

BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");

BOOST_CHECK(test_args.ParseParameters(3, (char**)argv_both, error));

test_args.ReadConfigString(testnetconf);

BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);

// check setting the network to test (and thus making

// [test] regtest=1 potentially relevant) doesn't break things

test_args.SelectConfigNetwork("test");

BOOST_CHECK(test_args.ParseParameters(0, (char**)argv_testnet, error));

test_args.ReadConfigString(testnetconf);

BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");

BOOST_CHECK(test_args.ParseParameters(2, (char**)argv_testnet, error));

test_args.ReadConfigString(testnetconf);

BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");

BOOST_CHECK(test_args.ParseParameters(2, (char**)argv_regtest, error));

test_args.ReadConfigString(testnetconf);

BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);

BOOST_CHECK(test_args.ParseParameters(2, (char**)argv_test_no_reg, error));

test_args.ReadConfigString(testnetconf);

BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");

BOOST_CHECK(test_args.ParseParameters(3, (char**)argv_both, error));

test_args.ReadConfigString(testnetconf);

BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);

//! Max number of actions to sequence together. Can decrease this when

//! debugging to make test results easier to understand.

static constexpr int MAX_ACTIONS = 3;

enum Action { NONE, SET, NEGATE, SECTION_SET, SECTION_NEGATE };

using ActionList = Action[MAX_ACTIONS];

//! Enumerate all possible test configurations.

template <typename Fn>

void ForEachMergeSetup(Fn&& fn)

{

ActionList arg_actions = {};

// command_line_options do not have sections. Only iterate over SET and NEGATE

ForEachNoDup(arg_actions, SET, NEGATE, [&] {

ActionList conf_actions = {};

ForEachNoDup(conf_actions, SET, SECTION_NEGATE, [&] {

for (bool soft_set : {false, true}) {

for (bool force_set : {false, true}) {

for (const std::string& section : {CBaseChainParams::MAIN, CBaseChainParams::TESTNET}) {

for (const std::string& network : {CBaseChainParams::MAIN, CBaseChainParams::TESTNET}) {

for (bool net_specific : {false, true}) {

fn(arg_actions, conf_actions, soft_set, force_set, section, network, net_specific);

}

}

}

}

}

});

});

}

//! Translate actions into a list of <key>=<value> setting strings.

std::vector<std::string> GetValues(const ActionList& actions,

const std::string& section,

const std::string& name,

const std::string& value_prefix)

{

std::vector<std::string> values;

int suffix = 0;

for (Action action : actions) {

if (action == NONE) break;

std::string prefix;

if (action == SECTION_SET || action == SECTION_NEGATE) prefix = section + ".";

if (action == SET || action == SECTION_SET) {

for (int i = 0; i < 2; ++i) {

values.push_back(prefix + name + "=" + value_prefix + ToString(++suffix));

}

}

if (action == NEGATE || action == SECTION_NEGATE) {

values.push_back(prefix + "no" + name + "=1");

}

}

return values;

}

{

CHash256 out_sha;

FILE* out_file = nullptr;

if (const char* out_path = getenv("ARGS_MERGE_TEST_OUT")) {

out_file = fsbridge::fopen(out_path, "w");

if (!out_file) throw std::system_error(errno, std::generic_category(), "fopen failed");

}

ForEachMergeSetup([&](const ActionList& arg_actions, const ActionList& conf_actions, bool soft_set, bool force_set,

const std::string& section, const std::string& network, bool net_specific) {

TestArgsManager parser;

LOCK(parser.cs_args);

std::string desc = "net=";

desc += network;

parser.m_network = network;

const std::string& name = net_specific ? "wallet" : "server";

const std::string key = "-" + name;

parser.AddArg(key, name, ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

if (net_specific) parser.SetNetworkOnlyArg(key);

auto args = GetValues(arg_actions, section, name, "a");

std::vector<const char*> argv = {"ignored"};

for (auto& arg : args) {

arg.insert(0, "-");

desc += " ";

desc += arg;

argv.push_back(arg.c_str());

}

std::string error;

BOOST_CHECK(parser.ParseParameters(argv.size(), argv.data(), error));

BOOST_CHECK_EQUAL(error, "");

std::string conf;

for (auto& conf_val : GetValues(conf_actions, section, name, "c")) {

desc += " ";

desc += conf_val;

conf += conf_val;

conf += "\n";

}

std::istringstream conf_stream(conf);

BOOST_CHECK(parser.ReadConfigStream(conf_stream, "filepath", error));

BOOST_CHECK_EQUAL(error, "");

if (soft_set) {

desc += " soft";

parser.SoftSetArg(key, "soft1");

parser.SoftSetArg(key, "soft2");

}

if (force_set) {

desc += " force";

parser.ForceSetArg(key, "force1");

parser.ForceSetArg(key, "force2");

}

desc += " || ";

if (!parser.IsArgSet(key)) {

desc += "unset";

BOOST_CHECK(!parser.IsArgNegated(key));

BOOST_CHECK_EQUAL(parser.GetArg(key, "default"), "default");

BOOST_CHECK(parser.GetArgs(key).empty());

} else if (parser.IsArgNegated(key)) {

desc += "negated";