argsman_tests.cpp
1 // Copyright (c) 2011-present The Bitcoin Core developers 2 // Distributed under the MIT software license, see the accompanying 3 // file COPYING or http://www.opensource.org/licenses/mit-license.php. 4 5 #include <common/args.h> 6 #include <sync.h> 7 #include <test/util/logging.h> 8 #include <test/util/setup_common.h> 9 #include <test/util/str.h> 10 #include <univalue.h> 11 #include <util/chaintype.h> 12 #include <util/fs.h> 13 #include <util/strencodings.h> 14 15 #include <array> 16 #include <optional> 17 #include <cstdint> 18 #include <cstring> 19 #include <vector> 20 21 #include <boost/test/unit_test.hpp> 22 23 using util::ToString; 24 25 BOOST_FIXTURE_TEST_SUITE(argsman_tests, BasicTestingSetup) 26 27 BOOST_AUTO_TEST_CASE(util_datadir) 28 { 29 // Use local args variable instead of m_args to avoid making assumptions about test setup 30 ArgsManager args; 31 args.ForceSetArg("-datadir", fs::PathToString(m_path_root)); 32 33 const fs::path dd_norm = args.GetDataDirBase(); 34 35 args.ForceSetArg("-datadir", fs::PathToString(dd_norm) + "/"); 36 args.ClearPathCache(); 37 BOOST_CHECK_EQUAL(dd_norm, args.GetDataDirBase()); 38 39 args.ForceSetArg("-datadir", fs::PathToString(dd_norm) + "/."); 40 args.ClearPathCache(); 41 BOOST_CHECK_EQUAL(dd_norm, args.GetDataDirBase()); 42 43 args.ForceSetArg("-datadir", fs::PathToString(dd_norm) + "/./"); 44 args.ClearPathCache(); 45 BOOST_CHECK_EQUAL(dd_norm, args.GetDataDirBase()); 46 47 args.ForceSetArg("-datadir", fs::PathToString(dd_norm) + "/.//"); 48 args.ClearPathCache(); 49 BOOST_CHECK_EQUAL(dd_norm, args.GetDataDirBase()); 50 } 51 52 struct TestArgsManager : public ArgsManager 53 { 54 void ReadConfigString(const std::string& str_config) 55 { 56 BOOST_REQUIRE(ArgsManager::ReadConfigString(str_config)); 57 } 58 void SetupArgs(const std::vector<std::pair<std::string, unsigned int>>& args) 59 { 60 for (const auto& arg : args) { 61 AddArg(arg.first, "", arg.second, OptionsCategory::OPTIONS); 62 } 63 } 64 65 // make protected methods available for testing 66 using ArgsManager::ReadConfigStream; 67 }; 68 69 //! Test GetSetting and GetArg type coercion, negation, and default value handling. 70 class CheckValueTest : public TestChain100Setup 71 { 72 public: 73 struct Expect { 74 common::SettingsValue setting; 75 bool default_string = false; 76 bool default_int = false; 77 bool default_bool = false; 78 const char* string_value = nullptr; 79 std::optional<int64_t> int_value; 80 std::optional<bool> bool_value; 81 std::optional<std::vector<std::string>> list_value; 82 const char* error = nullptr; 83 84 explicit Expect(common::SettingsValue s) : setting(std::move(s)) {} 85 Expect& DefaultString() { default_string = true; return *this; } 86 Expect& DefaultInt() { default_int = true; return *this; } 87 Expect& DefaultBool() { default_bool = true; return *this; } 88 Expect& String(const char* s) { string_value = s; return *this; } 89 Expect& Int(int64_t i) { int_value = i; return *this; } 90 Expect& Bool(bool b) { bool_value = b; return *this; } 91 Expect& List(std::vector<std::string> m) { list_value = std::move(m); return *this; } 92 Expect& Error(const char* e) { error = e; return *this; } 93 }; 94 95 void CheckValue(unsigned int flags, const char* arg, const Expect& expect) 96 { 97 TestArgsManager test; 98 test.SetupArgs({{"-value", flags}}); 99 const char* argv[] = {"ignored", arg}; 100 std::string error; 101 bool success = test.ParseParameters(arg ? 2 : 1, argv, error); 102 103 BOOST_CHECK_EQUAL(test.GetSetting("-value").write(), expect.setting.write()); 104 auto settings_list = test.GetSettingsList("-value"); 105 if (expect.setting.isNull() || expect.setting.isFalse()) { 106 BOOST_CHECK_EQUAL(settings_list.size(), 0U); 107 } else { 108 BOOST_CHECK_EQUAL(settings_list.size(), 1U); 109 BOOST_CHECK_EQUAL(settings_list[0].write(), expect.setting.write()); 110 } 111 112 if (expect.error) { 113 BOOST_CHECK(!success); 114 BOOST_CHECK_NE(error.find(expect.error), std::string::npos); 115 } else { 116 BOOST_CHECK(success); 117 BOOST_CHECK_EQUAL(error, ""); 118 } 119 120 if (expect.default_string) { 121 BOOST_CHECK_EQUAL(test.GetArg("-value", "zzzzz"), "zzzzz"); 122 } else if (expect.string_value) { 123 BOOST_CHECK_EQUAL(test.GetArg("-value", "zzzzz"), expect.string_value); 124 } else { 125 BOOST_CHECK(!success); 126 } 127 128 if (expect.default_int) { 129 BOOST_CHECK_EQUAL(test.GetIntArg("-value", 99999), 99999); 130 } else if (expect.int_value) { 131 BOOST_CHECK_EQUAL(test.GetIntArg("-value", 99999), *expect.int_value); 132 } else { 133 BOOST_CHECK(!success); 134 } 135 136 if (expect.default_bool) { 137 BOOST_CHECK_EQUAL(test.GetBoolArg("-value", false), false); 138 BOOST_CHECK_EQUAL(test.GetBoolArg("-value", true), true); 139 } else if (expect.bool_value) { 140 BOOST_CHECK_EQUAL(test.GetBoolArg("-value", false), *expect.bool_value); 141 BOOST_CHECK_EQUAL(test.GetBoolArg("-value", true), *expect.bool_value); 142 } else { 143 BOOST_CHECK(!success); 144 } 145 146 if (expect.list_value) { 147 auto l = test.GetArgs("-value"); 148 BOOST_CHECK_EQUAL_COLLECTIONS(l.begin(), l.end(), expect.list_value->begin(), expect.list_value->end()); 149 } else { 150 BOOST_CHECK(!success); 151 } 152 } 153 }; 154 155 BOOST_FIXTURE_TEST_CASE(util_CheckValue, CheckValueTest) 156 { 157 using M = ArgsManager; 158 159 CheckValue(M::ALLOW_ANY, nullptr, Expect{{}}.DefaultString().DefaultInt().DefaultBool().List({})); 160 CheckValue(M::ALLOW_ANY, "-novalue", Expect{false}.String("0").Int(0).Bool(false).List({})); 161 CheckValue(M::ALLOW_ANY, "-novalue=", Expect{false}.String("0").Int(0).Bool(false).List({})); 162 CheckValue(M::ALLOW_ANY, "-novalue=0", Expect{true}.String("1").Int(1).Bool(true).List({"1"})); 163 CheckValue(M::ALLOW_ANY, "-novalue=1", Expect{false}.String("0").Int(0).Bool(false).List({})); 164 CheckValue(M::ALLOW_ANY, "-novalue=2", Expect{false}.String("0").Int(0).Bool(false).List({})); 165 CheckValue(M::ALLOW_ANY, "-novalue=abc", Expect{true}.String("1").Int(1).Bool(true).List({"1"})); 166 CheckValue(M::ALLOW_ANY, "-value", Expect{""}.String("").Int(0).Bool(true).List({""})); 167 CheckValue(M::ALLOW_ANY, "-value=", Expect{""}.String("").Int(0).Bool(true).List({""})); 168 CheckValue(M::ALLOW_ANY, "-value=0", Expect{"0"}.String("0").Int(0).Bool(false).List({"0"})); 169 CheckValue(M::ALLOW_ANY, "-value=1", Expect{"1"}.String("1").Int(1).Bool(true).List({"1"})); 170 CheckValue(M::ALLOW_ANY, "-value=2", Expect{"2"}.String("2").Int(2).Bool(true).List({"2"})); 171 CheckValue(M::ALLOW_ANY, "-value=abc", Expect{"abc"}.String("abc").Int(0).Bool(false).List({"abc"})); 172 } 173 174 struct NoIncludeConfTest { 175 std::string Parse(const char* arg) 176 { 177 TestArgsManager test; 178 test.SetupArgs({{"-includeconf", ArgsManager::ALLOW_ANY}}); 179 std::array argv{"ignored", arg}; 180 std::string error; 181 (void)test.ParseParameters(argv.size(), argv.data(), error); 182 return error; 183 } 184 }; 185 186 BOOST_FIXTURE_TEST_CASE(util_NoIncludeConf, NoIncludeConfTest) 187 { 188 BOOST_CHECK_EQUAL(Parse("-noincludeconf"), ""); 189 BOOST_CHECK_EQUAL(Parse("-includeconf"), "-includeconf cannot be used from commandline; -includeconf=\"\""); 190 BOOST_CHECK_EQUAL(Parse("-includeconf=file"), "-includeconf cannot be used from commandline; -includeconf=\"file\""); 191 } 192 193 BOOST_AUTO_TEST_CASE(util_ParseParameters) 194 { 195 TestArgsManager testArgs; 196 const auto a = std::make_pair("-a", ArgsManager::ALLOW_ANY); 197 const auto b = std::make_pair("-b", ArgsManager::ALLOW_ANY); 198 const auto ccc = std::make_pair("-ccc", ArgsManager::ALLOW_ANY); 199 const auto d = std::make_pair("-d", ArgsManager::ALLOW_ANY); 200 201 const char *argv_test[] = {"-ignored", "-a", "-b", "-ccc=argument", "-ccc=multiple", "f", "-d=e"}; 202 203 std::string error; 204 testArgs.SetupArgs({a, b, ccc, d}); 205 BOOST_CHECK(testArgs.ParseParameters(0, argv_test, error)); 206 testArgs.LockSettings([&](const common::Settings& s) { 207 BOOST_CHECK(s.command_line_options.empty() && s.ro_config.empty()); 208 }); 209 210 BOOST_CHECK(testArgs.ParseParameters(1, argv_test, error)); 211 testArgs.LockSettings([&](const common::Settings& s) { 212 BOOST_CHECK(s.command_line_options.empty() && s.ro_config.empty()); 213 }); 214 215 BOOST_CHECK(testArgs.ParseParameters(7, argv_test, error)); 216 // expectation: -ignored is ignored (program name argument), 217 // -a, -b and -ccc end up in map, -d ignored because it is after 218 // a non-option argument (non-GNU option parsing) 219 BOOST_CHECK(testArgs.IsArgSet("-a") && testArgs.IsArgSet("-b") && testArgs.IsArgSet("-ccc") 220 && !testArgs.IsArgSet("f") && !testArgs.IsArgSet("-d")); 221 testArgs.LockSettings([&](const common::Settings& s) { 222 BOOST_CHECK(s.command_line_options.size() == 3 && s.ro_config.empty()); 223 BOOST_CHECK(s.command_line_options.contains("a") && s.command_line_options.contains("b") && s.command_line_options.contains("ccc") 224 && !s.command_line_options.contains("f") && !s.command_line_options.contains("d")); 225 226 BOOST_CHECK(s.command_line_options.at("a").size() == 1); 227 BOOST_CHECK(s.command_line_options.at("a").front().get_str() == ""); 228 BOOST_CHECK(s.command_line_options.at("ccc").size() == 2); 229 BOOST_CHECK(s.command_line_options.at("ccc").front().get_str() == "argument"); 230 BOOST_CHECK(s.command_line_options.at("ccc").back().get_str() == "multiple"); 231 }); 232 BOOST_CHECK(testArgs.GetArgs("-ccc").size() == 2); 233 } 234 235 BOOST_AUTO_TEST_CASE(util_ParseInvalidParameters) 236 { 237 TestArgsManager test; 238 test.SetupArgs({{"-registered", ArgsManager::ALLOW_ANY}}); 239 240 const char* argv[] = {"ignored", "-registered"}; 241 std::string error; 242 BOOST_CHECK(test.ParseParameters(2, argv, error)); 243 BOOST_CHECK_EQUAL(error, ""); 244 245 argv[1] = "-unregistered"; 246 BOOST_CHECK(!test.ParseParameters(2, argv, error)); 247 BOOST_CHECK_EQUAL(error, "Invalid parameter -unregistered"); 248 249 // Make sure registered parameters prefixed with a chain type trigger errors. 250 // (Previously, they were accepted and ignored.) 251 argv[1] = "-test.registered"; 252 BOOST_CHECK(!test.ParseParameters(2, argv, error)); 253 BOOST_CHECK_EQUAL(error, "Invalid parameter -test.registered"); 254 } 255 256 static void TestParse(const std::string& str, bool expected_bool, int64_t expected_int) 257 { 258 TestArgsManager test; 259 test.SetupArgs({{"-value", ArgsManager::ALLOW_ANY}}); 260 std::string arg = "-value=" + str; 261 const char* argv[] = {"ignored", arg.c_str()}; 262 std::string error; 263 BOOST_CHECK(test.ParseParameters(2, argv, error)); 264 BOOST_CHECK_EQUAL(test.GetBoolArg("-value", false), expected_bool); 265 BOOST_CHECK_EQUAL(test.GetBoolArg("-value", true), expected_bool); 266 BOOST_CHECK_EQUAL(test.GetIntArg("-value", 99998), expected_int); 267 BOOST_CHECK_EQUAL(test.GetIntArg("-value", 99999), expected_int); 268 } 269 270 // Test bool and int parsing. 271 BOOST_AUTO_TEST_CASE(util_ArgParsing) 272 { 273 // Some of these cases could be ambiguous or surprising to users, and might 274 // be worth triggering errors or warnings in the future. But for now basic 275 // test coverage is useful to avoid breaking backwards compatibility 276 // unintentionally. 277 TestParse("", true, 0); 278 TestParse(" ", false, 0); 279 TestParse("0", false, 0); 280 TestParse("0 ", false, 0); 281 TestParse(" 0", false, 0); 282 TestParse("+0", false, 0); 283 TestParse("-0", false, 0); 284 TestParse("5", true, 5); 285 TestParse("5 ", true, 5); 286 TestParse(" 5", true, 5); 287 TestParse("+5", true, 5); 288 TestParse("-5", true, -5); 289 TestParse("0 5", false, 0); 290 TestParse("5 0", true, 5); 291 TestParse("050", true, 50); 292 TestParse("0.", false, 0); 293 TestParse("5.", true, 5); 294 TestParse("0.0", false, 0); 295 TestParse("0.5", false, 0); 296 TestParse("5.0", true, 5); 297 TestParse("5.5", true, 5); 298 TestParse("x", false, 0); 299 TestParse("x0", false, 0); 300 TestParse("x5", false, 0); 301 TestParse("0x", false, 0); 302 TestParse("5x", true, 5); 303 TestParse("0x5", false, 0); 304 TestParse("false", false, 0); 305 TestParse("true", false, 0); 306 TestParse("yes", false, 0); 307 TestParse("no", false, 0); 308 } 309 310 BOOST_AUTO_TEST_CASE(util_GetBoolArg) 311 { 312 TestArgsManager testArgs; 313 const auto a = std::make_pair("-a", ArgsManager::ALLOW_ANY); 314 const auto b = std::make_pair("-b", ArgsManager::ALLOW_ANY); 315 const auto c = std::make_pair("-c", ArgsManager::ALLOW_ANY); 316 const auto d = std::make_pair("-d", ArgsManager::ALLOW_ANY); 317 const auto e = std::make_pair("-e", ArgsManager::ALLOW_ANY); 318 const auto f = std::make_pair("-f", ArgsManager::ALLOW_ANY); 319 320 const char *argv_test[] = { 321 "ignored", "-a", "-nob", "-c=0", "-d=1", "-e=false", "-f=true"}; 322 std::string error; 323 testArgs.SetupArgs({a, b, c, d, e, f}); 324 BOOST_CHECK(testArgs.ParseParameters(7, argv_test, error)); 325 326 // Each letter should be set. 327 for (const char opt : "abcdef") 328 BOOST_CHECK(testArgs.IsArgSet({'-', opt}) || !opt); 329 330 // Nothing else should be in the map 331 testArgs.LockSettings([&](const common::Settings& s) { 332 BOOST_CHECK(s.command_line_options.size() == 6 && s.ro_config.empty()); 333 }); 334 335 // The -no prefix should get stripped on the way in. 336 BOOST_CHECK(!testArgs.IsArgSet("-nob")); 337 338 // The -b option is flagged as negated, and nothing else is 339 BOOST_CHECK(testArgs.IsArgNegated("-b")); 340 BOOST_CHECK(!testArgs.IsArgNegated("-a")); 341 342 // Check expected values. 343 BOOST_CHECK(testArgs.GetBoolArg("-a", false) == true); 344 BOOST_CHECK(testArgs.GetBoolArg("-b", true) == false); 345 BOOST_CHECK(testArgs.GetBoolArg("-c", true) == false); 346 BOOST_CHECK(testArgs.GetBoolArg("-d", false) == true); 347 BOOST_CHECK(testArgs.GetBoolArg("-e", true) == false); 348 BOOST_CHECK(testArgs.GetBoolArg("-f", true) == false); 349 } 350 351 BOOST_AUTO_TEST_CASE(util_GetBoolArgEdgeCases) 352 { 353 // Test some awful edge cases that hopefully no user will ever exercise. 354 TestArgsManager testArgs; 355 356 // Params test 357 const auto foo = std::make_pair("-foo", ArgsManager::ALLOW_ANY); 358 const auto bar = std::make_pair("-bar", ArgsManager::ALLOW_ANY); 359 const char *argv_test[] = {"ignored", "-nofoo", "-foo", "-nobar=0"}; 360 testArgs.SetupArgs({foo, bar}); 361 std::string error; 362 BOOST_CHECK(testArgs.ParseParameters(4, argv_test, error)); 363 364 // This was passed twice, second one overrides the negative setting. 365 BOOST_CHECK(!testArgs.IsArgNegated("-foo")); 366 BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == ""); 367 368 // A double negative is a positive, and not marked as negated. 369 BOOST_CHECK(!testArgs.IsArgNegated("-bar")); 370 BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "1"); 371 372 // Config test 373 const char *conf_test = "nofoo=1\nfoo=1\nnobar=0\n"; 374 BOOST_CHECK(testArgs.ParseParameters(1, argv_test, error)); 375 testArgs.ReadConfigString(conf_test); 376 377 // This was passed twice, second one overrides the negative setting, 378 // and the value. 379 BOOST_CHECK(!testArgs.IsArgNegated("-foo")); 380 BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "1"); 381 382 // A double negative is a positive, and does not count as negated. 383 BOOST_CHECK(!testArgs.IsArgNegated("-bar")); 384 BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "1"); 385 386 // Combined test 387 const char *combo_test_args[] = {"ignored", "-nofoo", "-bar"}; 388 const char *combo_test_conf = "foo=1\nnobar=1\n"; 389 BOOST_CHECK(testArgs.ParseParameters(3, combo_test_args, error)); 390 testArgs.ReadConfigString(combo_test_conf); 391 392 // Command line overrides, but doesn't erase old setting 393 BOOST_CHECK(testArgs.IsArgNegated("-foo")); 394 BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "0"); 395 BOOST_CHECK(testArgs.GetArgs("-foo").size() == 0); 396 397 // Command line overrides, but doesn't erase old setting 398 BOOST_CHECK(!testArgs.IsArgNegated("-bar")); 399 BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == ""); 400 BOOST_CHECK(testArgs.GetArgs("-bar").size() == 1 401 && testArgs.GetArgs("-bar").front() == ""); 402 } 403 404 BOOST_AUTO_TEST_CASE(util_ReadConfigStream) 405 { 406 const char *str_config = 407 "a=\n" 408 "b=1\n" 409 "ccc=argument\n" 410 "ccc=multiple\n" 411 "d=e\n" 412 "nofff=1\n" 413 "noggg=0\n" 414 "h=1\n" 415 "noh=1\n" 416 "noi=1\n" 417 "i=1\n" 418 "sec1.ccc=extend1\n" 419 "\n" 420 "[sec1]\n" 421 "ccc=extend2\n" 422 "d=eee\n" 423 "h=1\n" 424 "[sec2]\n" 425 "ccc=extend3\n" 426 "iii=2\n"; 427 428 TestArgsManager test_args; 429 const auto a = std::make_pair("-a", ArgsManager::ALLOW_ANY); 430 const auto b = std::make_pair("-b", ArgsManager::ALLOW_ANY); 431 const auto ccc = std::make_pair("-ccc", ArgsManager::ALLOW_ANY); 432 const auto d = std::make_pair("-d", ArgsManager::ALLOW_ANY); 433 const auto e = std::make_pair("-e", ArgsManager::ALLOW_ANY); 434 const auto fff = std::make_pair("-fff", ArgsManager::ALLOW_ANY); 435 const auto ggg = std::make_pair("-ggg", ArgsManager::ALLOW_ANY); 436 const auto h = std::make_pair("-h", ArgsManager::ALLOW_ANY); 437 const auto i = std::make_pair("-i", ArgsManager::ALLOW_ANY); 438 const auto iii = std::make_pair("-iii", ArgsManager::ALLOW_ANY); 439 test_args.SetupArgs({a, b, ccc, d, e, fff, ggg, h, i, iii}); 440 441 test_args.ReadConfigString(str_config); 442 // expectation: a, b, ccc, d, fff, ggg, h, i end up in map 443 // so do sec1.ccc, sec1.d, sec1.h, sec2.ccc, sec2.iii 444 445 test_args.LockSettings([&](const common::Settings& s) { 446 BOOST_CHECK(s.command_line_options.empty()); 447 BOOST_CHECK(s.ro_config.size() == 3); 448 BOOST_CHECK(s.ro_config.at("").size() == 8); 449 BOOST_CHECK(s.ro_config.at("sec1").size() == 3); 450 BOOST_CHECK(s.ro_config.at("sec2").size() == 2); 451 452 BOOST_CHECK(s.ro_config.at("").contains("a")); 453 BOOST_CHECK(s.ro_config.at("").contains("b")); 454 BOOST_CHECK(s.ro_config.at("").contains("ccc")); 455 BOOST_CHECK(s.ro_config.at("").contains("d")); 456 BOOST_CHECK(s.ro_config.at("").contains("fff")); 457 BOOST_CHECK(s.ro_config.at("").contains("ggg")); 458 BOOST_CHECK(s.ro_config.at("").contains("h")); 459 BOOST_CHECK(s.ro_config.at("").contains("i")); 460 BOOST_CHECK(s.ro_config.at("sec1").contains("ccc")); 461 BOOST_CHECK(s.ro_config.at("sec1").contains("h")); 462 BOOST_CHECK(s.ro_config.at("sec2").contains("ccc")); 463 BOOST_CHECK(s.ro_config.at("sec2").contains("iii")); 464 }); 465 466 BOOST_CHECK(test_args.IsArgSet("-a")); 467 BOOST_CHECK(test_args.IsArgSet("-b")); 468 BOOST_CHECK(test_args.IsArgSet("-ccc")); 469 BOOST_CHECK(test_args.IsArgSet("-d")); 470 BOOST_CHECK(test_args.IsArgSet("-fff")); 471 BOOST_CHECK(test_args.IsArgSet("-ggg")); 472 BOOST_CHECK(test_args.IsArgSet("-h")); 473 BOOST_CHECK(test_args.IsArgSet("-i")); 474 BOOST_CHECK(!test_args.IsArgSet("-zzz")); 475 BOOST_CHECK(!test_args.IsArgSet("-iii")); 476 477 BOOST_CHECK_EQUAL(test_args.GetArg("-a", "xxx"), ""); 478 BOOST_CHECK_EQUAL(test_args.GetArg("-b", "xxx"), "1"); 479 BOOST_CHECK_EQUAL(test_args.GetArg("-ccc", "xxx"), "argument"); 480 BOOST_CHECK_EQUAL(test_args.GetArg("-d", "xxx"), "e"); 481 BOOST_CHECK_EQUAL(test_args.GetArg("-fff", "xxx"), "0"); 482 BOOST_CHECK_EQUAL(test_args.GetArg("-ggg", "xxx"), "1"); 483 BOOST_CHECK_EQUAL(test_args.GetArg("-h", "xxx"), "0"); 484 BOOST_CHECK_EQUAL(test_args.GetArg("-i", "xxx"), "1"); 485 BOOST_CHECK_EQUAL(test_args.GetArg("-zzz", "xxx"), "xxx"); 486 BOOST_CHECK_EQUAL(test_args.GetArg("-iii", "xxx"), "xxx"); 487 488 for (const bool def : {false, true}) { 489 BOOST_CHECK(test_args.GetBoolArg("-a", def)); 490 BOOST_CHECK(test_args.GetBoolArg("-b", def)); 491 BOOST_CHECK(!test_args.GetBoolArg("-ccc", def)); 492 BOOST_CHECK(!test_args.GetBoolArg("-d", def)); 493 BOOST_CHECK(!test_args.GetBoolArg("-fff", def)); 494 BOOST_CHECK(test_args.GetBoolArg("-ggg", def)); 495 BOOST_CHECK(!test_args.GetBoolArg("-h", def)); 496 BOOST_CHECK(test_args.GetBoolArg("-i", def)); 497 BOOST_CHECK(test_args.GetBoolArg("-zzz", def) == def); 498 BOOST_CHECK(test_args.GetBoolArg("-iii", def) == def); 499 } 500 501 BOOST_CHECK(test_args.GetArgs("-a").size() == 1 502 && test_args.GetArgs("-a").front() == ""); 503 BOOST_CHECK(test_args.GetArgs("-b").size() == 1 504 && test_args.GetArgs("-b").front() == "1"); 505 BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2 506 && test_args.GetArgs("-ccc").front() == "argument" 507 && test_args.GetArgs("-ccc").back() == "multiple"); 508 BOOST_CHECK(test_args.GetArgs("-fff").size() == 0); 509 BOOST_CHECK(test_args.GetArgs("-nofff").size() == 0); 510 BOOST_CHECK(test_args.GetArgs("-ggg").size() == 1 511 && test_args.GetArgs("-ggg").front() == "1"); 512 BOOST_CHECK(test_args.GetArgs("-noggg").size() == 0); 513 BOOST_CHECK(test_args.GetArgs("-h").size() == 0); 514 BOOST_CHECK(test_args.GetArgs("-noh").size() == 0); 515 BOOST_CHECK(test_args.GetArgs("-i").size() == 1 516 && test_args.GetArgs("-i").front() == "1"); 517 BOOST_CHECK(test_args.GetArgs("-noi").size() == 0); 518 BOOST_CHECK(test_args.GetArgs("-zzz").size() == 0); 519 520 BOOST_CHECK(!test_args.IsArgNegated("-a")); 521 BOOST_CHECK(!test_args.IsArgNegated("-b")); 522 BOOST_CHECK(!test_args.IsArgNegated("-ccc")); 523 BOOST_CHECK(!test_args.IsArgNegated("-d")); 524 BOOST_CHECK(test_args.IsArgNegated("-fff")); 525 BOOST_CHECK(!test_args.IsArgNegated("-ggg")); 526 BOOST_CHECK(test_args.IsArgNegated("-h")); // last setting takes precedence 527 BOOST_CHECK(!test_args.IsArgNegated("-i")); // last setting takes precedence 528 BOOST_CHECK(!test_args.IsArgNegated("-zzz")); 529 530 // Test sections work 531 test_args.SelectConfigNetwork("sec1"); 532 533 // same as original 534 BOOST_CHECK_EQUAL(test_args.GetArg("-a", "xxx"), ""); 535 BOOST_CHECK_EQUAL(test_args.GetArg("-b", "xxx"), "1"); 536 BOOST_CHECK_EQUAL(test_args.GetArg("-fff", "xxx"), "0"); 537 BOOST_CHECK_EQUAL(test_args.GetArg("-ggg", "xxx"), "1"); 538 BOOST_CHECK_EQUAL(test_args.GetArg("-zzz", "xxx"), "xxx"); 539 BOOST_CHECK_EQUAL(test_args.GetArg("-iii", "xxx"), "xxx"); 540 // d is overridden 541 BOOST_CHECK(test_args.GetArg("-d", "xxx") == "eee"); 542 // section-specific setting 543 BOOST_CHECK(test_args.GetArg("-h", "xxx") == "1"); 544 // section takes priority for multiple values 545 BOOST_CHECK(test_args.GetArg("-ccc", "xxx") == "extend1"); 546 // check multiple values works 547 const std::vector<std::string> sec1_ccc_expected = {"extend1","extend2","argument","multiple"}; 548 const auto& sec1_ccc_res = test_args.GetArgs("-ccc"); 549 BOOST_CHECK_EQUAL_COLLECTIONS(sec1_ccc_res.begin(), sec1_ccc_res.end(), sec1_ccc_expected.begin(), sec1_ccc_expected.end()); 550 551 test_args.SelectConfigNetwork("sec2"); 552 553 // same as original 554 BOOST_CHECK(test_args.GetArg("-a", "xxx") == ""); 555 BOOST_CHECK(test_args.GetArg("-b", "xxx") == "1"); 556 BOOST_CHECK(test_args.GetArg("-d", "xxx") == "e"); 557 BOOST_CHECK(test_args.GetArg("-fff", "xxx") == "0"); 558 BOOST_CHECK(test_args.GetArg("-ggg", "xxx") == "1"); 559 BOOST_CHECK(test_args.GetArg("-zzz", "xxx") == "xxx"); 560 BOOST_CHECK(test_args.GetArg("-h", "xxx") == "0"); 561 // section-specific setting 562 BOOST_CHECK(test_args.GetArg("-iii", "xxx") == "2"); 563 // section takes priority for multiple values 564 BOOST_CHECK(test_args.GetArg("-ccc", "xxx") == "extend3"); 565 // check multiple values works 566 const std::vector<std::string> sec2_ccc_expected = {"extend3","argument","multiple"}; 567 const auto& sec2_ccc_res = test_args.GetArgs("-ccc"); 568 BOOST_CHECK_EQUAL_COLLECTIONS(sec2_ccc_res.begin(), sec2_ccc_res.end(), sec2_ccc_expected.begin(), sec2_ccc_expected.end()); 569 570 // Test section only options 571 572 const auto ccc2 = std::make_pair("-ccc", ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY); 573 const auto d2 = std::make_pair("-d", ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY); 574 const auto h2 = std::make_pair("-h", ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY); 575 test_args.ClearArgs(); 576 test_args.SetupArgs({a, b, ccc2, d2, e, fff, ggg, h2, i, iii}); 577 test_args.ReadConfigString(str_config); 578 579 test_args.SelectConfigNetwork(ChainTypeToString(ChainType::MAIN)); 580 BOOST_CHECK(test_args.GetArg("-d", "xxx") == "e"); 581 BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2); 582 BOOST_CHECK(test_args.GetArg("-h", "xxx") == "0"); 583 584 test_args.SelectConfigNetwork("sec1"); 585 BOOST_CHECK(test_args.GetArg("-d", "xxx") == "eee"); 586 BOOST_CHECK(test_args.GetArgs("-d").size() == 1); 587 BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2); 588 BOOST_CHECK(test_args.GetArg("-h", "xxx") == "1"); 589 590 test_args.SelectConfigNetwork("sec2"); 591 BOOST_CHECK(test_args.GetArg("-d", "xxx") == "xxx"); 592 BOOST_CHECK(test_args.GetArgs("-d").size() == 0); 593 BOOST_CHECK(test_args.GetArgs("-ccc").size() == 1); 594 BOOST_CHECK(test_args.GetArg("-h", "xxx") == "0"); 595 } 596 597 BOOST_AUTO_TEST_CASE(util_GetArg) 598 { 599 TestArgsManager testArgs; 600 testArgs.LockSettings([&](common::Settings& s) { 601 s.command_line_options.clear(); 602 s.command_line_options["strtest1"] = {"string..."}; 603 // strtest2 undefined on purpose 604 s.command_line_options["inttest1"] = {"12345"}; 605 s.command_line_options["inttest2"] = {"81985529216486895"}; 606 // inttest3 undefined on purpose 607 s.command_line_options["booltest1"] = {""}; 608 // booltest2 undefined on purpose 609 s.command_line_options["booltest3"] = {"0"}; 610 s.command_line_options["booltest4"] = {"1"}; 611 612 // priorities 613 s.command_line_options["pritest1"] = {"a", "b"}; 614 s.ro_config[""]["pritest2"] = {"a", "b"}; 615 s.command_line_options["pritest3"] = {"a"}; 616 s.ro_config[""]["pritest3"] = {"b"}; 617 s.command_line_options["pritest4"] = {"a","b"}; 618 s.ro_config[""]["pritest4"] = {"c","d"}; 619 }); 620 621 BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "string..."); 622 BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "default"); 623 BOOST_CHECK_EQUAL(testArgs.GetIntArg("inttest1", -1), 12345); 624 BOOST_CHECK_EQUAL(testArgs.GetIntArg("inttest2", -1), 81985529216486895LL); 625 BOOST_CHECK_EQUAL(testArgs.GetIntArg("inttest3", -1), -1); 626 BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", false), true); 627 BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest2", false), false); 628 BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest3", false), false); 629 BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest4", false), true); 630 631 BOOST_CHECK_EQUAL(testArgs.GetArg("pritest1", "default"), "b"); 632 BOOST_CHECK_EQUAL(testArgs.GetArg("pritest2", "default"), "a"); 633 BOOST_CHECK_EQUAL(testArgs.GetArg("pritest3", "default"), "a"); 634 BOOST_CHECK_EQUAL(testArgs.GetArg("pritest4", "default"), "b"); 635 } 636 637 BOOST_AUTO_TEST_CASE(util_GetChainTypeString) 638 { 639 TestArgsManager test_args; 640 const auto testnet = std::make_pair("-testnet", ArgsManager::ALLOW_ANY); 641 const auto testnet4 = std::make_pair("-testnet4", ArgsManager::ALLOW_ANY); 642 const auto regtest = std::make_pair("-regtest", ArgsManager::ALLOW_ANY); 643 test_args.SetupArgs({testnet, testnet4, regtest}); 644 645 const char* argv_testnet4[] = {"cmd", "-testnet4"}; 646 const char* argv_regtest[] = {"cmd", "-regtest"}; 647 const char* argv_test_no_reg[] = {"cmd", "-testnet4", "-noregtest"}; 648 const char* argv_both[] = {"cmd", "-testnet4", "-regtest"}; 649 650 // regtest in test network section is ignored 651 const char* testnetconf = "testnet4=1\nregtest=0\n[testnet4]\nregtest=1"; 652 std::string error; 653 654 BOOST_CHECK(test_args.ParseParameters(0, argv_testnet4, error)); 655 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "main"); 656 657 BOOST_CHECK(test_args.ParseParameters(0, argv_testnet4, error)); 658 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "main"); 659 660 BOOST_CHECK(test_args.ParseParameters(2, argv_testnet4, error)); 661 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4"); 662 663 BOOST_CHECK(test_args.ParseParameters(2, argv_regtest, error)); 664 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "regtest"); 665 666 BOOST_CHECK(test_args.ParseParameters(3, argv_test_no_reg, error)); 667 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4"); 668 669 BOOST_CHECK(test_args.ParseParameters(3, argv_both, error)); 670 BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error); 671 672 BOOST_CHECK(test_args.ParseParameters(0, argv_testnet4, error)); 673 test_args.ReadConfigString(testnetconf); 674 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4"); 675 676 BOOST_CHECK(test_args.ParseParameters(2, argv_testnet4, error)); 677 test_args.ReadConfigString(testnetconf); 678 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4"); 679 680 BOOST_CHECK(test_args.ParseParameters(2, argv_regtest, error)); 681 test_args.ReadConfigString(testnetconf); 682 BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error); 683 684 BOOST_CHECK(test_args.ParseParameters(3, argv_test_no_reg, error)); 685 test_args.ReadConfigString(testnetconf); 686 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4"); 687 688 BOOST_CHECK(test_args.ParseParameters(3, argv_both, error)); 689 test_args.ReadConfigString(testnetconf); 690 BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error); 691 692 // check setting the network to testnet4 (and thus making 693 // [testnet4] regtest=1 potentially relevant) doesn't break things 694 test_args.SelectConfigNetwork("testnet4"); 695 696 BOOST_CHECK(test_args.ParseParameters(0, argv_testnet4, error)); 697 test_args.ReadConfigString(testnetconf); 698 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4"); 699 700 BOOST_CHECK(test_args.ParseParameters(2, argv_testnet4, error)); 701 test_args.ReadConfigString(testnetconf); 702 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4"); 703 704 BOOST_CHECK(test_args.ParseParameters(2, argv_regtest, error)); 705 test_args.ReadConfigString(testnetconf); 706 BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error); 707 708 BOOST_CHECK(test_args.ParseParameters(2, argv_test_no_reg, error)); 709 test_args.ReadConfigString(testnetconf); 710 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4"); 711 712 BOOST_CHECK(test_args.ParseParameters(3, argv_both, error)); 713 test_args.ReadConfigString(testnetconf); 714 BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error); 715 } 716 717 // Test different ways settings can be merged, and verify results. This test can 718 // be used to confirm that updates to settings code don't change behavior 719 // unintentionally. 720 // 721 // The test covers: 722 // 723 // - Combining different setting actions. Possible actions are: configuring a 724 // setting, negating a setting (adding "-no" prefix), and configuring/negating 725 // settings in a network section (adding "main." or "test." prefixes). 726 // 727 // - Combining settings from command line arguments and a config file. 728 // 729 // - Combining SoftSet and ForceSet calls. 730 // 731 // - Testing "main" and "testnet4" network values to make sure settings from network 732 // sections are applied and to check for mainnet-specific behaviors like 733 // inheriting settings from the default section. 734 // 735 // - Testing network-specific settings like "-wallet", that may be ignored 736 // outside a network section, and non-network specific settings like "-server" 737 // that aren't sensitive to the network. 738 // 739 struct ArgsMergeTestingSetup : public BasicTestingSetup { 740 //! Max number of actions to sequence together. Can decrease this when 741 //! debugging to make test results easier to understand. 742 static constexpr int MAX_ACTIONS = 3; 743 744 enum Action { NONE, SET, NEGATE, SECTION_SET, SECTION_NEGATE }; 745 using ActionList = Action[MAX_ACTIONS]; 746 747 //! Enumerate all possible test configurations. 748 template <typename Fn> 749 void ForEachMergeSetup(Fn&& fn) 750 { 751 ActionList arg_actions = {}; 752 // command_line_options do not have sections. Only iterate over SET and NEGATE 753 ForEachNoDup(arg_actions, SET, NEGATE, [&] { 754 ActionList conf_actions = {}; 755 ForEachNoDup(conf_actions, SET, SECTION_NEGATE, [&] { 756 for (bool soft_set : {false, true}) { 757 for (bool force_set : {false, true}) { 758 for (const std::string& section : {ChainTypeToString(ChainType::MAIN), ChainTypeToString(ChainType::TESTNET), ChainTypeToString(ChainType::TESTNET4), ChainTypeToString(ChainType::SIGNET)}) { 759 for (const std::string& network : {ChainTypeToString(ChainType::MAIN), ChainTypeToString(ChainType::TESTNET), ChainTypeToString(ChainType::TESTNET4), ChainTypeToString(ChainType::SIGNET)}) { 760 for (bool net_specific : {false, true}) { 761 fn(arg_actions, conf_actions, soft_set, force_set, section, network, net_specific); 762 } 763 } 764 } 765 } 766 } 767 }); 768 }); 769 } 770 771 //! Translate actions into a list of <key>=<value> setting strings. 772 std::vector<std::string> GetValues(const ActionList& actions, 773 const std::string& section, 774 const std::string& name, 775 const std::string& value_prefix) 776 { 777 std::vector<std::string> values; 778 int suffix = 0; 779 for (Action action : actions) { 780 if (action == NONE) break; 781 std::string prefix; 782 if (action == SECTION_SET || action == SECTION_NEGATE) prefix = section + "."; 783 if (action == SET || action == SECTION_SET) { 784 for (int i = 0; i < 2; ++i) { 785 values.push_back(prefix + name + "=" + value_prefix + ToString(++suffix)); 786 } 787 } 788 if (action == NEGATE || action == SECTION_NEGATE) { 789 values.push_back(prefix + "no" + name + "=1"); 790 } 791 } 792 return values; 793 } 794 }; 795 796 // Regression test covering different ways config settings can be merged. The 797 // test parses and merges settings, representing the results as strings that get 798 // compared against an expected hash. To debug, the result strings can be dumped 799 // to a file (see comments below). 800 BOOST_FIXTURE_TEST_CASE(util_ArgsMerge, ArgsMergeTestingSetup) 801 { 802 CHash256 out_sha; 803 FILE* out_file = nullptr; 804 if (const char* out_path = getenv("ARGS_MERGE_TEST_OUT")) { 805 out_file = fsbridge::fopen(out_path, "w"); 806 if (!out_file) throw std::system_error(errno, std::generic_category(), "fopen failed"); 807 } 808 809 ForEachMergeSetup([&](const ActionList& arg_actions, const ActionList& conf_actions, bool soft_set, bool force_set, 810 const std::string& section, const std::string& network, bool net_specific) { 811 TestArgsManager parser; 812 813 std::string desc = "net="; 814 desc += network; 815 parser.SelectConfigNetwork(network); 816 817 const std::string& name = net_specific ? "wallet" : "server"; 818 const std::string key = "-" + name; 819 unsigned int flags = ArgsManager::ALLOW_ANY; 820 if (net_specific) flags |= ArgsManager::NETWORK_ONLY; 821 parser.AddArg(key, name, flags, OptionsCategory::OPTIONS); 822 823 auto args = GetValues(arg_actions, section, name, "a"); 824 std::vector<const char*> argv = {"ignored"}; 825 for (auto& arg : args) { 826 arg.insert(0, "-"); 827 desc += " "; 828 desc += arg; 829 argv.push_back(arg.c_str()); 830 } 831 std::string error; 832 BOOST_CHECK(parser.ParseParameters(argv.size(), argv.data(), error)); 833 BOOST_CHECK_EQUAL(error, ""); 834 835 std::string conf; 836 for (auto& conf_val : GetValues(conf_actions, section, name, "c")) { 837 desc += " "; 838 desc += conf_val; 839 conf += conf_val; 840 conf += "\n"; 841 } 842 std::istringstream conf_stream(conf); 843 BOOST_CHECK(parser.ReadConfigStream(conf_stream, "filepath", error)); 844 BOOST_CHECK_EQUAL(error, ""); 845 846 if (soft_set) { 847 desc += " soft"; 848 parser.SoftSetArg(key, "soft1"); 849 parser.SoftSetArg(key, "soft2"); 850 } 851 852 if (force_set) { 853 desc += " force"; 854 parser.ForceSetArg(key, "force1"); 855 parser.ForceSetArg(key, "force2"); 856 } 857 858 desc += " || "; 859 860 if (!parser.IsArgSet(key)) { 861 desc += "unset"; 862 BOOST_CHECK(!parser.IsArgNegated(key)); 863 BOOST_CHECK_EQUAL(parser.GetArg(key, "default"), "default"); 864 BOOST_CHECK(parser.GetArgs(key).empty()); 865 } else if (parser.IsArgNegated(key)) { 866 desc += "negated"; 867 BOOST_CHECK_EQUAL(parser.GetArg(key, "default"), "0"); 868 BOOST_CHECK(parser.GetArgs(key).empty()); 869 } else { 870 desc += parser.GetArg(key, "default"); 871 desc += " |"; 872 for (const auto& arg : parser.GetArgs(key)) { 873 desc += " "; 874 desc += arg; 875 } 876 } 877 878 std::set<std::string> ignored = parser.GetUnsuitableSectionOnlyArgs(); 879 if (!ignored.empty()) { 880 desc += " | ignored"; 881 for (const auto& arg : ignored) { 882 desc += " "; 883 desc += arg; 884 } 885 } 886 887 desc += "\n"; 888 889 out_sha.Write(MakeUCharSpan(desc)); 890 if (out_file) { 891 BOOST_REQUIRE(fwrite(desc.data(), 1, desc.size(), out_file) == desc.size()); 892 } 893 }); 894 895 if (out_file) { 896 if (fclose(out_file)) throw std::system_error(errno, std::generic_category(), "fclose failed"); 897 out_file = nullptr; 898 } 899 900 unsigned char out_sha_bytes[CSHA256::OUTPUT_SIZE]; 901 out_sha.Finalize(out_sha_bytes); 902 std::string out_sha_hex = HexStr(out_sha_bytes); 903 904 // If check below fails, should manually dump the results with: 905 // 906 // ARGS_MERGE_TEST_OUT=results.txt ./test_bitcoin --run_test=argsman_tests/util_ArgsMerge 907 // 908 // And verify diff against previous results to make sure the changes are expected. 909 // 910 // Results file is formatted like: 911 // 912 // <input> || <IsArgSet/IsArgNegated/GetArg output> | <GetArgs output> | <GetUnsuitable output> 913 BOOST_CHECK_EQUAL(out_sha_hex, "f1ee5ab094cc43d16a6086fa7f2c10389e0f99902616b31bbf29189972ad1473"); 914 } 915 916 // Similar test as above, but for ArgsManager::GetChainTypeString function. 917 struct ChainMergeTestingSetup : public BasicTestingSetup { 918 static constexpr int MAX_ACTIONS = 2; 919 920 enum Action { NONE, ENABLE_TEST, DISABLE_TEST, NEGATE_TEST, ENABLE_REG, DISABLE_REG, NEGATE_REG }; 921 using ActionList = Action[MAX_ACTIONS]; 922 923 //! Enumerate all possible test configurations. 924 template <typename Fn> 925 void ForEachMergeSetup(Fn&& fn) 926 { 927 ActionList arg_actions = {}; 928 ForEachNoDup(arg_actions, ENABLE_TEST, NEGATE_REG, [&] { 929 ActionList conf_actions = {}; 930 ForEachNoDup(conf_actions, ENABLE_TEST, NEGATE_REG, [&] { fn(arg_actions, conf_actions); }); 931 }); 932 } 933 }; 934 935 BOOST_FIXTURE_TEST_CASE(util_ChainMerge, ChainMergeTestingSetup) 936 { 937 CHash256 out_sha; 938 FILE* out_file = nullptr; 939 if (const char* out_path = getenv("CHAIN_MERGE_TEST_OUT")) { 940 out_file = fsbridge::fopen(out_path, "w"); 941 if (!out_file) throw std::system_error(errno, std::generic_category(), "fopen failed"); 942 } 943 944 ForEachMergeSetup([&](const ActionList& arg_actions, const ActionList& conf_actions) { 945 TestArgsManager parser; 946 parser.AddArg("-regtest", "regtest", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 947 parser.AddArg("-testnet4", "testnet4", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS); 948 949 auto arg = [](Action action) { return action == ENABLE_TEST ? "-testnet4=1" : 950 action == DISABLE_TEST ? "-testnet4=0" : 951 action == NEGATE_TEST ? "-notestnet4=1" : 952 action == ENABLE_REG ? "-regtest=1" : 953 action == DISABLE_REG ? "-regtest=0" : 954 action == NEGATE_REG ? "-noregtest=1" : nullptr; }; 955 956 std::string desc; 957 std::vector<const char*> argv = {"ignored"}; 958 for (Action action : arg_actions) { 959 const char* argstr = arg(action); 960 if (!argstr) break; 961 argv.push_back(argstr); 962 desc += " "; 963 desc += argv.back(); 964 } 965 std::string error; 966 BOOST_CHECK(parser.ParseParameters(argv.size(), argv.data(), error)); 967 BOOST_CHECK_EQUAL(error, ""); 968 969 std::string conf; 970 for (Action action : conf_actions) { 971 const char* argstr = arg(action); 972 if (!argstr) break; 973 desc += " "; 974 desc += argstr + 1; 975 conf += argstr + 1; 976 conf += "\n"; 977 } 978 std::istringstream conf_stream(conf); 979 BOOST_CHECK(parser.ReadConfigStream(conf_stream, "filepath", error)); 980 BOOST_CHECK_EQUAL(error, ""); 981 982 desc += " || "; 983 try { 984 desc += parser.GetChainTypeString(); 985 } catch (const std::runtime_error& e) { 986 desc += "error: "; 987 desc += e.what(); 988 } 989 desc += "\n"; 990 991 out_sha.Write(MakeUCharSpan(desc)); 992 if (out_file) { 993 BOOST_REQUIRE(fwrite(desc.data(), 1, desc.size(), out_file) == desc.size()); 994 } 995 }); 996 997 if (out_file) { 998 if (fclose(out_file)) throw std::system_error(errno, std::generic_category(), "fclose failed"); 999 out_file = nullptr; 1000 } 1001 1002 unsigned char out_sha_bytes[CSHA256::OUTPUT_SIZE]; 1003 out_sha.Finalize(out_sha_bytes); 1004 std::string out_sha_hex = HexStr(out_sha_bytes); 1005 1006 // If check below fails, should manually dump the results with: 1007 // 1008 // CHAIN_MERGE_TEST_OUT=results.txt ./test_bitcoin --run_test=argsman_tests/util_ChainMerge 1009 // 1010 // And verify diff against previous results to make sure the changes are expected. 1011 // 1012 // Results file is formatted like: 1013 // 1014 // <input> || <output> 1015 BOOST_CHECK_EQUAL(out_sha_hex, "c0e33aab0c74e040ddcee9edad59e8148d8e1cacb3cccd9ea1a1f485cb6bad21"); 1016 } 1017 1018 BOOST_AUTO_TEST_CASE(util_ReadWriteSettings) 1019 { 1020 // Test writing setting. 1021 TestArgsManager args1; 1022 args1.ForceSetArg("-datadir", fs::PathToString(m_path_root)); 1023 args1.LockSettings([&](common::Settings& s) { s.rw_settings["name"] = "value"; }); 1024 args1.WriteSettingsFile(); 1025 1026 // Test reading setting. 1027 TestArgsManager args2; 1028 args2.ForceSetArg("-datadir", fs::PathToString(m_path_root)); 1029 args2.ReadSettingsFile(); 1030 args2.LockSettings([&](common::Settings& s) { BOOST_CHECK_EQUAL(s.rw_settings["name"].get_str(), "value"); }); 1031 1032 // Test error logging, and remove previously written setting. 1033 { 1034 ASSERT_DEBUG_LOG("Failed renaming settings file"); 1035 fs::remove(args1.GetDataDirBase() / "settings.json"); 1036 fs::create_directory(args1.GetDataDirBase() / "settings.json"); 1037 args2.WriteSettingsFile(); 1038 fs::remove(args1.GetDataDirBase() / "settings.json"); 1039 } 1040 } 1041 1042 BOOST_AUTO_TEST_SUITE_END()