argsman_tests.cpp raw
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_AddCommand)
638 {
639 enum TestFail { SUCCESS,
640 PARSE_FAIL,
641 PARSE_ERROR,
642 NO_COMMAND,
643 COMMAND_OPTS_BAD_DETAILS,
644 COMMAND_OPTS };
645
646 auto testfn = [&](const auto& argv) -> TestFail {
647 TestArgsManager test_args;
648 test_args.AddArg("-opt1=<file name>", "Opt 1", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION, OptionsCategory::COMMAND_OPTIONS);
649 test_args.AddArg("-opt2=<file name>", "Opt 2", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION, OptionsCategory::COMMAND_OPTIONS);
650 test_args.AddArg("-opt3=<file name>", "Opt 3", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION, OptionsCategory::OPTIONS);
651
652 test_args.AddCommand("cmd1", "No specific options");
653 test_args.AddCommand("cmd2", "Opt 1", {"-opt1"});
654 test_args.AddCommand("cmd3", "Opt 1 or 2", {"-opt1", "-opt2"});
655
656 std::string error;
657 if (!test_args.ParseParameters(argv.size(), argv.data(), error)) return PARSE_FAIL;
658 if (!error.empty()) return PARSE_ERROR;
659 const auto command = test_args.GetCommand();
660 if (!command) return NO_COMMAND;
661 std::vector<std::string> details;
662 if (!test_args.CheckCommandOptions(command->command, &details)) {
663 if (details.empty()) return COMMAND_OPTS_BAD_DETAILS;
664 return COMMAND_OPTS;
665 } else if (!details.empty()) {
666 return COMMAND_OPTS_BAD_DETAILS;
667 }
668 return SUCCESS;
669 };
670
671 BOOST_CHECK_EQUAL(COMMAND_OPTS, testfn(std::array{"x", "-opt1=foo", "cmd1"}));
672 BOOST_CHECK_EQUAL(SUCCESS, testfn(std::array{"x", "cmd1", "-opt1=foo"})); // things after the command are "args" and left unparsed, not options
673
674 BOOST_CHECK_EQUAL(SUCCESS, testfn(std::array{"x", "-opt1=foo", "cmd2"}));
675 BOOST_CHECK_EQUAL(SUCCESS, testfn(std::array{"x", "-opt1=foo", "cmd3"}));
676 BOOST_CHECK_EQUAL(COMMAND_OPTS, testfn(std::array{"x", "-opt2=foo", "cmd1"}));
677 BOOST_CHECK_EQUAL(COMMAND_OPTS, testfn(std::array{"x", "-opt2=foo", "cmd2"}));
678 BOOST_CHECK_EQUAL(SUCCESS, testfn(std::array{"x", "-opt2=foo", "cmd3"}));
679 BOOST_CHECK_EQUAL(SUCCESS, testfn(std::array{"x", "-opt3=foo", "cmd1"}));
680 BOOST_CHECK_EQUAL(SUCCESS, testfn(std::array{"x", "-opt3=foo", "cmd2"}));
681 BOOST_CHECK_EQUAL(SUCCESS, testfn(std::array{"x", "-opt3=foo", "cmd3"}));
682
683 BOOST_CHECK_EQUAL(COMMAND_OPTS, testfn(std::array{"x", "-opt1=foo", "-opt3=bar", "-opt2=baz", "cmd1"}));
684 BOOST_CHECK_EQUAL(COMMAND_OPTS, testfn(std::array{"x", "-opt1=foo", "-opt3=bar", "-opt2=baz", "cmd2"}));
685 BOOST_CHECK_EQUAL(SUCCESS, testfn(std::array{"x", "-opt1=foo", "-opt3=bar", "-opt2=baz", "cmd3"}));
686
687 BOOST_CHECK_EQUAL(PARSE_FAIL, testfn(std::array{"x", "cmd4"}));
688 BOOST_CHECK_EQUAL(NO_COMMAND, testfn(std::array{"x", "-opt3=foo"}));
689 BOOST_CHECK_EQUAL(PARSE_FAIL, testfn(std::array{"x", "-opt4=foo"}));
690 }
691
692 BOOST_AUTO_TEST_CASE(util_AddCommand_clearargs_replaces_command_options)
693 {
694 const auto add_command{[&](TestArgsManager& test_args, const std::string& option) {
695 test_args.AddArg(option, "option", ArgsManager::ALLOW_ANY, OptionsCategory::COMMAND_OPTIONS);
696 test_args.AddCommand("cmd", "cmd", {option});
697 }};
698
699 TestArgsManager test_args;
700 add_command(test_args, "-opt1");
701 test_args.ClearArgs();
702 add_command(test_args, "-opt2");
703
704 const auto help{test_args.GetHelpMessage()};
705 BOOST_CHECK(help.find("-opt2") != std::string::npos);
706
707 test_args.ForceSetArg("-opt2", "1");
708 std::vector<std::string> details;
709 BOOST_CHECK(test_args.CheckCommandOptions("cmd", &details));
710 BOOST_CHECK(details.empty());
711 }
712
713 BOOST_AUTO_TEST_CASE(util_GetChainTypeString)
714 {
715 TestArgsManager test_args;
716 const auto testnet = std::make_pair("-testnet", ArgsManager::ALLOW_ANY);
717 const auto testnet4 = std::make_pair("-testnet4", ArgsManager::ALLOW_ANY);
718 const auto regtest = std::make_pair("-regtest", ArgsManager::ALLOW_ANY);
719 test_args.SetupArgs({testnet, testnet4, regtest});
720
721 const char* argv_testnet4[] = {"cmd", "-testnet4"};
722 const char* argv_regtest[] = {"cmd", "-regtest"};
723 const char* argv_test_no_reg[] = {"cmd", "-testnet4", "-noregtest"};
724 const char* argv_both[] = {"cmd", "-testnet4", "-regtest"};
725
726 // regtest in test network section is ignored
727 const char* testnetconf = "testnet4=1\nregtest=0\n[testnet4]\nregtest=1";
728 std::string error;
729
730 BOOST_CHECK(test_args.ParseParameters(0, argv_testnet4, error));
731 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "main");
732
733 BOOST_CHECK(test_args.ParseParameters(0, argv_testnet4, error));
734 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "main");
735
736 BOOST_CHECK(test_args.ParseParameters(2, argv_testnet4, error));
737 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4");
738
739 BOOST_CHECK(test_args.ParseParameters(2, argv_regtest, error));
740 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "regtest");
741
742 BOOST_CHECK(test_args.ParseParameters(3, argv_test_no_reg, error));
743 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4");
744
745 BOOST_CHECK(test_args.ParseParameters(3, argv_both, error));
746 BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
747
748 BOOST_CHECK(test_args.ParseParameters(0, argv_testnet4, error));
749 test_args.ReadConfigString(testnetconf);
750 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4");
751
752 BOOST_CHECK(test_args.ParseParameters(2, argv_testnet4, error));
753 test_args.ReadConfigString(testnetconf);
754 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4");
755
756 BOOST_CHECK(test_args.ParseParameters(2, argv_regtest, error));
757 test_args.ReadConfigString(testnetconf);
758 BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
759
760 BOOST_CHECK(test_args.ParseParameters(3, argv_test_no_reg, error));
761 test_args.ReadConfigString(testnetconf);
762 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4");
763
764 BOOST_CHECK(test_args.ParseParameters(3, argv_both, error));
765 test_args.ReadConfigString(testnetconf);
766 BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
767
768 // check setting the network to testnet4 (and thus making
769 // [testnet4] regtest=1 potentially relevant) doesn't break things
770 test_args.SelectConfigNetwork("testnet4");
771
772 BOOST_CHECK(test_args.ParseParameters(0, argv_testnet4, error));
773 test_args.ReadConfigString(testnetconf);
774 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4");
775
776 BOOST_CHECK(test_args.ParseParameters(2, argv_testnet4, error));
777 test_args.ReadConfigString(testnetconf);
778 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4");
779
780 BOOST_CHECK(test_args.ParseParameters(2, argv_regtest, error));
781 test_args.ReadConfigString(testnetconf);
782 BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
783
784 BOOST_CHECK(test_args.ParseParameters(2, argv_test_no_reg, error));
785 test_args.ReadConfigString(testnetconf);
786 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4");
787
788 BOOST_CHECK(test_args.ParseParameters(3, argv_both, error));
789 test_args.ReadConfigString(testnetconf);
790 BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
791 }
792
793 // Test different ways settings can be merged, and verify results. This test can
794 // be used to confirm that updates to settings code don't change behavior
795 // unintentionally.
796 //
797 // The test covers:
798 //
799 // - Combining different setting actions. Possible actions are: configuring a
800 // setting, negating a setting (adding "-no" prefix), and configuring/negating
801 // settings in a network section (adding "main." or "test." prefixes).
802 //
803 // - Combining settings from command line arguments and a config file.
804 //
805 // - Combining SoftSet and ForceSet calls.
806 //
807 // - Testing "main" and "testnet4" network values to make sure settings from network
808 // sections are applied and to check for mainnet-specific behaviors like
809 // inheriting settings from the default section.
810 //
811 // - Testing network-specific settings like "-wallet", that may be ignored
812 // outside a network section, and non-network specific settings like "-server"
813 // that aren't sensitive to the network.
814 //
815 struct ArgsMergeTestingSetup : public BasicTestingSetup {
816 //! Max number of actions to sequence together. Can decrease this when
817 //! debugging to make test results easier to understand.
818 static constexpr int MAX_ACTIONS = 3;
819
820 enum Action { NONE, SET, NEGATE, SECTION_SET, SECTION_NEGATE };
821 using ActionList = Action[MAX_ACTIONS];
822
823 //! Enumerate all possible test configurations.
824 template <typename Fn>
825 void ForEachMergeSetup(Fn&& fn)
826 {
827 ActionList arg_actions = {};
828 // command_line_options do not have sections. Only iterate over SET and NEGATE
829 ForEachNoDup(arg_actions, SET, NEGATE, [&] {
830 ActionList conf_actions = {};
831 ForEachNoDup(conf_actions, SET, SECTION_NEGATE, [&] {
832 for (bool soft_set : {false, true}) {
833 for (bool force_set : {false, true}) {
834 for (const std::string& section : {ChainTypeToString(ChainType::MAIN), ChainTypeToString(ChainType::TESTNET), ChainTypeToString(ChainType::TESTNET4), ChainTypeToString(ChainType::SIGNET)}) {
835 for (const std::string& network : {ChainTypeToString(ChainType::MAIN), ChainTypeToString(ChainType::TESTNET), ChainTypeToString(ChainType::TESTNET4), ChainTypeToString(ChainType::SIGNET)}) {
836 for (bool net_specific : {false, true}) {
837 fn(arg_actions, conf_actions, soft_set, force_set, section, network, net_specific);
838 }
839 }
840 }
841 }
842 }
843 });
844 });
845 }
846
847 //! Translate actions into a list of <key>=<value> setting strings.
848 std::vector<std::string> GetValues(const ActionList& actions,
849 const std::string& section,
850 const std::string& name,
851 const std::string& value_prefix)
852 {
853 std::vector<std::string> values;
854 int suffix = 0;
855 for (Action action : actions) {
856 if (action == NONE) break;
857 std::string prefix;
858 if (action == SECTION_SET || action == SECTION_NEGATE) prefix = section + ".";
859 if (action == SET || action == SECTION_SET) {
860 for (int i = 0; i < 2; ++i) {
861 values.push_back(prefix + name + "=" + value_prefix + ToString(++suffix));
862 }
863 }
864 if (action == NEGATE || action == SECTION_NEGATE) {
865 values.push_back(prefix + "no" + name + "=1");
866 }
867 }
868 return values;
869 }
870 };
871
872 // Regression test covering different ways config settings can be merged. The
873 // test parses and merges settings, representing the results as strings that get
874 // compared against an expected hash. To debug, the result strings can be dumped
875 // to a file (see comments below).
876 BOOST_FIXTURE_TEST_CASE(util_ArgsMerge, ArgsMergeTestingSetup)
877 {
878 CHash256 out_sha;
879 FILE* out_file = nullptr;
880 if (const char* out_path = getenv("ARGS_MERGE_TEST_OUT")) {
881 out_file = fsbridge::fopen(out_path, "w");
882 if (!out_file) throw std::system_error(errno, std::generic_category(), "fopen failed");
883 }
884
885 ForEachMergeSetup([&](const ActionList& arg_actions, const ActionList& conf_actions, bool soft_set, bool force_set,
886 const std::string& section, const std::string& network, bool net_specific) {
887 TestArgsManager parser;
888
889 std::string desc = "net=";
890 desc += network;
891 parser.SelectConfigNetwork(network);
892
893 const std::string& name = net_specific ? "wallet" : "server";
894 const std::string key = "-" + name;
895 unsigned int flags = ArgsManager::ALLOW_ANY;
896 if (net_specific) flags |= ArgsManager::NETWORK_ONLY;
897 parser.AddArg(key, name, flags, OptionsCategory::OPTIONS);
898
899 auto args = GetValues(arg_actions, section, name, "a");
900 std::vector<const char*> argv = {"ignored"};
901 for (auto& arg : args) {
902 arg.insert(0, "-");
903 desc += " ";
904 desc += arg;
905 argv.push_back(arg.c_str());
906 }
907 std::string error;
908 BOOST_CHECK(parser.ParseParameters(argv.size(), argv.data(), error));
909 BOOST_CHECK_EQUAL(error, "");
910
911 std::string conf;
912 for (auto& conf_val : GetValues(conf_actions, section, name, "c")) {
913 desc += " ";
914 desc += conf_val;
915 conf += conf_val;
916 conf += "\n";
917 }
918 std::istringstream conf_stream(conf);
919 BOOST_CHECK(parser.ReadConfigStream(conf_stream, "filepath", error));
920 BOOST_CHECK_EQUAL(error, "");
921
922 if (soft_set) {
923 desc += " soft";
924 parser.SoftSetArg(key, "soft1");
925 parser.SoftSetArg(key, "soft2");
926 }
927
928 if (force_set) {
929 desc += " force";
930 parser.ForceSetArg(key, "force1");
931 parser.ForceSetArg(key, "force2");
932 }
933
934 desc += " || ";
935
936 if (!parser.IsArgSet(key)) {
937 desc += "unset";
938 BOOST_CHECK(!parser.IsArgNegated(key));
939 BOOST_CHECK_EQUAL(parser.GetArg(key, "default"), "default");
940 BOOST_CHECK(parser.GetArgs(key).empty());
941 } else if (parser.IsArgNegated(key)) {
942 desc += "negated";
943 BOOST_CHECK_EQUAL(parser.GetArg(key, "default"), "0");
944 BOOST_CHECK(parser.GetArgs(key).empty());
945 } else {
946 desc += parser.GetArg(key, "default");
947 desc += " |";
948 for (const auto& arg : parser.GetArgs(key)) {
949 desc += " ";
950 desc += arg;
951 }
952 }
953
954 std::set<std::string> ignored = parser.GetUnsuitableSectionOnlyArgs();
955 if (!ignored.empty()) {
956 desc += " | ignored";
957 for (const auto& arg : ignored) {
958 desc += " ";
959 desc += arg;
960 }
961 }
962
963 desc += "\n";
964
965 out_sha.Write(MakeUCharSpan(desc));
966 if (out_file) {
967 BOOST_REQUIRE(fwrite(desc.data(), 1, desc.size(), out_file) == desc.size());
968 }
969 });
970
971 if (out_file) {
972 if (fclose(out_file)) throw std::system_error(errno, std::generic_category(), "fclose failed");
973 out_file = nullptr;
974 }
975
976 unsigned char out_sha_bytes[CSHA256::OUTPUT_SIZE];
977 out_sha.Finalize(out_sha_bytes);
978 std::string out_sha_hex = HexStr(out_sha_bytes);
979
980 // If check below fails, should manually dump the results with:
981 //
982 // ARGS_MERGE_TEST_OUT=results.txt ./test_bitcoin --run_test=argsman_tests/util_ArgsMerge
983 //
984 // And verify diff against previous results to make sure the changes are expected.
985 //
986 // Results file is formatted like:
987 //
988 // <input> || <IsArgSet/IsArgNegated/GetArg output> | <GetArgs output> | <GetUnsuitable output>
989 BOOST_CHECK_EQUAL(out_sha_hex, "f1ee5ab094cc43d16a6086fa7f2c10389e0f99902616b31bbf29189972ad1473");
990 }
991
992 // Similar test as above, but for ArgsManager::GetChainTypeString function.
993 struct ChainMergeTestingSetup : public BasicTestingSetup {
994 static constexpr int MAX_ACTIONS = 2;
995
996 enum Action { NONE, ENABLE_TEST, DISABLE_TEST, NEGATE_TEST, ENABLE_REG, DISABLE_REG, NEGATE_REG };
997 using ActionList = Action[MAX_ACTIONS];
998
999 //! Enumerate all possible test configurations.
1000 template <typename Fn>
1001 void ForEachMergeSetup(Fn&& fn)
1002 {
1003 ActionList arg_actions = {};
1004 ForEachNoDup(arg_actions, ENABLE_TEST, NEGATE_REG, [&] {
1005 ActionList conf_actions = {};
1006 ForEachNoDup(conf_actions, ENABLE_TEST, NEGATE_REG, [&] { fn(arg_actions, conf_actions); });
1007 });
1008 }
1009 };
1010
1011 BOOST_FIXTURE_TEST_CASE(util_ChainMerge, ChainMergeTestingSetup)
1012 {
1013 CHash256 out_sha;
1014 FILE* out_file = nullptr;
1015 if (const char* out_path = getenv("CHAIN_MERGE_TEST_OUT")) {
1016 out_file = fsbridge::fopen(out_path, "w");
1017 if (!out_file) throw std::system_error(errno, std::generic_category(), "fopen failed");
1018 }
1019
1020 ForEachMergeSetup([&](const ActionList& arg_actions, const ActionList& conf_actions) {
1021 TestArgsManager parser;
1022 parser.AddArg("-regtest", "regtest", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
1023 parser.AddArg("-testnet4", "testnet4", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
1024
1025 auto arg = [](Action action) { return action == ENABLE_TEST ? "-testnet4=1" :
1026 action == DISABLE_TEST ? "-testnet4=0" :
1027 action == NEGATE_TEST ? "-notestnet4=1" :
1028 action == ENABLE_REG ? "-regtest=1" :
1029 action == DISABLE_REG ? "-regtest=0" :
1030 action == NEGATE_REG ? "-noregtest=1" : nullptr; };
1031
1032 std::string desc;
1033 std::vector<const char*> argv = {"ignored"};
1034 for (Action action : arg_actions) {
1035 const char* argstr = arg(action);
1036 if (!argstr) break;
1037 argv.push_back(argstr);
1038 desc += " ";
1039 desc += argv.back();
1040 }
1041 std::string error;
1042 BOOST_CHECK(parser.ParseParameters(argv.size(), argv.data(), error));
1043 BOOST_CHECK_EQUAL(error, "");
1044
1045 std::string conf;
1046 for (Action action : conf_actions) {
1047 const char* argstr = arg(action);
1048 if (!argstr) break;
1049 desc += " ";
1050 desc += argstr + 1;
1051 conf += argstr + 1;
1052 conf += "\n";
1053 }
1054 std::istringstream conf_stream(conf);
1055 BOOST_CHECK(parser.ReadConfigStream(conf_stream, "filepath", error));
1056 BOOST_CHECK_EQUAL(error, "");
1057
1058 desc += " || ";
1059 try {
1060 desc += parser.GetChainTypeString();
1061 } catch (const std::runtime_error& e) {
1062 desc += "error: ";
1063 desc += e.what();
1064 }
1065 desc += "\n";
1066
1067 out_sha.Write(MakeUCharSpan(desc));
1068 if (out_file) {
1069 BOOST_REQUIRE(fwrite(desc.data(), 1, desc.size(), out_file) == desc.size());
1070 }
1071 });
1072
1073 if (out_file) {
1074 if (fclose(out_file)) throw std::system_error(errno, std::generic_category(), "fclose failed");
1075 out_file = nullptr;
1076 }
1077
1078 unsigned char out_sha_bytes[CSHA256::OUTPUT_SIZE];
1079 out_sha.Finalize(out_sha_bytes);
1080 std::string out_sha_hex = HexStr(out_sha_bytes);
1081
1082 // If check below fails, should manually dump the results with:
1083 //
1084 // CHAIN_MERGE_TEST_OUT=results.txt ./test_bitcoin --run_test=argsman_tests/util_ChainMerge
1085 //
1086 // And verify diff against previous results to make sure the changes are expected.
1087 //
1088 // Results file is formatted like:
1089 //
1090 // <input> || <output>
1091 BOOST_CHECK_EQUAL(out_sha_hex, "c0e33aab0c74e040ddcee9edad59e8148d8e1cacb3cccd9ea1a1f485cb6bad21");
1092 }
1093
1094 BOOST_AUTO_TEST_CASE(util_ReadWriteSettings)
1095 {
1096 // Test writing setting.
1097 TestArgsManager args1;
1098 args1.ForceSetArg("-datadir", fs::PathToString(m_path_root));
1099 args1.LockSettings([&](common::Settings& s) { s.rw_settings["name"] = "value"; });
1100 args1.WriteSettingsFile();
1101
1102 // Test reading setting.
1103 TestArgsManager args2;
1104 args2.ForceSetArg("-datadir", fs::PathToString(m_path_root));
1105 args2.ReadSettingsFile();
1106 args2.LockSettings([&](common::Settings& s) { BOOST_CHECK_EQUAL(s.rw_settings["name"].get_str(), "value"); });
1107
1108 // Test error logging, and remove previously written setting.
1109 {
1110 ASSERT_DEBUG_LOG("Failed renaming settings file");
1111 fs::remove(args1.GetDataDirBase() / "settings.json");
1112 fs::create_directory(args1.GetDataDirBase() / "settings.json");
1113 args2.WriteSettingsFile();
1114 fs::remove(args1.GetDataDirBase() / "settings.json");
1115 }
1116 }
1117
1118 BOOST_AUTO_TEST_SUITE_END()
1119